1 import Base 2 import ../../lib/logic.bend as L 3 import ../../lib/nat.bend as N 4 import ../../lib/u32.bend as U 5 import ../../lib/array.bend as AR 6 import ../../lib/list.bend as LL 7 import ../../../spec/lib/common.bend as SC 8 import ../../../src/containers/balanced_search_tree.bend as M 9 import ../../../src/containers/dynamic_array.bend as D 10 import ../../../src/containers/types/dynamic_array.bend as DE 11 import ../dynamic_array/layout.bend as LY 12 import ../dynamic_array/state.bend as DAS 13 import ../dynamic_array/steps.bend as DST 14 import ./state.bend as ST 15 import ./mk.bend as MK 16 import ./da.bend as DA 17 import ./arr.bend as AB 18 import ./prim.bend as PR 19 import ./nsl.bend as NSL 20 import ./mirror.bend as MI 21 22 # The simulation: every implementation function applied to realizations of 23 # mirror values is the realization of the mirror's result, whenever the 24 # arrays have their layout (MI.dg). (generated by 25 # tools/generators/tm_mirror.py; the primitives are hand-written in 26 # tools/generators/tm_hand/sim_head.bend) 27 28 29 # ---- reads ---- 30 31 def read_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Node, MI.read(~K, ~V, ~cmp, m, id)) == True{} : Bool}: 32 match m: 33 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 34 g_m 35 36 def read_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, m, id)) : M.TreeMap & M.Node}: 37 match m: 38 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 39 PR.read_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), id) 40 41 def get_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.get_id(~K, ~V, ~cmp, m, id)) == True{} : Bool}: 42 match m: 43 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 44 g_m 45 46 def get_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.get_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get_id(~K, ~V, ~cmp, m, id)) : M.TreeMap & Maybe<&2, V>}: 47 match m: 48 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 49 PR.get_id_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), id) 50 51 # ---- writes ---- 52 53 def len_wr_c(-K: Data, +nl: List<&2, M.Node>, +i: Nat, +x: M.Node, +b: Bool) -> {SC.length(M.Node, ST.pk(List<&2, M.Node>, b, SC.update(M.Node, nl, i, x), nl)) == SC.length(M.Node, nl) : Nat}: 54 match b: 55 case True{}: 56 LL.length_update(M.Node, nl, i, x) 57 case False{}: 58 {==} 59 60 def len_wr(-K: Data, +nl: List<&2, M.Node>, +id: Nat, +x: M.Node) -> {SC.length(M.Node, PR.wr_nl(K, nl, id, x)) == SC.length(M.Node, nl) : Nat}: 61 match id: 62 case 0n: 63 {==} 64 case 1n+i: 65 len_wr_c(K, nl, i, x, Nat.is_lt(i, SC.length(M.Node, nl))) 66 67 68 def len_ex_c(-V: Data, +pl: List<&2, Maybe<&2, V>>, +i: Nat, +v: Maybe<&2, V>, +b: Bool) -> {SC.length(Maybe<&2, V>, ST.pk(List<&2, Maybe<&2, V>>, b, SC.update(Maybe<&2, V>, pl, i, v), pl)) == SC.length(Maybe<&2, V>, pl) : Nat}: 69 match b: 70 case True{}: 71 LL.length_update(Maybe<&2, V>, pl, i, v) 72 case False{}: 73 {==} 74 75 def len_ex(-V: Data, +pl: List<&2, Maybe<&2, V>>, +id: Nat, +v: Maybe<&2, V>) -> {SC.length(Maybe<&2, V>, PR.ex_pl(V, pl, id, v)) == SC.length(Maybe<&2, V>, pl) : Nat}: 76 match id: 77 case 0n: 78 {==} 79 case 1n+i: 80 len_ex_c(V, pl, i, v, Nat.is_lt(i, SC.length(Maybe<&2, V>, pl))) 81 82 83 def write_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +node: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.write(~K, ~V, ~cmp, m, id, node)) == True{} : Bool}: 84 match m: 85 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 86 %Equal.sym(Nat, SC.length(M.Node, PR.wr_nl(K, nl, id, node)), SC.length(M.Node, nl), len_wr(K, nl, id, node)) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(_, SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, PR.wr_nl(K, nl, id, node)))))) == True{} : Bool} 87 %Equal.sym(Nat, SC.length(M.Node, PR.wr_nl(K, nl, id, node)), SC.length(M.Node, nl), len_wr(K, nl, id, node)) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), _)))) == True{} : Bool} 88 g_m 89 90 def write_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +node: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.write(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, node) == ST.real(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, m, id, node)) : M.TreeMap}: 91 match m: 92 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 93 PR.write_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), id, node) 94 95 def exchange_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +value: Maybe<&2, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, m, id, value)) == True{} : Bool}: 96 match m: 97 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 98 %Equal.sym(Nat, SC.length(Maybe<&2, V>, PR.ex_pl(V, pl, id, value)), SC.length(Maybe<&2, V>, pl), len_ex(V, pl, id, value)) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(_, SC.length(M.Node, nl))))) == True{} : Bool} 99 g_m 100 101 def exchange_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +value: Maybe<&2, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, value) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, m, id, value)) : M.TreeMap & Maybe<&2, V>}: 102 match m: 103 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 104 PR.exchange_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), id, value) 105 106 def clear_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.clear(~K, ~V, ~cmp, m)) == True{} : Bool}: 107 match m: 108 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 109 L.and_intro(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(0n, SC.pow2(d)), True{})), L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_intro(Nat.is_le(d, l), Bool.and(Nat.is_le(0n, SC.pow2(d)), True{}), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_intro(Nat.is_le(0n, SC.pow2(d)), True{}, N.zero_le(SC.pow2(d)), {==}))) 110 111 def clear_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.clear(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == ST.real(~K, ~V, ~cmp, MI.clear(~K, ~V, ~cmp, m)) : M.TreeMap}: 112 match m: 113 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 114 %Equal.sym(M.NodeStore, M.ns_clear(~K, ST.nodes(~K, l, d, nl)), ST.nodes(~K, l, d, Nil{}), NSL.ns_clear_ok(~K, l, d, nl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))))) : {M.TM{0n, 0n, 0n, 0n, 0n, _, D.clear_at(~Maybe<&2, V>, ST.pays(~V, l, d, pl))} == ST.real(~K, ~V, ~cmp, ST.SH{0n, 0n, 0n, 0n, 0n, l, d, Nil{}, Nil{}, t, fl}) : M.TreeMap} 115 %Equal.sym(D.DynArray<&2, Maybe<&2, V>>, D.clear_at(~Maybe<&2, V>, ST.pays(~V, l, d, pl)), DAS.real(Maybe<&2, V>, DAS.Sh{l, d, 0n, MK.mk(Maybe<&2, V>, d, Nil{})}), AB.blk_clear(~Maybe<&2, V>, l, d, pl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.subst(Nat, z => {Nat.is_le(z, SC.pow2(d)) == True{} : Bool}, SC.length(M.Node, nl), SC.length(Maybe<&2, V>, pl), Equal.sym(Nat, SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl), N.eq_from_is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))))), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)))))) : {M.TM{0n, 0n, 0n, 0n, 0n, ST.nodes(~K, l, d, Nil{}), 116 {==} 117 118 # ---- append ---- 119 120 121 def lt_pl(~K: Data, ~V: Data, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +x: Nat, +b: Bool, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +h: {Nat.is_lt(SC.length(M.Node, nl), x) == b : Bool}) -> {Nat.is_lt(SC.length(Maybe<&2, V>, pl), x) == b : Bool}: 122 L.subst(Nat, z => {Nat.is_lt(z, x) == b : Bool}, SC.length(M.Node, nl), SC.length(Maybe<&2, V>, pl), Equal.sym(Nat, SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl), N.eq_from_is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl), hp)), h) 123 124 def le_pl(~K: Data, ~V: Data, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +x: Nat, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +h: {Nat.is_le(SC.length(M.Node, nl), x) == True{} : Bool}) -> {Nat.is_le(SC.length(Maybe<&2, V>, pl), x) == True{} : Bool}: 125 L.subst(Nat, z => {Nat.is_le(z, x) == True{} : Bool}, SC.length(M.Node, nl), SC.length(Maybe<&2, V>, pl), Equal.sym(Nat, SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl), N.eq_from_is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl), hp)), h) 126 127 def app_g(~K: Data, ~V: Data, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +k: K, +v: V, +p: Nat, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +room: Bool, +hr: {Nat.is_lt(SC.length(M.Node, nl), SC.pow2(d)) == room : Bool}, +grow: Bool, +hgr: {Nat.is_lt(d, l) == grow : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, room, grow)) == True{} : Bool}: 128 match room grow: 129 case True{} _: 130 %Equal.sym(Nat, SC.length(M.Node, SC.snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})), 1n+SC.length(M.Node, nl), LL.length_snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(_, SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, SC.snoc(Maybe<&2, V>, pl, Some{v})), SC.length(M.Node, SC.snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})))))) == True{} : Bool} 131 %Equal.sym(Nat, SC.length(M.Node, SC.snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})), 1n+SC.length(M.Node, nl), LL.length_snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, SC.snoc(Maybe<&2, V>, pl, Some{v})), _)))) == True{} : Bool} 132 %Equal.sym(Nat, SC.length(Maybe<&2, V>, SC.snoc(Maybe<&2, V>, pl, Some{v})), 1n+SC.length(Maybe<&2, V>, pl), LL.length_snoc(Maybe<&2, V>, pl, Some{v})) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(_, 1n+SC.length(M.Node, nl))))) == True{} : Bool} 133 L.and_intro(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), hl, L.and_intro(Nat.is_le(d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), hd, L.and_intro(Nat.is_le(1n+SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), N.lt_succ_le_succ(SC.length(M.Node, nl), SC.pow2(d), hr), hp))) 134 case False{} True{}: 135 %Equal.sym(Nat, SC.length(M.Node, SC.snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})), 1n+SC.length(M.Node, nl), LL.length_snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(1n+d, l), Bool.and(Nat.is_le(_, SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, SC.snoc(Maybe<&2, V>, pl, Some{v})), SC.length(M.Node, SC.snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})))))) == True{} : Bool} 136 %Equal.sym(Nat, SC.length(M.Node, SC.snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})), 1n+SC.length(M.Node, nl), LL.length_snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(1n+d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node, nl), SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, SC.snoc(Maybe<&2, V>, pl, Some{v})), _)))) == True{} : Bool} 137 %Equal.sym(Nat, SC.length(Maybe<&2, V>, SC.snoc(Maybe<&2, V>, pl, Some{v})), 1n+SC.length(Maybe<&2, V>, pl), LL.length_snoc(Maybe<&2, V>, pl, Some{v})) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(1n+d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node, nl), SC.pow2(1n+d)), Nat.is_eq(_, 1n+SC.length(M.Node, nl))))) == True{} : Bool} 138 +h3 = N.lt_succ_le_succ(SC.length(M.Node, nl), SC.pow2(1n+d), N.le_lt_trans(SC.length(M.Node, nl), SC.pow2(d), SC.pow2(1n+d), hc, N.pow2_lt_succ(d))) 139 L.and_intro(Nat.is_le(l, 31n), Bool.and(Nat.is_le(1n+d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node, nl), SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), hl, L.and_intro(Nat.is_le(1n+d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node, nl), SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), N.lt_succ_le_succ(d, l, hgr), L.and_intro(Nat.is_le(1n+SC.length(M.Node, nl), SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), h3, hp))) 140 case False{} False{}: 141 L.and_intro(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), hl, L.and_intro(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), hd, L.and_intro(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), hc, hp))) 142 143 144 def app_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +k: K, +v: V, +p: Nat, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +room: Bool, +hr: {Nat.is_lt(SC.length(M.Node, nl), SC.pow2(d)) == room : Bool}, +grow: Bool, +hgr: {Nat.is_lt(d, l) == grow : Bool}) -> {M.append_nodes(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), k, v, 1n+SC.length(M.Node, nl), M.ns_push(~K, ST.nodes(~K, l, d, nl), M.N{True{}, 0n, 0n, p, k})) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, room, grow)) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>}: 145 match room grow: 146 case True{} _: 147 %Equal.sym(M.NodeStore & Result<&2, &2, DE.Error, Unit>, M.ns_push(~K, ST.nodes(~K, l, d, nl), M.N{True{}, 0n, 0n, p, k}), (ST.nodes(~K, l, d, SC.snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})), Done{Unit{}}), NSL.ns_push_room(~K, l, d, nl, hl, hd, hc, M.N{True{}, 0n, 0n, p, k}, hr)) : {M.append_nodes(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), k, v, 1n+SC.length(M.Node, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, True{}, grow)) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>} 148 %Equal.sym(D.DynArray<&2, Maybe<&2, V>> & Result<&2, &2, DE.Error, Unit>, D.push_at(~Maybe<&2, V>, ST.pays(~V, l, d, pl), Some{v}), (ST.pays(~V, l, d, SC.snoc(Maybe<&2, V>, pl, Some{v})), Done{Unit{}}), AB.blk_push_room(~Maybe<&2, V>, l, d, pl, hl, hd, le_pl(~K, ~V, nl, pl, SC.pow2(d), hp, hc), Some{v}, lt_pl(~K, ~V, nl, pl, SC.pow2(d), True{}, hp, hr))) : {M.append_values(~K, ~V, ~cmp, n, root, lo, hi, free, ST.nodes(~K, l, d, SC.snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})), k, v, 1n+SC.length(M.Node, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, True{}, grow)) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>} 149 {==} 150 case False{} True{}: 151 %Equal.sym(M.NodeStore & Result<&2, &2, DE.Error, Unit>, M.ns_push(~K, ST.nodes(~K, l, d, nl), M.N{True{}, 0n, 0n, p, k}), (ST.nodes(~K, l, 1n+d, SC.snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})), Done{Unit{}}), NSL.ns_push_grow(~K, l, d, nl, hl, hd, hc, M.N{True{}, 0n, 0n, p, k}, hr, hgr)) : {M.append_nodes(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), k, v, 1n+SC.length(M.Node, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, False{}, True{})) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>} 152 %Equal.sym(D.DynArray<&2, Maybe<&2, V>> & Result<&2, &2, DE.Error, Unit>, D.push_at(~Maybe<&2, V>, ST.pays(~V, l, d, pl), Some{v}), (ST.pays(~V, l, 1n+d, SC.snoc(Maybe<&2, V>, pl, Some{v})), Done{Unit{}}), AB.blk_push_grow(~Maybe<&2, V>, l, d, pl, hl, hd, le_pl(~K, ~V, nl, pl, SC.pow2(d), hp, hc), Some{v}, lt_pl(~K, ~V, nl, pl, SC.pow2(d), False{}, hp, hr), hgr)) : {M.append_values(~K, ~V, ~cmp, n, root, lo, hi, free, ST.nodes(~K, l, 1n+d, SC.snoc(M.Node, nl, M.N{True{}, 0n, 0n, p, k})), k, v, 1n+SC.length(M.Node, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, False{}, True{})) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>} 153 {==} 154 case False{} False{}: 155 %Equal.sym(M.NodeStore & Result<&2, &2, DE.Error, Unit>, M.ns_push(~K, ST.nodes(~K, l, d, nl), M.N{True{}, 0n, 0n, p, k}), (ST.nodes(~K, l, d, nl), Fail{DE.CapacityExceeded{}}), NSL.ns_push_full(~K, l, d, nl, hl, hd, hc, M.N{True{}, 0n, 0n, p, k}, hr, hgr)) : {M.append_nodes(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), k, v, 1n+SC.length(M.Node, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, False{}, False{})) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>} 156 {==} 157 158 def append_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +v: V, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected, Nat>, MI.append(~K, ~V, ~cmp, m, k, v, p)) == True{} : Bool}: 159 match m: 160 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 161 app_g(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), Nat.is_lt(SC.length(M.Node, nl), SC.pow2(d)), {==}, Nat.is_lt(d, l), {==}) 162 163 def append_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +v: V, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.append(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, v, p) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.append(~K, ~V, ~cmp, m, k, v, p)) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>}: 164 match m: 165 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 166 app_s(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), Nat.is_lt(SC.length(M.Node, nl), SC.pow2(d)), {==}, Nat.is_lt(d, l), {==}) 167 168 169 # ---- field writes: the mirror keeps the layout ---- 170 171 def set_left_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +v: Nat, +node: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_left_node(~K, ~V, ~cmp, m, id, v, node)) == True{} : Bool}: 172 match node: 173 case M.Free{+px2}: 174 g_m 175 case M.N{+px3, +px4, +px5, +px6, +px7}: 176 write_g(~K, ~V, ~cmp, m, id, M.N{px3, v, px5, px6, px7}, g_m) 177 178 def set_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +v: Nat, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.set_left_1(~K, ~V, ~cmp, id, v, pair_result)) == True{} : Bool}: 179 match pair_result: 180 case Tuple{+m1, +node}: 181 set_left_node_g(~K, ~V, ~cmp, m1, id, v, node, g_pair_result) 182 183 def set_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +v: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_left(~K, ~V, ~cmp, m, id, v)) == True{} : Bool}: 184 set_left_1_g(~K, ~V, ~cmp, id, v, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m)) 185 186 def set_right_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +v: Nat, +node: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_right_node(~K, ~V, ~cmp, m, id, v, node)) == True{} : Bool}: 187 match node: 188 case M.Free{+px2}: 189 g_m 190 case M.N{+px3, +px4, +px5, +px6, +px7}: 191 write_g(~K, ~V, ~cmp, m, id, M.N{px3, px4, v, px6, px7}, g_m) 192 193 def set_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +v: Nat, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.set_right_1(~K, ~V, ~cmp, id, v, pair_result)) == True{} : Bool}: 194 match pair_result: 195 case Tuple{+m1, +node}: 196 set_right_node_g(~K, ~V, ~cmp, m1, id, v, node, g_pair_result) 197 198 def set_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +v: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_right(~K, ~V, ~cmp, m, id, v)) == True{} : Bool}: 199 set_right_1_g(~K, ~V, ~cmp, id, v, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m)) 200 201 def set_parent_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +v: Nat, +node: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_parent_node(~K, ~V, ~cmp, m, id, v, node)) == True{} : Bool}: 202 match node: 203 case M.Free{+px2}: 204 g_m 205 case M.N{+px3, +px4, +px5, +px6, +px7}: 206 write_g(~K, ~V, ~cmp, m, id, M.N{px3, px4, px5, v, px7}, g_m) 207 208 def set_parent_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +v: Nat, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.set_parent_1(~K, ~V, ~cmp, id, v, pair_result)) == True{} : Bool}: 209 match pair_result: 210 case Tuple{+m1, +node}: 211 set_parent_node_g(~K, ~V, ~cmp, m1, id, v, node, g_pair_result) 212 213 def set_parent_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +v: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_parent(~K, ~V, ~cmp, m, id, v)) == True{} : Bool}: 214 set_parent_1_g(~K, ~V, ~cmp, id, v, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m)) 215 216 def set_red_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +v: Bool, +node: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_red_node(~K, ~V, ~cmp, m, id, v, node)) == True{} : Bool}: 217 match node: 218 case M.Free{+px2}: 219 g_m 220 case M.N{+px3, +px4, +px5, +px6, +px7}: 221 write_g(~K, ~V, ~cmp, m, id, M.N{v, px4, px5, px6, px7}, g_m) 222 223 def set_red_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +v: Bool, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.set_red_1(~K, ~V, ~cmp, id, v, pair_result)) == True{} : Bool}: 224 match pair_result: 225 case Tuple{+m1, +node}: 226 set_red_node_g(~K, ~V, ~cmp, m1, id, v, node, g_pair_result) 227 228 def set_red_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +v: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_red(~K, ~V, ~cmp, m, id, v)) == True{} : Bool}: 229 set_red_1_g(~K, ~V, ~cmp, id, v, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m)) 230 231 232 # ---- field writes: one array written is the node written ---- 233 234 def set_left_sc(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +i: Nat, +v: Nat, +y: M.Node, +hy: {ST.nth_or(M.Node, nl, i, M.Free{0n}) == y : M.Node}) -> {M.TM{n, root, lo, hi, free, M.ns_set_left(~K, ST.nodes(~K, l, d, nl), i, v), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_left_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, y)) : M.TreeMap}: 235 match y: 236 case M.Free{+z}: 237 %Equal.sym(M.NodeStore, M.ns_set_left(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, nl), NSL.left_set_free(~K, l, d, nl, hl, hd, hc, i, v, z, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_left_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.Free{z})) : M.TreeMap} 238 {==} 239 case M.N{+c, +lf, +rt, +q, +k}: 240 +hlt = NSL.nth_or_lt(~K, nl, i, M.N{c, lf, rt, q, k}, {==}, hy) 241 %Equal.sym(M.NodeStore, M.ns_set_left(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, SC.update(M.Node, nl, i, M.N{c, v, rt, q, k})), NSL.left_set_node(~K, l, d, nl, hl, hd, hc, i, v, c, lf, rt, q, k, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_left_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.N{c, lf, rt, q, k})) : M.TreeMap} 242 %Equal.sym(Bool, Nat.is_lt(i, SC.length(M.Node, nl)), True{}, hlt) : {M.TM{n, root, lo, hi, free, ST.nodes(~K, l, d, SC.update(M.Node, nl, i, M.N{c, v, rt, q, k})), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, ST.pk(List<&2, M.Node>, _, SC.update(M.Node, nl, i, M.N{c, v, rt, q, k}), nl), pl, t, fl}) : M.TreeMap} 243 {==} 244 245 def set_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +v: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, v) == ST.real(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m, id, v)) : M.TreeMap}: 246 match m id: 247 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 0n: 248 {==} 249 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 1n+ +i: 250 set_left_sc(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), i, v, ST.nth_or(M.Node, nl, i, M.Free{0n}), {==}) 251 252 def set_right_sc(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +i: Nat, +v: Nat, +y: M.Node, +hy: {ST.nth_or(M.Node, nl, i, M.Free{0n}) == y : M.Node}) -> {M.TM{n, root, lo, hi, free, M.ns_set_right(~K, ST.nodes(~K, l, d, nl), i, v), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_right_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, y)) : M.TreeMap}: 253 match y: 254 case M.Free{+z}: 255 %Equal.sym(M.NodeStore, M.ns_set_right(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, nl), NSL.right_set_free(~K, l, d, nl, hl, hd, hc, i, v, z, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_right_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.Free{z})) : M.TreeMap} 256 {==} 257 case M.N{+c, +lf, +rt, +q, +k}: 258 +hlt = NSL.nth_or_lt(~K, nl, i, M.N{c, lf, rt, q, k}, {==}, hy) 259 %Equal.sym(M.NodeStore, M.ns_set_right(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, SC.update(M.Node, nl, i, M.N{c, lf, v, q, k})), NSL.right_set_node(~K, l, d, nl, hl, hd, hc, i, v, c, lf, rt, q, k, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_right_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.N{c, lf, rt, q, k})) : M.TreeMap} 260 %Equal.sym(Bool, Nat.is_lt(i, SC.length(M.Node, nl)), True{}, hlt) : {M.TM{n, root, lo, hi, free, ST.nodes(~K, l, d, SC.update(M.Node, nl, i, M.N{c, lf, v, q, k})), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, ST.pk(List<&2, M.Node>, _, SC.update(M.Node, nl, i, M.N{c, lf, v, q, k}), nl), pl, t, fl}) : M.TreeMap} 261 {==} 262 263 def set_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +v: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, v) == ST.real(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m, id, v)) : M.TreeMap}: 264 match m id: 265 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 0n: 266 {==} 267 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 1n+ +i: 268 set_right_sc(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), i, v, ST.nth_or(M.Node, nl, i, M.Free{0n}), {==}) 269 270 def set_parent_sc(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +i: Nat, +v: Nat, +y: M.Node, +hy: {ST.nth_or(M.Node, nl, i, M.Free{0n}) == y : M.Node}) -> {M.TM{n, root, lo, hi, free, M.ns_set_parent(~K, ST.nodes(~K, l, d, nl), i, v), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_parent_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, y)) : M.TreeMap}: 271 match y: 272 case M.Free{+z}: 273 %Equal.sym(M.NodeStore, M.ns_set_parent(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, nl), NSL.parent_set_free(~K, l, d, nl, hl, hd, hc, i, v, z, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_parent_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.Free{z})) : M.TreeMap} 274 {==} 275 case M.N{+c, +lf, +rt, +q, +k}: 276 +hlt = NSL.nth_or_lt(~K, nl, i, M.N{c, lf, rt, q, k}, {==}, hy) 277 %Equal.sym(M.NodeStore, M.ns_set_parent(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, SC.update(M.Node, nl, i, M.N{c, lf, rt, v, k})), NSL.parent_set_node(~K, l, d, nl, hl, hd, hc, i, v, c, lf, rt, q, k, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_parent_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.N{c, lf, rt, q, k})) : M.TreeMap} 278 %Equal.sym(Bool, Nat.is_lt(i, SC.length(M.Node, nl)), True{}, hlt) : {M.TM{n, root, lo, hi, free, ST.nodes(~K, l, d, SC.update(M.Node, nl, i, M.N{c, lf, rt, v, k})), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, ST.pk(List<&2, M.Node>, _, SC.update(M.Node, nl, i, M.N{c, lf, rt, v, k}), nl), pl, t, fl}) : M.TreeMap} 279 {==} 280 281 def set_parent_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +v: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_parent(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, v) == ST.real(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, m, id, v)) : M.TreeMap}: 282 match m id: 283 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 0n: 284 {==} 285 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 1n+ +i: 286 set_parent_sc(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), i, v, ST.nth_or(M.Node, nl, i, M.Free{0n}), {==}) 287 288 def set_red_sc(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +i: Nat, +v: Bool, +y: M.Node, +hy: {ST.nth_or(M.Node, nl, i, M.Free{0n}) == y : M.Node}) -> {M.TM{n, root, lo, hi, free, M.ns_set_red(~K, ST.nodes(~K, l, d, nl), i, v), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_red_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, y)) : M.TreeMap}: 289 match y: 290 case M.Free{+z}: 291 %Equal.sym(M.NodeStore, M.ns_set_red(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, nl), NSL.red_set_free(~K, l, d, nl, hl, hd, hc, i, v, z, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_red_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.Free{z})) : M.TreeMap} 292 {==} 293 case M.N{+c, +lf, +rt, +q, +k}: 294 +hlt = NSL.nth_or_lt(~K, nl, i, M.N{c, lf, rt, q, k}, {==}, hy) 295 %Equal.sym(M.NodeStore, M.ns_set_red(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, SC.update(M.Node, nl, i, M.N{v, lf, rt, q, k})), NSL.red_set_node(~K, l, d, nl, hl, hd, hc, i, v, c, lf, rt, q, k, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_red_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.N{c, lf, rt, q, k})) : M.TreeMap} 296 %Equal.sym(Bool, Nat.is_lt(i, SC.length(M.Node, nl)), True{}, hlt) : {M.TM{n, root, lo, hi, free, ST.nodes(~K, l, d, SC.update(M.Node, nl, i, M.N{v, lf, rt, q, k})), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, ST.pk(List<&2, M.Node>, _, SC.update(M.Node, nl, i, M.N{v, lf, rt, q, k}), nl), pl, t, fl}) : M.TreeMap} 297 {==} 298 299 def set_red_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +v: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, v) == ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, id, v)) : M.TreeMap}: 300 match m id: 301 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 0n: 302 {==} 303 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 1n+ +i: 304 set_red_sc(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), i, v, ST.nth_or(M.Node, nl, i, M.Free{0n}), {==}) 305 306 # ---- the neighbour walks: field reads are the node list's ---- 307 308 309 def side_ok(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +left: Bool, +i: Nat) -> {M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), left, i) == (ST.nodes(~K, l, d, nl), M.pick(Nat, left, M.nleft(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})))) : M.NodeStore & Nat}: 310 match left: 311 case True{}: 312 NSL.left_at_ok(~K, l, d, nl, hl, hd, hc, i) 313 case False{}: 314 NSL.right_at_ok(~K, l, d, nl, hl, hd, hc, i) 315 316 def asc_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +x: Nat, +i: Nat, +forward: Bool, +y: M.Node, +hy: {ST.nth_or(M.Node, nl, i, M.Free{0n}) == y : M.Node}) -> {M.ascend_tag(~K, ~V, ~cmp, x, 1n+i, i, forward, (ST.nodes(~K, l, d, nl), M.ntag(~K, y))) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, y)) : M.NodeStore & M.Ascend}: 317 match y: 318 case M.Free{z}: 319 {==} 320 case M.N{True{}, +lf, +rt, +q, +k}: 321 %Equal.sym(M.NodeStore & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), forward, i), (ST.nodes(~K, l, d, nl), M.pick(Nat, forward, M.nleft(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, forward, i)) : {M.ascend_side(~K, ~V, ~cmp, x, 1n+i, i, _) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, M.N{True{}, lf, rt, q, k})) : M.NodeStore & M.Ascend} 322 %Equal.sym(M.NodeStore & Nat, M.ns_parent_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nparent(~K, ST.nth_or(M.Node, nl, i, M.Free{0n}))), NSL.parent_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.ascend_par(~K, ~V, ~cmp, x, 1n+i, M.pick(Nat, forward, M.nleft(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node, nl, i, M.Free{0n}))), _) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, M.N{True{}, lf, rt, q, k})) : M.NodeStore & M.Ascend} 323 %Equal.sym(M.Node, ST.nth_or(M.Node, nl, i, M.Free{0n}), M.N{True{}, lf, rt, q, k}, hy) : {(ST.nodes(~K, l, d, nl), M.ascend_choice(1n+i, 1n+i, M.nparent(~K, _), Nat.is_eq(x, M.pick(Nat, forward, M.nleft(~K, _), M.nright(~K, _))))) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, M.N{True{}, lf, rt, q, k})) : M.NodeStore & M.Ascend} 324 {==} 325 case M.N{False{}, +lf, +rt, +q, +k}: 326 %Equal.sym(M.NodeStore & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), forward, i), (ST.nodes(~K, l, d, nl), M.pick(Nat, forward, M.nleft(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, forward, i)) : {M.ascend_side(~K, ~V, ~cmp, x, 1n+i, i, _) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, M.N{False{}, lf, rt, q, k})) : M.NodeStore & M.Ascend} 327 %Equal.sym(M.NodeStore & Nat, M.ns_parent_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nparent(~K, ST.nth_or(M.Node, nl, i, M.Free{0n}))), NSL.parent_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.ascend_par(~K, ~V, ~cmp, x, 1n+i, M.pick(Nat, forward, M.nleft(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node, nl, i, M.Free{0n}))), _) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, M.N{False{}, lf, rt, q, k})) : M.NodeStore & M.Ascend} 328 %Equal.sym(M.Node, ST.nth_or(M.Node, nl, i, M.Free{0n}), M.N{False{}, lf, rt, q, k}, hy) : {(ST.nodes(~K, l, d, nl), M.ascend_choice(1n+i, 1n+i, M.nparent(~K, _), Nat.is_eq(x, M.pick(Nat, forward, M.nleft(~K, _), M.nright(~K, _))))) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, M.N{False{}, lf, rt, q, k})) : M.NodeStore & M.Ascend} 329 {==} 330 331 # one ascending step reads the node's tag, child and parent 332 def asc_at(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +x: Nat, +p: Nat, +forward: Bool) -> {M.ascend_at(~K, ~V, ~cmp, x, p, forward, ST.nodes(~K, l, d, nl)) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, p, forward, ST.nd(K, nl, p))) : M.NodeStore & M.Ascend}: 333 match p: 334 case 0n: 335 {==} 336 case 1n+ +i: 337 %Equal.sym(M.NodeStore & Nat, M.ns_tag_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.ntag(~K, ST.nth_or(M.Node, nl, i, M.Free{0n}))), NSL.tag_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.ascend_tag(~K, ~V, ~cmp, x, 1n+i, i, forward, _) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, ST.nth_or(M.Node, nl, i, M.Free{0n}))) : M.NodeStore & M.Ascend} 338 asc_y(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, x, i, forward, ST.nth_or(M.Node, nl, i, M.Free{0n}), {==}) 339 340 def ext_pick(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, -a: M.NodeStore, +fw: Bool, +lf: Nat, +rt: Nat) -> {(a, M.pick(Nat, Bool.not(fw), lf, rt)) == (a, M.pick(Nat, fw, rt, lf)) : M.NodeStore & Nat}: 341 match fw: 342 case True{}: 343 {==} 344 case False{}: 345 {==} 346 347 def ext_free(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, -a: M.NodeStore, +forward: Bool, +z: Nat) -> {(a, 0n) == (a, M.child(~K, M.Free{z}, forward)) : M.NodeStore & Nat}: 348 match forward: 349 case True{}: 350 {==} 351 case False{}: 352 {==} 353 354 def ext_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +forward: Bool, +j: Nat, +y: M.Node, +hy: {ST.nth_or(M.Node, nl, j, M.Free{0n}) == y : M.Node}) -> {M.extreme_tag(~K, ~V, ~cmp, forward, j, (ST.nodes(~K, l, d, nl), M.ntag(~K, y))) == (ST.nodes(~K, l, d, nl), M.child(~K, y, forward)) : M.NodeStore & Nat}: 355 match y: 356 case M.Free{+z}: 357 ext_free(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), forward, z) 358 case M.N{True{}, +lf, +rt, +q, +k}: 359 %Equal.sym(M.NodeStore & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), Bool.not(forward), j), (ST.nodes(~K, l, d, nl), M.pick(Nat, Bool.not(forward), M.nleft(~K, ST.nth_or(M.Node, nl, j, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node, nl, j, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, Bool.not(forward), j)) : {_ == (ST.nodes(~K, l, d, nl), M.child(~K, M.N{True{}, lf, rt, q, k}, forward)) : M.NodeStore & Nat} 360 %Equal.sym(M.Node, ST.nth_or(M.Node, nl, j, M.Free{0n}), M.N{True{}, lf, rt, q, k}, hy) : {(ST.nodes(~K, l, d, nl), M.pick(Nat, Bool.not(forward), M.nleft(~K, _), M.nright(~K, _))) == (ST.nodes(~K, l, d, nl), M.child(~K, M.N{True{}, lf, rt, q, k}, forward)) : M.NodeStore & Nat} 361 ext_pick(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), forward, lf, rt) 362 case M.N{False{}, +lf, +rt, +q, +k}: 363 %Equal.sym(M.NodeStore & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), Bool.not(forward), j), (ST.nodes(~K, l, d, nl), M.pick(Nat, Bool.not(forward), M.nleft(~K, ST.nth_or(M.Node, nl, j, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node, nl, j, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, Bool.not(forward), j)) : {_ == (ST.nodes(~K, l, d, nl), M.child(~K, M.N{False{}, lf, rt, q, k}, forward)) : M.NodeStore & Nat} 364 %Equal.sym(M.Node, ST.nth_or(M.Node, nl, j, M.Free{0n}), M.N{False{}, lf, rt, q, k}, hy) : {(ST.nodes(~K, l, d, nl), M.pick(Nat, Bool.not(forward), M.nleft(~K, _), M.nright(~K, _))) == (ST.nodes(~K, l, d, nl), M.child(~K, M.N{False{}, lf, rt, q, k}, forward)) : M.NodeStore & Nat} 365 ext_pick(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), forward, lf, rt) 366 367 # one descending step reads the node's tag and one child 368 def ext_at(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +forward: Bool, +j: Nat) -> {M.extreme_at(~K, ~V, ~cmp, forward, ST.nodes(~K, l, d, nl), j) == (ST.nodes(~K, l, d, nl), M.child(~K, ST.nth_or(M.Node, nl, j, M.Free{0n}), forward)) : M.NodeStore & Nat}: 369 %Equal.sym(M.NodeStore & Nat, M.ns_tag_at(~K, ST.nodes(~K, l, d, nl), j), (ST.nodes(~K, l, d, nl), M.ntag(~K, ST.nth_or(M.Node, nl, j, M.Free{0n}))), NSL.tag_at_ok(~K, l, d, nl, hl, hd, hc, j)) : {M.extreme_tag(~K, ~V, ~cmp, forward, j, _) == (ST.nodes(~K, l, d, nl), M.child(~K, ST.nth_or(M.Node, nl, j, M.Free{0n}), forward)) : M.NodeStore & Nat} 370 ext_y(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, forward, j, ST.nth_or(M.Node, nl, j, M.Free{0n}), {==}) 371 372 def asl(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +fuel: Nat, +forward: Bool, +st: M.Ascend) -> {M.ascend_slots_loop(~K, ~V, ~cmp, fuel, forward, (ST.nodes(~K, l, d, nl), st)) == (ST.nodes(~K, l, d, nl), MI.asc_loop(K, fuel, nl, forward, st)) : M.NodeStore & Nat}: 373 match fuel st: 374 case 0n _: 375 {==} 376 case 1n+f M.Ascend{x, p, True{}}: 377 {==} 378 case 1n+f M.Ascend{+x, +p, False{}}: 379 %Equal.sym(M.NodeStore & M.Ascend, M.ascend_at(~K, ~V, ~cmp, x, p, forward, ST.nodes(~K, l, d, nl)), (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, p, forward, ST.nd(K, nl, p))), asc_at(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, x, p, forward)) : {M.ascend_slots_loop(~K, ~V, ~cmp, f, forward, _) == (ST.nodes(~K, l, d, nl), MI.asc_loop(K, 1n+f, nl, forward, M.Ascend{x, p, False{}})) : M.NodeStore & Nat} 380 asl(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, f, forward, MI.asc_step(K, x, p, forward, ST.nd(K, nl, p))) 381 382 def esl(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +fuel: Nat, +forward: Bool, +id: Nat, +next: Nat) -> {M.extreme_slots_loop(~K, ~V, ~cmp, fuel, forward, id, (ST.nodes(~K, l, d, nl), next)) == (ST.nodes(~K, l, d, nl), MI.ext_loop(~K, fuel, nl, forward, id, next)) : M.NodeStore & Nat}: 383 match fuel next: 384 case 0n _: 385 {==} 386 case 1n+f 0n: 387 {==} 388 case 1n+f 1n+ +j: 389 %Equal.sym(M.NodeStore & Nat, M.extreme_at(~K, ~V, ~cmp, forward, ST.nodes(~K, l, d, nl), j), (ST.nodes(~K, l, d, nl), M.child(~K, ST.nth_or(M.Node, nl, j, M.Free{0n}), forward)), ext_at(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, forward, j)) : {M.extreme_slots_loop(~K, ~V, ~cmp, f, forward, 1n+j, _) == (ST.nodes(~K, l, d, nl), MI.ext_loop(~K, 1n+f, nl, forward, id, 1n+j)) : M.NodeStore & Nat} 390 esl(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, f, forward, 1n+j, M.child(~K, ST.nth_or(M.Node, nl, j, M.Free{0n}), forward)) 391 392 def nbl(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +n: Nat, +id: Nat, +p: Nat, +forward: Bool, +c: Nat) -> {M.neighbor_slots(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, id, p, forward, c) == (ST.nodes(~K, l, d, nl), MI.nbs(~K, nl, n, id, p, forward, c)) : M.NodeStore & Nat}: 393 match c: 394 case 0n: 395 asl(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, 1n+n, forward, M.Ascend{id, p, False{}}) 396 case 1n+ +j: 397 %Equal.sym(M.NodeStore & Nat, M.extreme_at(~K, ~V, ~cmp, Bool.not(forward), ST.nodes(~K, l, d, nl), j), (ST.nodes(~K, l, d, nl), M.child(~K, ST.nth_or(M.Node, nl, j, M.Free{0n}), Bool.not(forward))), ext_at(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, Bool.not(forward), j)) : {M.extreme_slots_loop(~K, ~V, ~cmp, 1n+n, Bool.not(forward), 1n+j, _) == (ST.nodes(~K, l, d, nl), MI.nbs(~K, nl, n, id, p, forward, 1n+j)) : M.NodeStore & Nat} 398 esl(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, 1n+n, Bool.not(forward), 1n+j, M.child(~K, ST.nth_or(M.Node, nl, j, M.Free{0n}), Bool.not(forward))) 399 400 def neighbor_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +forward: Bool, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.neighbor_node(~K, ~V, ~cmp, id, forward, r)) == True{} : Bool}: 401 match r: 402 case Tuple{ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}, +node}: 403 g_r 404 405 def neighbor_node_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +forward: Bool, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {M.neighbor_node(~K, ~V, ~cmp, id, forward, MI.rp(~K, ~V, ~cmp, M.Node, r)) == MI.rp(~K, ~V, ~cmp, Nat, MI.neighbor_node(~K, ~V, ~cmp, id, forward, r)) : M.TreeMap & Nat}: 406 match r: 407 case Tuple{ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}, +node}: 408 %Equal.sym(M.NodeStore & Nat, M.neighbor_slots(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, id, M.node_parent(~K, node), forward, M.child(~K, node, forward)), (ST.nodes(~K, l, d, nl), MI.nbs(~K, nl, n, id, M.node_parent(~K, node), forward, M.child(~K, node, forward))), nbl(~K, ~V, ~cmp, l, d, nl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_r), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_r)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_r))), n, id, M.node_parent(~K, node), forward, M.child(~K, node, forward))) : {M.neighbor_slots_finish(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), _) == MI.rp(~K, ~V, ~cmp, Nat, MI.neighbor_node(~K, ~V, ~cmp, id, forward, Tuple{ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, node})) : M.TreeMap & Nat} 409 {==} 410 411 def size_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.size(~K, ~V, ~cmp, m)) == True{} : Bool}: 412 match m: 413 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 414 g_m 415 416 def size_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.size(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Nat, MI.size(~K, ~V, ~cmp, m)) : M.TreeMap & Nat}: 417 match m: 418 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 419 {==} 420 421 422 def root_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.root_id(~K, ~V, ~cmp, m)) == True{} : Bool}: 423 match m: 424 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 425 g_m 426 427 def root_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.root_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Nat, MI.root_id(~K, ~V, ~cmp, m)) : M.TreeMap & Nat}: 428 match m: 429 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 430 {==} 431 432 433 def first_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.first_id(~K, ~V, ~cmp, m)) == True{} : Bool}: 434 match m: 435 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 436 g_m 437 438 def first_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.first_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Nat, MI.first_id(~K, ~V, ~cmp, m)) : M.TreeMap & Nat}: 439 match m: 440 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 441 {==} 442 443 444 def last_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.last_id(~K, ~V, ~cmp, m)) == True{} : Bool}: 445 match m: 446 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 447 g_m 448 449 def last_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.last_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Nat, MI.last_id(~K, ~V, ~cmp, m)) : M.TreeMap & Nat}: 450 match m: 451 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 452 {==} 453 454 455 def set_root_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +root: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_root(~K, ~V, ~cmp, m, root)) == True{} : Bool}: 456 match m: 457 case ST.SH{+n, +old, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 458 g_m 459 460 def set_root_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +root: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_root(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), root) == ST.real(~K, ~V, ~cmp, MI.set_root(~K, ~V, ~cmp, m, root)) : M.TreeMap}: 461 match m: 462 case ST.SH{+n, +old, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 463 {==} 464 465 466 def probe_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +k: K, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {MI.dgp(K, V, (M.Node & Cmp), MI.probe_node(~K, ~V, ~cmp, id, k, r)) == True{} : Bool}: 467 match r: 468 case Tuple{+px2, M.Free{+px4}}: 469 g_r 470 case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}: 471 g_r 472 473 def probe_node_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +k: K, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {M.probe_node(~K, ~V, ~cmp, id, k, MI.rp(~K, ~V, ~cmp, M.Node, r)) == MI.rp(~K, ~V, ~cmp, (M.Node & Cmp), MI.probe_node(~K, ~V, ~cmp, id, k, r)) : M.TreeMap & (M.Node & Cmp)}: 474 match r: 475 case Tuple{+px2, M.Free{+px4}}: 476 {==} 477 case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}: 478 {==} 479 480 481 def free_header_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +free: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.free_header(~K, ~V, ~cmp, m, free)) == True{} : Bool}: 482 match m: 483 case ST.SH{+n, +root, +lo, +hi, +old, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 484 g_m 485 486 def free_header_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +free: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.free_header(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), free) == ST.real(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, free)) : M.TreeMap}: 487 match m: 488 case ST.SH{+n, +root, +lo, +hi, +old, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 489 {==} 490 491 492 def reuse_slot_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected, Nat>, MI.reuse_slot_1(~K, ~V, ~cmp, id, pair_result)) == True{} : Bool}: 493 match pair_result: 494 case Tuple{+m1, +old}: 495 g_pair_result 496 497 def reuse_slot_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {M.reuse_slot_1(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, pair_result)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.reuse_slot_1(~K, ~V, ~cmp, id, pair_result)) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>}: 498 match pair_result: 499 case Tuple{+m1, +old}: 500 {==} 501 502 503 def put_replaced_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected, Maybe<&2, V>>, MI.put_replaced(~K, ~V, ~cmp, r)) == True{} : Bool}: 504 match r: 505 case Tuple{+m, +old}: 506 g_r 507 508 def put_replaced_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.put_replaced(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Maybe<&2, V>>, MI.put_replaced(~K, ~V, ~cmp, r)) : M.TreeMap & Result<&2, &2, M.Rejected, Maybe<&2, V>>}: 509 match r: 510 case Tuple{+m, +old}: 511 {==} 512 513 514 def contains_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.contains_found(~K, ~V, ~cmp, r)) == True{} : Bool}: 515 match r: 516 case Tuple{+m, M.Search{+id, +p, +left}}: 517 g_r 518 519 def contains_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.contains_found(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_found(~K, ~V, ~cmp, r)) : M.TreeMap & Bool}: 520 match r: 521 case Tuple{+m, M.Search{+id, +p, +left}}: 522 {==} 523 524 525 def move_successor_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +source: Nat, pair_result: ST.Sh & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.move_successor_3(~K, ~V, ~cmp, source, pair_result)) == True{} : Bool}: 526 match pair_result: 527 case Tuple{+m3, +old}: 528 g_pair_result 529 530 def move_successor_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +source: Nat, pair_result: ST.Sh & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {M.move_successor_3(~K, ~V, ~cmp, source, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, pair_result)) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_3(~K, ~V, ~cmp, source, pair_result)) : M.TreeMap & Nat}: 531 match pair_result: 532 case Tuple{+m3, +old}: 533 {==} 534 535 536 def release_header_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.release_header(~K, ~V, ~cmp, m, id)) == True{} : Bool}: 537 match m: 538 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 539 g_m 540 541 def release_header_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.release_header(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == ST.real(~K, ~V, ~cmp, MI.release_header(~K, ~V, ~cmp, m, id)) : M.TreeMap}: 542 match m: 543 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 544 {==} 545 546 547 def set_ends_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +lo: Nat, +hi: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_ends(~K, ~V, ~cmp, m, lo, hi)) == True{} : Bool}: 548 match m: 549 case ST.SH{+n, +root, +oldlo, +oldhi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 550 g_m 551 552 def set_ends_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +lo: Nat, +hi: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_ends(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), lo, hi) == ST.real(~K, ~V, ~cmp, MI.set_ends(~K, ~V, ~cmp, m, lo, hi)) : M.TreeMap}: 553 match m: 554 case ST.SH{+n, +root, +oldlo, +oldhi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 555 {==} 556 557 558 def is_empty_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.is_empty_1(~K, ~V, ~cmp, pair_result)) == True{} : Bool}: 559 match pair_result: 560 case Tuple{+m1, +n}: 561 g_pair_result 562 563 def is_empty_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {M.is_empty_1(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, pair_result)) == MI.rp(~K, ~V, ~cmp, Bool, MI.is_empty_1(~K, ~V, ~cmp, pair_result)) : M.TreeMap & Bool}: 564 match pair_result: 565 case Tuple{+m1, +n}: 566 {==} 567 568 569 def entry_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: Maybe<&2, K>, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry>, MI.entry_value(~K, ~V, ~cmp, k, r)) == True{} : Bool}: 570 match k r: 571 case Some{+px3} Tuple{+px4, Some{+px6}}: 572 g_r 573 case None{} Tuple{+px7, None{}}: 574 g_r 575 case None{} Tuple{+px7, Some{+px9}}: 576 g_r 577 case Some{+px3} Tuple{+px4, None{}}: 578 g_r 579 580 def entry_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: Maybe<&2, K>, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.entry_value(~K, ~V, ~cmp, k, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.entry_value(~K, ~V, ~cmp, k, r)) : M.TreeMap & Maybe<&2, M.Entry>}: 581 match k r: 582 case Some{+px3} Tuple{+px4, Some{+px6}}: 583 {==} 584 case None{} Tuple{+px7, None{}}: 585 {==} 586 case None{} Tuple{+px7, Some{+px9}}: 587 {==} 588 case Some{+px3} Tuple{+px4, None{}}: 589 {==} 590 591 592 def default_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fallback: V, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, V, MI.default_value(~K, ~V, ~cmp, fallback, r)) == True{} : Bool}: 593 match r: 594 case Tuple{+px2, None{}}: 595 g_r 596 case Tuple{+px2, Some{+px4}}: 597 g_r 598 599 def default_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fallback: V, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.default_value(~K, ~V, ~cmp, fallback, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rp(~K, ~V, ~cmp, V, MI.default_value(~K, ~V, ~cmp, fallback, r)) : M.TreeMap & V}: 600 match r: 601 case Tuple{+px2, None{}}: 602 {==} 603 case Tuple{+px2, Some{+px4}}: 604 {==} 605 606 607 def view_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +lower: M.Bound, +upper: M.Bound, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgr(K, V, MI.view_checked(~K, ~V, ~cmp, m, lower, upper, descending, valid)) == True{} : Bool}: 608 match valid: 609 case True{}: 610 g_m 611 case False{}: 612 g_m 613 614 def view_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +lower: M.Bound, +upper: M.Bound, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.view_checked(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), lower, upper, descending, valid) == MI.rr(~K, ~V, ~cmp, MI.view_checked(~K, ~V, ~cmp, m, lower, upper, descending, valid)) : Result<&1, &1, M.InvalidView, M.View>}: 615 match valid: 616 case True{}: 617 {==} 618 case False{}: 619 {==} 620 621 622 def head_map_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +upper: M.Bound, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgv(K, V, MI.head_map(~K, ~V, ~cmp, m, upper)) == True{} : Bool}: 623 g_m 624 625 def head_map_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +upper: M.Bound, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.head_map(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), upper) == MI.rv(~K, ~V, ~cmp, MI.head_map(~K, ~V, ~cmp, m, upper)) : M.View}: 626 {==} 627 628 629 def tail_map_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +lower: M.Bound, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgv(K, V, MI.tail_map(~K, ~V, ~cmp, m, lower)) == True{} : Bool}: 630 g_m 631 632 def tail_map_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +lower: M.Bound, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.tail_map(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), lower) == MI.rv(~K, ~V, ~cmp, MI.tail_map(~K, ~V, ~cmp, m, lower)) : M.View}: 633 {==} 634 635 636 def descending_map_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgv(K, V, MI.descending_map(~K, ~V, ~cmp, m)) == True{} : Bool}: 637 g_m 638 639 def descending_map_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.descending_map(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rv(~K, ~V, ~cmp, MI.descending_map(~K, ~V, ~cmp, m)) : M.View}: 640 {==} 641 642 643 def view_reverse_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgv(K, V, MI.view_reverse(~K, ~V, ~cmp, view)) == True{} : Bool}: 644 match view: 645 case MI.MV{+m, +lower, +upper, +descending}: 646 g_view 647 648 def view_reverse_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_reverse(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == MI.rv(~K, ~V, ~cmp, MI.view_reverse(~K, ~V, ~cmp, view)) : M.View}: 649 match view: 650 case MI.MV{+m, +lower, +upper, +descending}: 651 {==} 652 653 654 def view_finish_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dg(K, V, MI.view_finish(~K, ~V, ~cmp, view)) == True{} : Bool}: 655 match view: 656 case MI.MV{+m, +lower, +upper, +descending}: 657 g_view 658 659 def view_finish_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_finish(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == ST.real(~K, ~V, ~cmp, MI.view_finish(~K, ~V, ~cmp, view)) : M.TreeMap}: 660 match view: 661 case MI.MV{+m, +lower, +upper, +descending}: 662 {==} 663 664 665 def view_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound, +upper: M.Bound, +descending: Bool, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, V>, MI.view_value(~K, ~V, ~cmp, lower, upper, descending, r)) == True{} : Bool}: 666 match r: 667 case Tuple{+m, +v}: 668 g_r 669 670 def view_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound, +upper: M.Bound, +descending: Bool, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.view_value(~K, ~V, ~cmp, lower, upper, descending, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_value(~K, ~V, ~cmp, lower, upper, descending, r)) : M.View & Maybe<&2, V>}: 671 match r: 672 case Tuple{+m, +v}: 673 {==} 674 675 676 def view_put_finish_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound, +upper: M.Bound, +descending: Bool, r: ST.Sh & Result<&2, &2, M.Rejected, Maybe<&2, V>>, +g_r: {MI.dgp(K, V, Result<&2, &2, M.Rejected, Maybe<&2, V>>, r) == True{} : Bool}) -> {MI.dgvp(K, V, Result<&2, &2, M.Rejected, Maybe<&2, V>>, MI.view_put_finish(~K, ~V, ~cmp, lower, upper, descending, r)) == True{} : Bool}: 677 match r: 678 case Tuple{+m, +status}: 679 g_r 680 681 def view_put_finish_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound, +upper: M.Bound, +descending: Bool, r: ST.Sh & Result<&2, &2, M.Rejected, Maybe<&2, V>>, +g_r: {MI.dgp(K, V, Result<&2, &2, M.Rejected, Maybe<&2, V>>, r) == True{} : Bool}) -> {M.view_put_finish(~K, ~V, ~cmp, lower, upper, descending, MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Maybe<&2, V>>, r)) == MI.rvp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Maybe<&2, V>>, MI.view_put_finish(~K, ~V, ~cmp, lower, upper, descending, r)) : M.View & Result<&2, &2, M.Rejected, Maybe<&2, V>>}: 682 match r: 683 case Tuple{+m, +status}: 684 {==} 685 686 687 def cursor_started_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound, +upper: M.Bound, +forward: Bool, r: ST.Sh & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgc(K, V, MI.cursor_started(~K, ~V, ~cmp, lower, upper, forward, r)) == True{} : Bool}: 688 match r: 689 case Tuple{+m, +id}: 690 g_r 691 692 def cursor_started_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound, +upper: M.Bound, +forward: Bool, r: ST.Sh & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.cursor_started(~K, ~V, ~cmp, lower, upper, forward, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rc(~K, ~V, ~cmp, MI.cursor_started(~K, ~V, ~cmp, lower, upper, forward, r)) : M.Cursor}: 693 match r: 694 case Tuple{+m, +id}: 695 {==} 696 697 698 def iterator_finish_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dg(K, V, MI.iterator_finish(~K, ~V, ~cmp, cursor)) == True{} : Bool}: 699 match cursor: 700 case MI.MC{+m, +next, +current, +lower, +upper, +forward}: 701 g_cursor 702 703 def iterator_finish_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, cursor)) : M.TreeMap}: 704 match cursor: 705 case MI.MC{+m, +next, +current, +lower, +upper, +forward}: 706 {==} 707 708 709 def iterator_view_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgv(K, V, MI.iterator_view(~K, ~V, ~cmp, cursor)) == True{} : Bool}: 710 match cursor: 711 case MI.MC{+m, +next, +current, +lower, +upper, +forward}: 712 g_cursor 713 714 def iterator_view_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_view(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == MI.rv(~K, ~V, ~cmp, MI.iterator_view(~K, ~V, ~cmp, cursor)) : M.View}: 715 match cursor: 716 case MI.MC{+m, +next, +current, +lower, +upper, +forward}: 717 {==} 718 719 720 def iterator_yield_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +lower: M.Bound, +upper: M.Bound, +forward: Bool, +entry: M.Entry, r: ST.Sh & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry>, MI.iterator_yield(~K, ~V, ~cmp, id, lower, upper, forward, entry, r)) == True{} : Bool}: 721 match r: 722 case Tuple{+m, +next}: 723 g_r 724 725 def iterator_yield_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +lower: M.Bound, +upper: M.Bound, +forward: Bool, +entry: M.Entry, r: ST.Sh & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.iterator_yield(~K, ~V, ~cmp, id, lower, upper, forward, entry, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.iterator_yield(~K, ~V, ~cmp, id, lower, upper, forward, entry, r)) : M.Cursor & Maybe<&2, M.Entry>}: 726 match r: 727 case Tuple{+m, +next}: 728 {==} 729 730 731 def iterator_set_done_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +next: Nat, +current: Nat, +lower: M.Bound, +upper: M.Bound, +forward: Bool, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Result<&2, &2, M.Error, V>, MI.iterator_set_done(~K, ~V, ~cmp, next, current, lower, upper, forward, r)) == True{} : Bool}: 732 match r: 733 case Tuple{+px2, Some{+px4}}: 734 g_r 735 case Tuple{+px2, None{}}: 736 g_r 737 738 def iterator_set_done_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +next: Nat, +current: Nat, +lower: M.Bound, +upper: M.Bound, +forward: Bool, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.iterator_set_done(~K, ~V, ~cmp, next, current, lower, upper, forward, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rcp(~K, ~V, ~cmp, Result<&2, &2, M.Error, V>, MI.iterator_set_done(~K, ~V, ~cmp, next, current, lower, upper, forward, r)) : M.Cursor & Result<&2, &2, M.Error, V>}: 739 match r: 740 case Tuple{+px2, Some{+px4}}: 741 {==} 742 case Tuple{+px2, None{}}: 743 {==} 744 745 746 def iterator_relocated_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound, +upper: M.Bound, +forward: Bool, +removed: Maybe<&2, V>, r: ST.Sh & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_relocated(~K, ~V, ~cmp, lower, upper, forward, removed, r)) == True{} : Bool}: 747 match r: 748 case Tuple{+m, M.Search{+id, +p, +on_left}}: 749 g_r 750 751 def iterator_relocated_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound, +upper: M.Bound, +forward: Bool, +removed: Maybe<&2, V>, r: ST.Sh & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.iterator_relocated(~K, ~V, ~cmp, lower, upper, forward, removed, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_relocated(~K, ~V, ~cmp, lower, upper, forward, removed, r)) : M.Cursor & Maybe<&2, V>}: 752 match r: 753 case Tuple{+m, M.Search{+id, +p, +on_left}}: 754 {==} 755 756 757 def iterator_key_result_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor & Maybe<&2, M.Entry>, +g_r: {MI.dgcp(K, V, Maybe<&2, M.Entry>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, K>, MI.iterator_key_result(~K, ~V, ~cmp, r)) == True{} : Bool}: 758 match r: 759 case Tuple{+px2, None{}}: 760 g_r 761 case Tuple{+px2, Some{M.Entry{+px5, +px6}}}: 762 g_r 763 764 def iterator_key_result_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor & Maybe<&2, M.Entry>, +g_r: {MI.dgcp(K, V, Maybe<&2, M.Entry>, r) == True{} : Bool}) -> {M.iterator_key_result(~K, ~V, ~cmp, MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, K>, MI.iterator_key_result(~K, ~V, ~cmp, r)) : M.Cursor & Maybe<&2, K>}: 765 match r: 766 case Tuple{+px2, None{}}: 767 {==} 768 case Tuple{+px2, Some{M.Entry{+px5, +px6}}}: 769 {==} 770 771 772 def iterator_value_result_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor & Maybe<&2, M.Entry>, +g_r: {MI.dgcp(K, V, Maybe<&2, M.Entry>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_value_result(~K, ~V, ~cmp, r)) == True{} : Bool}: 773 match r: 774 case Tuple{+px2, None{}}: 775 g_r 776 case Tuple{+px2, Some{M.Entry{+px5, +px6}}}: 777 g_r 778 779 def iterator_value_result_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor & Maybe<&2, M.Entry>, +g_r: {MI.dgcp(K, V, Maybe<&2, M.Entry>, r) == True{} : Bool}) -> {M.iterator_value_result(~K, ~V, ~cmp, MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_value_result(~K, ~V, ~cmp, r)) : M.Cursor & Maybe<&2, V>}: 780 match r: 781 case Tuple{+px2, None{}}: 782 {==} 783 case Tuple{+px2, Some{M.Entry{+px5, +px6}}}: 784 {==} 785 786 787 def changed_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.changed_value(~K, ~V, ~cmp, r)) == True{} : Bool}: 788 match r: 789 case Tuple{+px2, None{}}: 790 g_r 791 case Tuple{+px2, Some{+px4}}: 792 g_r 793 794 def changed_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.changed_value(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.changed_value(~K, ~V, ~cmp, r)) : M.TreeMap & Bool}: 795 match r: 796 case Tuple{+px2, None{}}: 797 {==} 798 case Tuple{+px2, Some{+px4}}: 799 {==} 800 801 802 def view_contains_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MView & Maybe<&2, V>, +g_r: {MI.dgvp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgvp(K, V, Bool, MI.view_contains_value(~K, ~V, ~cmp, r)) == True{} : Bool}: 803 match r: 804 case Tuple{+px2, None{}}: 805 g_r 806 case Tuple{+px2, Some{+px4}}: 807 g_r 808 809 def view_contains_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MView & Maybe<&2, V>, +g_r: {MI.dgvp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.view_contains_value(~K, ~V, ~cmp, MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rvp(~K, ~V, ~cmp, Bool, MI.view_contains_value(~K, ~V, ~cmp, r)) : M.View & Bool}: 810 match r: 811 case Tuple{+px2, None{}}: 812 {==} 813 case Tuple{+px2, Some{+px4}}: 814 {==} 815 816 817 def view_entry_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +lower: M.Bound, +upper: M.Bound, +descending: Bool, +entry: M.Entry, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry>, MI.view_entry_checked(~K, ~V, ~cmp, m, lower, upper, descending, entry, valid)) == True{} : Bool}: 818 match valid: 819 case True{}: 820 g_m 821 case False{}: 822 g_m 823 824 def view_entry_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +lower: M.Bound, +upper: M.Bound, +descending: Bool, +entry: M.Entry, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.view_entry_checked(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), lower, upper, descending, entry, valid) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.view_entry_checked(~K, ~V, ~cmp, m, lower, upper, descending, entry, valid)) : M.View & Maybe<&2, M.Entry>}: 825 match valid: 826 case True{}: 827 {==} 828 case False{}: 829 {==} 830 831 832 def insert_header_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +p: Nat, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.insert_header(~K, ~V, ~cmp, m, id, p, on_left)) == True{} : Bool}: 833 match m: 834 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 835 g_m 836 837 def insert_header_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +p: Nat, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_header(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, p, on_left) == ST.real(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, m, id, p, on_left)) : M.TreeMap}: 838 match m: 839 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 840 {==} 841 842 843 def ascend_step_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +forward: Bool, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {MI.dgp(K, V, M.Ascend, MI.ascend_step_node(~K, ~V, ~cmp, x, p, forward, r)) == True{} : Bool}: 844 match r: 845 case Tuple{+px2, M.Free{+px4}}: 846 g_r 847 case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}: 848 g_r 849 850 def ascend_step_node_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +forward: Bool, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {M.ascend_step_node(~K, ~V, ~cmp, x, p, forward, MI.rp(~K, ~V, ~cmp, M.Node, r)) == MI.rp(~K, ~V, ~cmp, M.Ascend, MI.ascend_step_node(~K, ~V, ~cmp, x, p, forward, r)) : M.TreeMap & M.Ascend}: 851 match r: 852 case Tuple{+px2, M.Free{+px4}}: 853 {==} 854 case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}: 855 {==} 856 857 858 def refresh_ends_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lo: Nat, pair_result: ST.Sh & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.refresh_ends_3(~K, ~V, ~cmp, lo, pair_result)) == True{} : Bool}: 859 match pair_result: 860 case Tuple{+m3, +hi}: 861 set_ends_g(~K, ~V, ~cmp, m3, lo, hi, g_pair_result) 862 863 def refresh_ends_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lo: Nat, pair_result: ST.Sh & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {M.refresh_ends_3(~K, ~V, ~cmp, lo, MI.rp(~K, ~V, ~cmp, Nat, pair_result)) == ST.real(~K, ~V, ~cmp, MI.refresh_ends_3(~K, ~V, ~cmp, lo, pair_result)) : M.TreeMap}: 864 match pair_result: 865 case Tuple{+m3, +hi}: 866 set_ends_s(~K, ~V, ~cmp, m3, lo, hi, g_pair_result) 867 868 869 def is_empty_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.is_empty(~K, ~V, ~cmp, m)) == True{} : Bool}: 870 is_empty_1_g(~K, ~V, ~cmp, MI.size(~K, ~V, ~cmp, m), size_g(~K, ~V, ~cmp, m, g_m)) 871 872 def is_empty_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.is_empty(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Bool, MI.is_empty(~K, ~V, ~cmp, m)) : M.TreeMap & Bool}: 873 %Equal.sym(M.TreeMap & Nat, M.size(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.size(~K, ~V, ~cmp, m)), size_s(~K, ~V, ~cmp, m, g_m)) : {M.is_empty_1(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.is_empty(~K, ~V, ~cmp, m)) : M.TreeMap & Bool} 874 is_empty_1_s(~K, ~V, ~cmp, MI.size(~K, ~V, ~cmp, m), size_g(~K, ~V, ~cmp, m, g_m)) 875 876 877 def key_finish_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.key_finish(~K, ~V, ~cmp, r)) == True{} : Bool}: 878 match r: 879 case Tuple{+m, +node}: 880 g_r 881 882 def key_finish_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {M.key_finish(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, M.Node, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.key_finish(~K, ~V, ~cmp, r)) : M.TreeMap & Maybe<&2, K>}: 883 match r: 884 case Tuple{+m, +node}: 885 {==} 886 887 888 def range_unbounded_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.range_unbounded(~K, ~V, ~cmp, m, forward)) == True{} : Bool}: 889 match forward: 890 case True{}: 891 first_id_g(~K, ~V, ~cmp, m, g_m) 892 case False{}: 893 last_id_g(~K, ~V, ~cmp, m, g_m) 894 895 def range_unbounded_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.range_unbounded(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), forward) == MI.rp(~K, ~V, ~cmp, Nat, MI.range_unbounded(~K, ~V, ~cmp, m, forward)) : M.TreeMap & Nat}: 896 match forward: 897 case True{}: 898 first_id_s(~K, ~V, ~cmp, m, g_m) 899 case False{}: 900 last_id_s(~K, ~V, ~cmp, m, g_m) 901 902 903 def iterator_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgc(K, V, MI.iterator(~K, ~V, ~cmp, m)) == True{} : Bool}: 904 cursor_started_g(~K, ~V, ~cmp, M.Unbounded{}, M.Unbounded{}, True{}, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m)) 905 906 def iterator_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.iterator(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rc(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m)) : M.Cursor}: 907 %Equal.sym(M.TreeMap & Nat, M.first_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.first_id(~K, ~V, ~cmp, m)), first_id_s(~K, ~V, ~cmp, m, g_m)) : {M.cursor_started(~K, ~V, ~cmp, M.Unbounded{}, M.Unbounded{}, True{}, _) == MI.rc(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m)) : M.Cursor} 908 cursor_started_s(~K, ~V, ~cmp, M.Unbounded{}, M.Unbounded{}, True{}, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m)) 909 910 911 def descending_iterator_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgc(K, V, MI.descending_iterator(~K, ~V, ~cmp, m)) == True{} : Bool}: 912 cursor_started_g(~K, ~V, ~cmp, M.Unbounded{}, M.Unbounded{}, False{}, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m)) 913 914 def descending_iterator_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.descending_iterator(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rc(~K, ~V, ~cmp, MI.descending_iterator(~K, ~V, ~cmp, m)) : M.Cursor}: 915 %Equal.sym(M.TreeMap & Nat, M.last_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.last_id(~K, ~V, ~cmp, m)), last_id_s(~K, ~V, ~cmp, m, g_m)) : {M.cursor_started(~K, ~V, ~cmp, M.Unbounded{}, M.Unbounded{}, False{}, _) == MI.rc(~K, ~V, ~cmp, MI.descending_iterator(~K, ~V, ~cmp, m)) : M.Cursor} 916 cursor_started_s(~K, ~V, ~cmp, M.Unbounded{}, M.Unbounded{}, False{}, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m)) 917 918 919 def get_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.get_found(~K, ~V, ~cmp, r)) == True{} : Bool}: 920 match r: 921 case Tuple{+m, M.Search{+id, +p, +on_left}}: 922 get_id_g(~K, ~V, ~cmp, m, id, g_r) 923 924 def get_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.get_found(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get_found(~K, ~V, ~cmp, r)) : M.TreeMap & Maybe<&2, V>}: 925 match r: 926 case Tuple{+m, M.Search{+id, +p, +on_left}}: 927 get_id_s(~K, ~V, ~cmp, m, id, g_r) 928 929 930 def replace_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +v: V, r: ST.Sh & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.replace_found(~K, ~V, ~cmp, v, r)) == True{} : Bool}: 931 match r: 932 case Tuple{+px2, M.Search{0n, +px5, +px6}}: 933 g_r 934 case Tuple{+px2, M.Search{1n+ +px7, +px5, +px6}}: 935 exchange_g(~K, ~V, ~cmp, px2, 1n+px7, Some{v}, g_r) 936 937 def replace_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +v: V, r: ST.Sh & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.replace_found(~K, ~V, ~cmp, v, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.replace_found(~K, ~V, ~cmp, v, r)) : M.TreeMap & Maybe<&2, V>}: 938 match r: 939 case Tuple{+px2, M.Search{0n, +px5, +px6}}: 940 {==} 941 case Tuple{+px2, M.Search{1n+ +px7, +px5, +px6}}: 942 exchange_s(~K, ~V, ~cmp, px2, 1n+px7, Some{v}, g_r) 943 944 945 def sub_map_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +lower: M.Bound, +upper: M.Bound, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgr(K, V, MI.sub_map(~K, ~V, ~cmp, m, lower, upper)) == True{} : Bool}: 946 view_checked_g(~K, ~V, ~cmp, m, lower, upper, False{}, M.bounds_valid(~K, ~V, ~cmp, lower, upper), g_m) 947 948 def sub_map_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +lower: M.Bound, +upper: M.Bound, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.sub_map(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), lower, upper) == MI.rr(~K, ~V, ~cmp, MI.sub_map(~K, ~V, ~cmp, m, lower, upper)) : Result<&1, &1, M.InvalidView, M.View>}: 949 view_checked_s(~K, ~V, ~cmp, m, lower, upper, False{}, M.bounds_valid(~K, ~V, ~cmp, lower, upper), g_m) 950 951 952 def iterator_set_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor, +v: V, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgcp(K, V, Result<&2, &2, M.Error, V>, MI.iterator_set_value(~K, ~V, ~cmp, cursor, v)) == True{} : Bool}: 953 match cursor: 954 case MI.MC{+px2, +px3, 0n, +px5, +px6, +px7}: 955 g_cursor 956 case MI.MC{+px2, +px3, 1n+ +px8, +px5, +px6, +px7}: 957 iterator_set_done_g(~K, ~V, ~cmp, px3, 1n+px8, px5, px6, px7, MI.exchange(~K, ~V, ~cmp, px2, 1n+px8, Some{v}), exchange_g(~K, ~V, ~cmp, px2, 1n+px8, Some{v}, g_cursor)) 958 959 def iterator_set_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor, +v: V, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_set_value(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor), v) == MI.rcp(~K, ~V, ~cmp, Result<&2, &2, M.Error, V>, MI.iterator_set_value(~K, ~V, ~cmp, cursor, v)) : M.Cursor & Result<&2, &2, M.Error, V>}: 960 match cursor: 961 case MI.MC{+px2, +px3, 0n, +px5, +px6, +px7}: 962 {==} 963 case MI.MC{+px2, +px3, 1n+ +px8, +px5, +px6, +px7}: 964 %Equal.sym(M.TreeMap & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), 1n+px8, Some{v}), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, px2, 1n+px8, Some{v})), exchange_s(~K, ~V, ~cmp, px2, 1n+px8, Some{v}, g_cursor)) : {M.iterator_set_done(~K, ~V, ~cmp, px3, 1n+px8, px5, px6, px7, _) == MI.rcp(~K, ~V, ~cmp, Result<&2, &2, M.Error, V>, MI.iterator_set_value(~K, ~V, ~cmp, MI.MC{px2, px3, 1n+ px8, px5, px6, px7}, v)) : M.Cursor & Result<&2, &2, M.Error, V>} 965 iterator_set_done_s(~K, ~V, ~cmp, px3, 1n+px8, px5, px6, px7, MI.exchange(~K, ~V, ~cmp, px2, 1n+px8, Some{v}), exchange_g(~K, ~V, ~cmp, px2, 1n+px8, Some{v}, g_cursor)) 966 967 968 def entry_set_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgc(K, V, MI.entry_set(~K, ~V, ~cmp, m)) == True{} : Bool}: 969 iterator_g(~K, ~V, ~cmp, m, g_m) 970 971 def entry_set_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.entry_set(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rc(~K, ~V, ~cmp, MI.entry_set(~K, ~V, ~cmp, m)) : M.Cursor}: 972 iterator_s(~K, ~V, ~cmp, m, g_m) 973 974 975 def key_set_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgc(K, V, MI.key_set(~K, ~V, ~cmp, m)) == True{} : Bool}: 976 iterator_g(~K, ~V, ~cmp, m, g_m) 977 978 def key_set_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.key_set(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rc(~K, ~V, ~cmp, MI.key_set(~K, ~V, ~cmp, m)) : M.Cursor}: 979 iterator_s(~K, ~V, ~cmp, m, g_m) 980 981 982 def values_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgc(K, V, MI.values(~K, ~V, ~cmp, m)) == True{} : Bool}: 983 iterator_g(~K, ~V, ~cmp, m, g_m) 984 985 def values_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.values(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rc(~K, ~V, ~cmp, MI.values(~K, ~V, ~cmp, m)) : M.Cursor}: 986 iterator_s(~K, ~V, ~cmp, m, g_m) 987 988 989 def replace_if_apply_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +replacement: V, +equal: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.replace_if_apply(~K, ~V, ~cmp, m, id, replacement, equal)) == True{} : Bool}: 990 match equal: 991 case False{}: 992 g_m 993 case True{}: 994 changed_value_g(~K, ~V, ~cmp, MI.exchange(~K, ~V, ~cmp, m, id, Some{replacement}), exchange_g(~K, ~V, ~cmp, m, id, Some{replacement}, g_m)) 995 996 def replace_if_apply_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +replacement: V, +equal: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.replace_if_apply(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, replacement, equal) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_apply(~K, ~V, ~cmp, m, id, replacement, equal)) : M.TreeMap & Bool}: 997 match equal: 998 case False{}: 999 {==} 1000 case True{}: 1001 %Equal.sym(M.TreeMap & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, Some{replacement}), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, m, id, Some{replacement})), exchange_s(~K, ~V, ~cmp, m, id, Some{replacement}, g_m)) : {M.changed_value(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_apply(~K, ~V, ~cmp, m, id, replacement, True{})) : M.TreeMap & Bool} 1002 changed_value_s(~K, ~V, ~cmp, MI.exchange(~K, ~V, ~cmp, m, id, Some{replacement}), exchange_g(~K, ~V, ~cmp, m, id, Some{replacement}, g_m)) 1003 1004 1005 def replace_if_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +id: Nat, +expected: V, +replacement: V, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.replace_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, r)) == True{} : Bool}: 1006 match r: 1007 case Tuple{+px2, None{}}: 1008 g_r 1009 case Tuple{+px2, Some{+px4}}: 1010 replace_if_apply_g(~K, ~V, ~cmp, px2, id, replacement, eq(px4, expected), g_r) 1011 1012 def replace_if_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +id: Nat, +expected: V, +replacement: V, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.replace_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, r)) : M.TreeMap & Bool}: 1013 match r: 1014 case Tuple{+px2, None{}}: 1015 {==} 1016 case Tuple{+px2, Some{+px4}}: 1017 replace_if_apply_s(~K, ~V, ~cmp, px2, id, replacement, eq(px4, expected), g_r) 1018 1019 1020 def iterator_has_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +next: Nat, +current: Nat, +lower: M.Bound, +upper: M.Bound, +forward: Bool, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {MI.dgcp(K, V, Bool, MI.iterator_has_checked(~K, ~V, ~cmp, next, current, lower, upper, forward, r)) == True{} : Bool}: 1021 match r: 1022 case Tuple{+px2, M.Free{+px4}}: 1023 g_r 1024 case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}: 1025 g_r 1026 1027 def iterator_has_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +next: Nat, +current: Nat, +lower: M.Bound, +upper: M.Bound, +forward: Bool, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {M.iterator_has_checked(~K, ~V, ~cmp, next, current, lower, upper, forward, MI.rp(~K, ~V, ~cmp, M.Node, r)) == MI.rcp(~K, ~V, ~cmp, Bool, MI.iterator_has_checked(~K, ~V, ~cmp, next, current, lower, upper, forward, r)) : M.Cursor & Bool}: 1028 match r: 1029 case Tuple{+px2, M.Free{+px4}}: 1030 {==} 1031 case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}: 1032 {==} 1033 1034 1035 def view_entry_result_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound, +upper: M.Bound, +descending: Bool, r: ST.Sh & Maybe<&2, M.Entry>, +g_r: {MI.dgp(K, V, Maybe<&2, M.Entry>, r) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry>, MI.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, r)) == True{} : Bool}: 1036 match r: 1037 case Tuple{+px2, None{}}: 1038 g_r 1039 case Tuple{+px2, Some{M.Entry{+px5, +px6}}}: 1040 view_entry_checked_g(~K, ~V, ~cmp, px2, lower, upper, descending, M.Entry{px5, px6}, M.in_range(~K, ~V, ~cmp, px5, lower, upper), g_r) 1041 1042 def view_entry_result_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound, +upper: M.Bound, +descending: Bool, r: ST.Sh & Maybe<&2, M.Entry>, +g_r: {MI.dgp(K, V, Maybe<&2, M.Entry>, r) == True{} : Bool}) -> {M.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, r)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, r)) : M.View & Maybe<&2, M.Entry>}: 1043 match r: 1044 case Tuple{+px2, None{}}: 1045 {==} 1046 case Tuple{+px2, Some{M.Entry{+px5, +px6}}}: 1047 view_entry_checked_s(~K, ~V, ~cmp, px2, lower, upper, descending, M.Entry{px5, px6}, M.in_range(~K, ~V, ~cmp, px5, lower, upper), g_r) 1048 1049 1050 def attach_side_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +p: Nat, +x: Nat, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.attach_side(~K, ~V, ~cmp, m, p, x, on_left)) == True{} : Bool}: 1051 match p on_left: 1052 case 0n True{}: 1053 set_root_g(~K, ~V, ~cmp, m, x, g_m) 1054 case 0n False{}: 1055 set_root_g(~K, ~V, ~cmp, m, x, g_m) 1056 case 1n+ +px3 True{}: 1057 set_left_g(~K, ~V, ~cmp, m, 1n+px3, x, g_m) 1058 case 1n+ +px3 False{}: 1059 set_right_g(~K, ~V, ~cmp, m, 1n+px3, x, g_m) 1060 1061 def attach_side_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +p: Nat, +x: Nat, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.attach_side(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, x, on_left) == ST.real(~K, ~V, ~cmp, MI.attach_side(~K, ~V, ~cmp, m, p, x, on_left)) : M.TreeMap}: 1062 match p on_left: 1063 case 0n True{}: 1064 set_root_s(~K, ~V, ~cmp, m, x, g_m) 1065 case 0n False{}: 1066 set_root_s(~K, ~V, ~cmp, m, x, g_m) 1067 case 1n+ +px3 True{}: 1068 set_left_s(~K, ~V, ~cmp, m, 1n+px3, x, g_m) 1069 case 1n+ +px3 False{}: 1070 set_right_s(~K, ~V, ~cmp, m, 1n+px3, x, g_m) 1071 1072 1073 def replace_if_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +expected: V, +replacement: V, r: ST.Sh & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.replace_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, r)) == True{} : Bool}: 1074 match r: 1075 case Tuple{+m, M.Search{+id, +p, +on_left}}: 1076 replace_if_value_g(~K, ~V, ~cmp, ~eq, id, expected, replacement, MI.get_id(~K, ~V, ~cmp, m, id), get_id_g(~K, ~V, ~cmp, m, id, g_r)) 1077 1078 def replace_if_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +expected: V, +replacement: V, r: ST.Sh & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.replace_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, r)) : M.TreeMap & Bool}: 1079 match r: 1080 case Tuple{+m, M.Search{+id, +p, +on_left}}: 1081 %Equal.sym(M.TreeMap & Maybe<&2, V>, M.get_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get_id(~K, ~V, ~cmp, m, id)), get_id_s(~K, ~V, ~cmp, m, id, g_r)) : {M.replace_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, Tuple{m, M.Search{id, p, on_left}})) : M.TreeMap & Bool} 1082 replace_if_value_s(~K, ~V, ~cmp, ~eq, id, expected, replacement, MI.get_id(~K, ~V, ~cmp, m, id), get_id_g(~K, ~V, ~cmp, m, id, g_r)) 1083 1084 1085 def attach_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +p: Nat, +x: Nat, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.attach(~K, ~V, ~cmp, m, p, x, on_left)) == True{} : Bool}: 1086 set_parent_g(~K, ~V, ~cmp, MI.attach_side(~K, ~V, ~cmp, m, p, x, on_left), x, p, attach_side_g(~K, ~V, ~cmp, m, p, x, on_left, g_m)) 1087 1088 def attach_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +p: Nat, +x: Nat, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.attach(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, x, on_left) == ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m, p, x, on_left)) : M.TreeMap}: 1089 %Equal.sym(M.TreeMap, M.attach_side(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, x, on_left), ST.real(~K, ~V, ~cmp, MI.attach_side(~K, ~V, ~cmp, m, p, x, on_left)), attach_side_s(~K, ~V, ~cmp, m, p, x, on_left, g_m)) : {M.set_parent(~K, ~V, ~cmp, _, x, p) == ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m, p, x, on_left)) : M.TreeMap} 1090 set_parent_s(~K, ~V, ~cmp, MI.attach_side(~K, ~V, ~cmp, m, p, x, on_left), x, p, attach_side_g(~K, ~V, ~cmp, m, p, x, on_left, g_m)) 1091 1092 1093 def black_root_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.black_root_1(~K, ~V, ~cmp, pair_result)) == True{} : Bool}: 1094 match pair_result: 1095 case Tuple{+m1, +r}: 1096 set_red_g(~K, ~V, ~cmp, m1, r, False{}, g_pair_result) 1097 1098 def black_root_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {M.black_root_1(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, pair_result)) == ST.real(~K, ~V, ~cmp, MI.black_root_1(~K, ~V, ~cmp, pair_result)) : M.TreeMap}: 1099 match pair_result: 1100 case Tuple{+m1, +r}: 1101 set_red_s(~K, ~V, ~cmp, m1, r, False{}, g_pair_result) 1102 1103 1104 def reuse_slot_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +next: Nat, +p: Nat, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) == True{} : Bool}: 1105 reuse_slot_1_g(~K, ~V, ~cmp, id, MI.exchange(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}), id, Some{v}), exchange_g(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}), id, Some{v}, write_g(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}, free_header_g(~K, ~V, ~cmp, m, next, g_m)))) 1106 1107 def reuse_slot_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +next: Nat, +p: Nat, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.reuse_slot(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, next, p, k, v) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>}: 1108 %Equal.sym(M.TreeMap, M.free_header(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), next), ST.real(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next)), free_header_s(~K, ~V, ~cmp, m, next, g_m)) : {M.reuse_slot_1(~K, ~V, ~cmp, id, M.exchange(~K, ~V, ~cmp, M.write(~K, ~V, ~cmp, _, id, M.N{True{}, 0n, 0n, p, k}), id, Some{v})) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>} 1109 %Equal.sym(M.TreeMap, M.write(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next)), id, M.N{True{}, 0n, 0n, p, k}), ST.real(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k})), write_s(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}, free_header_g(~K, ~V, ~cmp, m, next, g_m))) : {M.reuse_slot_1(~K, ~V, ~cmp, id, M.exchange(~K, ~V, ~cmp, _, id, Some{v})) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>} 1110 %Equal.sym(M.TreeMap & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k})), id, Some{v}), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}), id, Some{v})), exchange_s(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}), id, Some{v}, write_g(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}, free_header_g(~K, ~V, ~cmp, m, next, g_m)))) : {M.reuse_slot_1(~K, ~V, ~cmp, id, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>} 1111 reuse_slot_1_s(~K, ~V, ~cmp, id, MI.exchange(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}), id, Some{v}), exchange_g(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}), id, Some{v}, write_g(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}, free_header_g(~K, ~V, ~cmp, m, next, g_m)))) 1112 1113 1114 def set_key_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +k: K, +node: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_key_node(~K, ~V, ~cmp, m, id, k, node)) == True{} : Bool}: 1115 match node: 1116 case M.Free{+px2}: 1117 g_m 1118 case M.N{+px3, +px4, +px5, +px6, +px7}: 1119 write_g(~K, ~V, ~cmp, m, id, M.N{px3, px4, px5, px6, k}, g_m) 1120 1121 def set_key_node_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +k: K, +node: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_key_node(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, k, node) == ST.real(~K, ~V, ~cmp, MI.set_key_node(~K, ~V, ~cmp, m, id, k, node)) : M.TreeMap}: 1122 match node: 1123 case M.Free{+px2}: 1124 {==} 1125 case M.N{+px3, +px4, +px5, +px6, +px7}: 1126 write_s(~K, ~V, ~cmp, m, id, M.N{px3, px4, px5, px6, k}, g_m) 1127 1128 1129 def recycle_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.recycle(~K, ~V, ~cmp, m, id)) == True{} : Bool}: 1130 match m: 1131 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 1132 release_header_g(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, M.Free{free}), id, write_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, M.Free{free}, g_m)) 1133 1134 def recycle_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.recycle(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == ST.real(~K, ~V, ~cmp, MI.recycle(~K, ~V, ~cmp, m, id)) : M.TreeMap}: 1135 match m: 1136 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 1137 %Equal.sym(M.TreeMap, M.write(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}), id, M.Free{free}), ST.real(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, M.Free{free})), write_s(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, M.Free{free}, g_m)) : {M.release_header(~K, ~V, ~cmp, _, id) == ST.real(~K, ~V, ~cmp, MI.recycle(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id)) : M.TreeMap} 1138 release_header_s(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, M.Free{free}), id, write_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, M.Free{free}, g_m)) 1139 1140 1141 # ---- entry_snapshot: the key and the value, the mirror's whole node ---- 1142 1143 1144 def es_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +y: M.Node, +w: Maybe<&2, V>) -> {M.snap_kv(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), ST.nodes(~K, l, d, nl), M.nkey(~K, y), w) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.entry_value(~K, ~V, ~cmp, M.node_key(~K, y), (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, w))) : M.TreeMap & Maybe<&2, M.Entry>}: 1145 match y w: 1146 case M.Free{z} None{}: 1147 {==} 1148 case M.Free{z} Some{x}: 1149 {==} 1150 case M.N{c, lf, rt, q, key} None{}: 1151 {==} 1152 case M.N{c, lf, rt, q, key} Some{v}: 1153 {==} 1154 1155 def es_n(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +id: Nat) -> {M.snap_at(~K, ~V, ~cmp, id, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl})) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.entry_snapshot(~K, ~V, ~cmp, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id))) : M.TreeMap & Maybe<&2, M.Entry>}: 1156 match id: 1157 case 0n: 1158 {==} 1159 case 1n+ +i: 1160 %Equal.sym(M.TreeMap & Maybe<&2, V>, M.get_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}), 1n+i), (ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}), ST.pv(V, pl, 1n+i)), PR.get_id_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, 1n+i)) : {M.snap_value(~K, ~V, ~cmp, i, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.entry_snapshot(~K, ~V, ~cmp, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i))) : M.TreeMap & Maybe<&2, M.Entry>} 1161 %Equal.sym(M.NodeStore & Maybe<&2, K>, M.ns_key_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nkey(~K, ST.nth_or(M.Node, nl, i, M.Free{0n}))), NSL.key_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.snap_key(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), ST.nth_or(Maybe<&2, V>, pl, i, None{}), _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.entry_snapshot(~K, ~V, ~cmp, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i))) : M.TreeMap & Maybe<&2, M.Entry>} 1162 es_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, ST.nth_or(M.Node, nl, i, M.Free{0n}), ST.nth_or(Maybe<&2, V>, pl, i, None{})) 1163 1164 def es_m(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.snap_at(~K, ~V, ~cmp, id, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.entry_snapshot(~K, ~V, ~cmp, (m, id))) : M.TreeMap & Maybe<&2, M.Entry>}: 1165 match m: 1166 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 1167 es_n(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), id) 1168 1169 def entry_snapshot_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.entry_snapshot(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.entry_snapshot(~K, ~V, ~cmp, r)) : M.TreeMap & Maybe<&2, M.Entry>}: 1170 match r: 1171 case Tuple{+m, +id}: 1172 es_m(~K, ~V, ~cmp, m, id, g_r) 1173 1174 def entry_snapshot_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry>, MI.entry_snapshot_value(~K, ~V, ~cmp, id, r)) == True{} : Bool}: 1175 match r: 1176 case Tuple{+m, +node}: 1177 entry_value_g(~K, ~V, ~cmp, M.node_key(~K, node), MI.get_id(~K, ~V, ~cmp, m, id), get_id_g(~K, ~V, ~cmp, m, id, g_r)) 1178 1179 def entry_snapshot_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry>, MI.entry_snapshot(~K, ~V, ~cmp, r)) == True{} : Bool}: 1180 match r: 1181 case Tuple{+m, +id}: 1182 entry_snapshot_value_g(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_r)) 1183 1184 def rotate_left_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node, +yn: M.Node, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, pair_result)) == True{} : Bool}: 1185 match pair_result: 1186 case Tuple{+m3, +pn}: 1187 set_parent_g(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x), x, M.node_right(~K, xn), set_left_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x, attach_g(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x, set_right_g(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn), g_pair_result))))) 1188 1189 def rotate_left_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node, +yn: M.Node, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {M.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, MI.rp(~K, ~V, ~cmp, M.Node, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, pair_result)) : M.TreeMap}: 1190 match pair_result: 1191 case Tuple{+m3, +pn}: 1192 %Equal.sym(M.TreeMap, M.set_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m3), x, M.node_left(~K, yn)), ST.real(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn))), set_right_s(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn), g_pair_result)) : {M.set_parent(~K, ~V, ~cmp, M.set_left(~K, ~V, ~cmp, M.attach(~K, ~V, ~cmp, M.set_parent(~K, ~V, ~cmp, _, M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x), x, M.node_right(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap} 1193 %Equal.sym(M.TreeMap, M.set_parent(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn))), M.node_left(~K, yn), x), ST.real(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x)), set_parent_s(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x, set_right_g(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn), g_pair_result))) : {M.set_parent(~K, ~V, ~cmp, M.set_left(~K, ~V, ~cmp, M.attach(~K, ~V, ~cmp, _, M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x), x, M.node_right(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap} 1194 %Equal.sym(M.TreeMap, M.attach(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x)), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x))), attach_s(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x, set_right_g(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn), g_pair_result)))) : {M.set_parent(~K, ~V, ~cmp, M.set_left(~K, ~V, ~cmp, _, M.node_right(~K, xn), x), x, M.node_right(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap} 1195 %Equal.sym(M.TreeMap, M.set_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x))), M.node_right(~K, xn), x), ST.real(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x)), set_left_s(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x, attach_g(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x, set_right_g(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn), g_pair_result))))) : {M.set_parent(~K, ~V, ~cmp, _, x, M.node_right(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap} 1196 set_parent_s(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x), x, M.node_right(~K, xn), set_left_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x, attach_g(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x, set_right_g(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn), g_pair_result))))) 1197 1198 1199 def rotate_right_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node, +yn: M.Node, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, pair_result)) == True{} : Bool}: 1200 match pair_result: 1201 case Tuple{+m3, +pn}: 1202 set_parent_g(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x), x, M.node_left(~K, xn), set_right_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x, attach_g(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x, set_left_g(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn), g_pair_result))))) 1203 1204 def rotate_right_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node, +yn: M.Node, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {M.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, MI.rp(~K, ~V, ~cmp, M.Node, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, pair_result)) : M.TreeMap}: 1205 match pair_result: 1206 case Tuple{+m3, +pn}: 1207 %Equal.sym(M.TreeMap, M.set_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m3), x, M.node_right(~K, yn)), ST.real(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn))), set_left_s(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn), g_pair_result)) : {M.set_parent(~K, ~V, ~cmp, M.set_right(~K, ~V, ~cmp, M.attach(~K, ~V, ~cmp, M.set_parent(~K, ~V, ~cmp, _, M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x), x, M.node_left(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap} 1208 %Equal.sym(M.TreeMap, M.set_parent(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn))), M.node_right(~K, yn), x), ST.real(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x)), set_parent_s(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x, set_left_g(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn), g_pair_result))) : {M.set_parent(~K, ~V, ~cmp, M.set_right(~K, ~V, ~cmp, M.attach(~K, ~V, ~cmp, _, M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x), x, M.node_left(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap} 1209 %Equal.sym(M.TreeMap, M.attach(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x)), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x))), attach_s(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x, set_left_g(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn), g_pair_result)))) : {M.set_parent(~K, ~V, ~cmp, M.set_right(~K, ~V, ~cmp, _, M.node_left(~K, xn), x), x, M.node_left(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap} 1210 %Equal.sym(M.TreeMap, M.set_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x))), M.node_left(~K, xn), x), ST.real(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x)), set_right_s(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x, attach_g(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x, set_left_g(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn), g_pair_result))))) : {M.set_parent(~K, ~V, ~cmp, _, x, M.node_left(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap} 1211 set_parent_s(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x), x, M.node_left(~K, xn), set_right_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x, attach_g(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x, set_left_g(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn), g_pair_result))))) 1212 1213 1214 def black_root_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.black_root(~K, ~V, ~cmp, m)) == True{} : Bool}: 1215 black_root_1_g(~K, ~V, ~cmp, MI.root_id(~K, ~V, ~cmp, m), root_id_g(~K, ~V, ~cmp, m, g_m)) 1216 1217 def black_root_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.black_root(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == ST.real(~K, ~V, ~cmp, MI.black_root(~K, ~V, ~cmp, m)) : M.TreeMap}: 1218 %Equal.sym(M.TreeMap & Nat, M.root_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.root_id(~K, ~V, ~cmp, m)), root_id_s(~K, ~V, ~cmp, m, g_m)) : {M.black_root_1(~K, ~V, ~cmp, _) == ST.real(~K, ~V, ~cmp, MI.black_root(~K, ~V, ~cmp, m)) : M.TreeMap} 1219 black_root_1_s(~K, ~V, ~cmp, MI.root_id(~K, ~V, ~cmp, m), root_id_g(~K, ~V, ~cmp, m, g_m)) 1220 1221 1222 def alloc_read_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +p: Nat, +k: K, +v: V, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected, Nat>, MI.alloc_read(~K, ~V, ~cmp, id, p, k, v, r)) == True{} : Bool}: 1223 match r: 1224 case Tuple{+px2, M.Free{+px4}}: 1225 reuse_slot_g(~K, ~V, ~cmp, px2, id, px4, p, k, v, g_r) 1226 case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}: 1227 g_r 1228 1229 def alloc_read_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +p: Nat, +k: K, +v: V, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {M.alloc_read(~K, ~V, ~cmp, id, p, k, v, MI.rp(~K, ~V, ~cmp, M.Node, r)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected, Nat>, MI.alloc_read(~K, ~V, ~cmp, id, p, k, v, r)) : M.TreeMap & Result<&2, &2, M.Rejected, Nat>}: 1230 match r: 1231 case Tuple{+px2, M.Free{+px4}}: 1232 reuse_slot_s(~K, ~V, ~cmp, px2, id, px4, p, k, v, g_r) 1233 case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}: 1234 {==} 1235 1236 1237 def set_key_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +k: K, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.set_key_1(~K, ~V, ~cmp, id, k, pair_result)) == True{} : Bool}: 1238 match pair_result: 1239 case Tuple{+m1, +node}: 1240 set_key_node_g(~K, ~V, ~cmp, m1, id, k, node, g_pair_result) 1241 1242 def set_key_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +k: K, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {M.set_key_1(~K, ~V, ~cmp, id, k, MI.rp(~K, ~V, ~cmp, M.Node, pair_result)) == ST.real(~K, ~V, ~cmp, MI.set_key_1(~K, ~V, ~cmp, id, k, pair_result)) : M.TreeMap}: 1243 match pair_result: 1244 case Tuple{+m1, +node}: 1245 set_key_node_s(~K, ~V, ~cmp, m1, id, k, node, g_pair_result) 1246 1247 1248 def first_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry>, MI.first_entry(~K, ~V, ~cmp, m)) == True{} : Bool}: 1249 entry_snapshot_g(~K, ~V, ~cmp, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m)) 1250 1251 def first_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.first_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.first_entry(~K, ~V, ~cmp, m)) : M.TreeMap & Maybe<&2, M.Entry>}: 1252 %Equal.sym(M.TreeMap & Nat, M.first_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.first_id(~K, ~V, ~cmp, m)), first_id_s(~K, ~V, ~cmp, m, g_m)) : {M.entry_snapshot(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.first_entry(~K, ~V, ~cmp, m)) : M.TreeMap & Maybe<&2, M.Entry>} 1253 entry_snapshot_s(~K, ~V, ~cmp, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m)) 1254 1255 1256 def last_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry>, MI.last_entry(~K, ~V, ~cmp, m)) == True{} : Bool}: 1257 entry_snapshot_g(~K, ~V, ~cmp, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m)) 1258 1259 def last_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.last_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.last_entry(~K, ~V, ~cmp, m)) : M.TreeMap & Maybe<&2, M.Entry>}: 1260 %Equal.sym(M.TreeMap & Nat, M.last_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.last_id(~K, ~V, ~cmp, m)), last_id_s(~K, ~V, ~cmp, m, g_m)) : {M.entry_snapshot(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry>, MI.last_entry(~K, ~V, ~cmp, m)) : M.TreeMap & Maybe<&2, M.Entry>} 1261 entry_snapshot_s(~K, ~V, ~cmp, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m)) 1262 1263 1264 # ---- search: two field reads per level are the mirror's probes ---- 1265 1266 1267 # the order of a live node decides: descend (the rest by ih) or stop 1268 def sr_o(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +k: K, +f: Nat, +i: Nat, +p: Nat, +ol: Bool, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +hy: {ST.nth_or(M.Node, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node}, ih: @+id2: Nat -> @+p2: Nat -> @+ol2: Bool -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, p2, ol2, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id2, k))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, f, k, id2, p2, ol2, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id2, k))) : M.TreeMap & M.Search}, +c0: Cmp) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 1n+f, k, p, ol, (ST.nodes(~K, l, d, nl), (1n+i, Some{c0})))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, c0)))) : M.TreeMap & M.Search}: 1269 match c0: 1270 case LT{}: 1271 %Equal.sym(M.NodeStore & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), True{}, i), (ST.nodes(~K, l, d, nl), M.pick(Nat, True{}, M.nleft(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, True{}, i)) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, 1n+i, True{}, M.search_down2(~K, ~V, ~cmp, k, _))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, LT{})))) : M.TreeMap & M.Search} 1272 %Equal.sym(M.Node, ST.nth_or(M.Node, nl, i, M.Free{0n}), M.N{c, lf, rt, q, key}, hy) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, 1n+i, True{}, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), M.nleft(~K, _), k))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, LT{})))) : M.TreeMap & M.Search} 1273 ih(lf, 1n+i, True{}) 1274 case GT{}: 1275 %Equal.sym(M.NodeStore & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), False{}, i), (ST.nodes(~K, l, d, nl), M.pick(Nat, False{}, M.nleft(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, False{}, i)) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, 1n+i, False{}, M.search_down2(~K, ~V, ~cmp, k, _))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, GT{})))) : M.TreeMap & M.Search} 1276 %Equal.sym(M.Node, ST.nth_or(M.Node, nl, i, M.Free{0n}), M.N{c, lf, rt, q, key}, hy) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, 1n+i, False{}, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), M.nright(~K, _), k))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, GT{})))) : M.TreeMap & M.Search} 1277 ih(rt, 1n+i, False{}) 1278 case EQ{}: 1279 {==} 1280 1281 def sr_c(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +k: K, +f: Nat, +i: Nat, +p: Nat, +ol: Bool, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +hy: {ST.nth_or(M.Node, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node}, ih: @+id2: Nat -> @+p2: Nat -> @+ol2: Bool -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, p2, ol2, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id2, k))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, f, k, id2, p2, ol2, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id2, k))) : M.TreeMap & M.Search}, +c0: Cmp, +hco: {cmp(k, key) == c0 : Cmp}) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 1n+f, k, p, ol, (ST.nodes(~K, l, d, nl), (1n+i, Some{cmp(k, key)})))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, cmp(k, key))))) : M.TreeMap & M.Search}: 1282 %Equal.sym(Cmp, cmp(k, key), c0, hco) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 1n+f, k, p, ol, (ST.nodes(~K, l, d, nl), (1n+i, Some{_})))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, _)))) : M.TreeMap & M.Search} 1283 sr_o(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, f, i, p, ol, c, lf, rt, q, key, hy, ih, c0) 1284 1285 def sr_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +k: K, +f: Nat, +i: Nat, +p: Nat, +ol: Bool, +y: M.Node, +hy: {ST.nth_or(M.Node, nl, i, M.Free{0n}) == y : M.Node}, ih: @+id2: Nat -> @+p2: Nat -> @+ol2: Bool -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, p2, ol2, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id2, k))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, f, k, id2, p2, ol2, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id2, k))) : M.TreeMap & M.Search}) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 1n+f, k, p, ol, M.search_key(~K, ~V, ~cmp, 1n+i, k, (ST.nodes(~K, l, d, nl), M.nkey(~K, y))))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, y)))) : M.TreeMap & M.Search}: 1286 match y: 1287 case M.Free{z}: 1288 {==} 1289 case M.N{+c, +lf, +rt, +q, +key}: 1290 sr_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, f, i, p, ol, c, lf, rt, q, key, hy, ih, cmp(k, key), {==}) 1291 1292 def s0_o(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +k: K, +i: Nat, +p: Nat, +ol: Bool, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +c0: Cmp) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 0n, k, p, ol, (ST.nodes(~K, l, d, nl), (1n+i, Some{c0})))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 0n, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, c0)))) : M.TreeMap & M.Search}: 1293 match c0: 1294 case LT{}: 1295 {==} 1296 case GT{}: 1297 {==} 1298 case EQ{}: 1299 {==} 1300 1301 def s0_c(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +k: K, +i: Nat, +p: Nat, +ol: Bool, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +c0: Cmp, +hco: {cmp(k, key) == c0 : Cmp}) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 0n, k, p, ol, (ST.nodes(~K, l, d, nl), (1n+i, Some{cmp(k, key)})))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 0n, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, cmp(k, key))))) : M.TreeMap & M.Search}: 1302 %Equal.sym(Cmp, cmp(k, key), c0, hco) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 0n, k, p, ol, (ST.nodes(~K, l, d, nl), (1n+i, Some{_})))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 0n, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, _)))) : M.TreeMap & M.Search} 1303 s0_o(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, i, p, ol, c, lf, rt, q, key, c0) 1304 1305 def s0_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +k: K, +i: Nat, +p: Nat, +ol: Bool, +y: M.Node) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 0n, k, p, ol, M.search_key(~K, ~V, ~cmp, 1n+i, k, (ST.nodes(~K, l, d, nl), M.nkey(~K, y))))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 0n, k, 1n+i, p, ol, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, y)))) : M.TreeMap & M.Search}: 1306 match y: 1307 case M.Free{z}: 1308 {==} 1309 case M.N{+c, +lf, +rt, +q, +key}: 1310 s0_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, i, p, ol, c, lf, rt, q, key, cmp(k, key), {==}) 1311 1312 # the fast loop, the store put back into the map, is the mirror's loop 1313 def sr(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +k: K, +fuel: Nat, +id: Nat, +p: Nat, +ol: Bool) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, fuel, k, p, ol, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id, k))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, fuel, k, id, p, ol, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id, k))) : M.TreeMap & M.Search}: 1314 match fuel id: 1315 case 0n 0n: 1316 {==} 1317 case 0n 1n+ +i: 1318 %Equal.sym(M.NodeStore & Maybe<&2, K>, M.ns_key_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nkey(~K, ST.nth_or(M.Node, nl, i, M.Free{0n}))), NSL.key_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 0n, k, p, ol, M.search_key(~K, ~V, ~cmp, 1n+i, k, _))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 0n, k, 1n+i, p, ol, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, ST.nth_or(M.Node, nl, i, M.Free{0n}))))) : M.TreeMap & M.Search} 1319 s0_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, i, p, ol, ST.nth_or(M.Node, nl, i, M.Free{0n})) 1320 case 1n+f 0n: 1321 {==} 1322 case 1n+ +f 1n+ +i: 1323 %Equal.sym(M.NodeStore & Maybe<&2, K>, M.ns_key_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nkey(~K, ST.nth_or(M.Node, nl, i, M.Free{0n}))), NSL.key_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 1n+f, k, p, ol, M.search_key(~K, ~V, ~cmp, 1n+i, k, _))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, ST.nth_or(M.Node, nl, i, M.Free{0n}))))) : M.TreeMap & M.Search} 1324 sr_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, f, i, p, ol, ST.nth_or(M.Node, nl, i, M.Free{0n}), {==}, id2 => p2 => ol2 => sr(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, f, id2, p2, ol2)) 1325 1326 def search_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)) : M.TreeMap & M.Search}: 1327 match m: 1328 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 1329 sr(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), k, 1n+n, root, 0n, False{}) 1330 1331 1332 def probe_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, (M.Node & Cmp), MI.probe(~K, ~V, ~cmp, m, id, k)) == True{} : Bool}: 1333 probe_node_g(~K, ~V, ~cmp, id, k, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m)) 1334 1335 1336 def search_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +k: K, +id: Nat, +p: Nat, +on_left: Bool, st: ST.Sh & (M.Node & Cmp), +g_st: {MI.dgp(K, V, (M.Node & Cmp), st) == True{} : Bool}) -> {MI.dgp(K, V, M.Search, MI.search_loop(~K, ~V, ~cmp, fuel, k, id, p, on_left, st)) == True{} : Bool}: 1337 match fuel st: 1338 case 0n Tuple{+px4, Tuple{M.Free{+px8}, LT{}}}: 1339 g_st 1340 case 0n Tuple{+px4, Tuple{M.Free{+px8}, EQ{}}}: 1341 g_st 1342 case 0n Tuple{+px4, Tuple{M.Free{+px8}, GT{}}}: 1343 g_st 1344 case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, LT{}}}: 1345 g_st 1346 case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, EQ{}}}: 1347 g_st 1348 case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, GT{}}}: 1349 g_st 1350 case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, LT{}}}: 1351 g_st 1352 case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, EQ{}}}: 1353 g_st 1354 case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, GT{}}}: 1355 g_st 1356 case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, LT{}}}: 1357 search_loop_g(~K, ~V, ~cmp, px3, k, px20, id, True{}, MI.probe(~K, ~V, ~cmp, px14, px20, k), probe_g(~K, ~V, ~cmp, px14, px20, k, g_st)) 1358 case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, GT{}}}: 1359 search_loop_g(~K, ~V, ~cmp, px3, k, px21, id, False{}, MI.probe(~K, ~V, ~cmp, px14, px21, k), probe_g(~K, ~V, ~cmp, px14, px21, k, g_st)) 1360 case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, EQ{}}}: 1361 g_st 1362 1363 def search_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Search, MI.search(~K, ~V, ~cmp, m, k)) == True{} : Bool}: 1364 match m: 1365 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 1366 search_loop_g(~K, ~V, ~cmp, 1n+n, k, root, 0n, False{}, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, root, k), probe_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, root, k, g_m)) 1367 1368 def get_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.get(~K, ~V, ~cmp, m, k)) == True{} : Bool}: 1369 get_found_g(~K, ~V, ~cmp, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m)) 1370 1371 def get_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.get(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get(~K, ~V, ~cmp, m, k)) : M.TreeMap & Maybe<&2, V>}: 1372 %Equal.sym(M.TreeMap & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)), search_s(~K, ~V, ~cmp, m, k, g_m)) : {M.get_found(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get(~K, ~V, ~cmp, m, k)) : M.TreeMap & Maybe<&2, V>} 1373 get_found_s(~K, ~V, ~cmp, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m)) 1374 1375 1376 def contains_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.contains_key(~K, ~V, ~cmp, m, k)) == True{} : Bool}: 1377 contains_found_g(~K, ~V, ~cmp, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m)) 1378 1379 def contains_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.contains_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_key(~K, ~V, ~cmp, m, k)) : M.TreeMap & Bool}: 1380 %Equal.sym(M.TreeMap & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)), search_s(~K, ~V, ~cmp, m, k, g_m)) : {M.contains_found(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_key(~K, ~V, ~cmp, m, k)) : M.TreeMap & Bool} 1381 contains_found_s(~K, ~V, ~cmp, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m)) 1382 1383 1384 # ---- extreme: the field walk is the mirror's node walk ---- 1385 1386 1387 def xe_eq(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +fuel: Nat, +fw: Bool, +id: Nat, +next: Nat) -> {MI.extreme_loop(~K, ~V, ~cmp, fuel, fw, id, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, next)) == (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, MI.ext_loop(~K, fuel, nl, fw, id, next)) : ST.Sh & Nat}: 1388 match fuel next: 1389 case 0n 0n: 1390 {==} 1391 case 0n 1n+j: 1392 {==} 1393 case 1n+f 0n: 1394 {==} 1395 case 1n+f 1n+j: 1396 xe_eq(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, f, fw, 1n+j, M.child(~K, ST.nd(K, nl, 1n+j), fw)) 1397 1398 def xe_0(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +fw: Bool) -> {M.extreme_start(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, 0n, fw) == (ST.nodes(~K, l, d, nl), MI.ext_loop(~K, 1n+n, nl, fw, 0n, M.child(~K, ST.nd(K, nl, 0n), fw))) : M.NodeStore & Nat}: 1399 match fw: 1400 case True{}: 1401 {==} 1402 case False{}: 1403 {==} 1404 1405 def xe_n(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +id: Nat, +fw: Bool) -> {M.extreme_start(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, id, fw) == (ST.nodes(~K, l, d, nl), MI.ext_loop(~K, 1n+n, nl, fw, id, M.child(~K, ST.nd(K, nl, id), fw))) : M.NodeStore & Nat}: 1406 match id: 1407 case 0n: 1408 xe_0(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, fw) 1409 case 1n+ +j: 1410 %Equal.sym(M.NodeStore & Nat, M.extreme_at(~K, ~V, ~cmp, fw, ST.nodes(~K, l, d, nl), j), (ST.nodes(~K, l, d, nl), M.child(~K, ST.nth_or(M.Node, nl, j, M.Free{0n}), fw)), ext_at(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, fw, j)) : {M.extreme_slots_loop(~K, ~V, ~cmp, 1n+n, fw, 1n+j, _) == (ST.nodes(~K, l, d, nl), MI.ext_loop(~K, 1n+n, nl, fw, 1n+j, M.child(~K, ST.nd(K, nl, 1n+j), fw))) : M.NodeStore & Nat} 1411 esl(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, 1n+n, fw, 1n+j, M.child(~K, ST.nth_or(M.Node, nl, j, M.Free{0n}), fw)) 1412 1413 def extreme_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.extreme(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, forward) == MI.rp(~K, ~V, ~cmp, Nat, MI.extreme(~K, ~V, ~cmp, m, id, forward)) : M.TreeMap & Nat}: 1414 match m: 1415 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 1416 %Equal.sym(ST.Sh & Nat, MI.extreme(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id, forward), (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, MI.ext_loop(~K, 1n+n, nl, forward, id, M.child(~K, ST.nd(K, nl, id), forward))), xe_eq(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, 1n+n, forward, id, M.child(~K, ST.nd(K, nl, id), forward))) : {M.extreme(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}), id, forward) == MI.rp(~K, ~V, ~cmp, Nat, _) : M.TreeMap & Nat} 1417 %Equal.sym(M.NodeStore & Nat, M.extreme_start(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, id, forward), (ST.nodes(~K, l, d, nl), MI.ext_loop(~K, 1n+n, nl, forward, id, M.child(~K, ST.nd(K, nl, id), forward))), xe_n(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), id, forward)) : {M.neighbor_slots_finish(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), _) == MI.rp(~K, ~V, ~cmp, Nat, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, MI.ext_loop(~K, 1n+n, nl, forward, id, M.child(~K, ST.nd(K, nl, 1418 {==} 1419 1420 def extreme_probe_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +forward: Bool, r: ST.Sh & M.Node, +g_r: {MI.dgp(K, V, M.Node, r) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.extreme_probe(~K, ~V, ~cmp, forward, r)) == True{} : Bool}: 1421 match r: 1422 case Tuple{+m, +node}: 1423 g_r 1424 1425 def extreme_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +forward: Bool, +id: Nat, st: ST.Sh & Nat, +g_st: {MI.dgp(K, V, Nat, st) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.extreme_loop(~K, ~V, ~cmp, fuel, forward, id, st)) == True{} : Bool}: 1426 match fuel st: 1427 case 0n Tuple{+px4, 0n}: 1428 g_st 1429 case 0n Tuple{+px4, 1n+ +px6}: 1430 g_st 1431 case 1n+ +px3 Tuple{+px7, 0n}: 1432 g_st 1433 case 1n+ +px3 Tuple{+px7, 1n+ +px9}: 1434 extreme_loop_g(~K, ~V, ~cmp, px3, forward, 1n+px9, MI.extreme_probe(~K, ~V, ~cmp, forward, MI.read(~K, ~V, ~cmp, px7, 1n+px9)), extreme_probe_g(~K, ~V, ~cmp, forward, MI.read(~K, ~V, ~cmp, px7, 1n+px9), read_g(~K, ~V, ~cmp, px7, 1n+px9, g_st))) 1435 1436 def extreme_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.extreme(~K, ~V, ~cmp, m, id, forward)) == True{} : Bool}: 1437 match m: 1438 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 1439 extreme_loop_g(~K, ~V, ~cmp, 1n+n, forward, id, MI.extreme_probe(~K, ~V, ~cmp, forward, MI.read(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id)), extreme_probe_g(~K, ~V, ~cmp, forward, MI.read(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id), read_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, g_m))) 1440 1441 def replace_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.replace(~K, ~V, ~cmp, m, k, v)) == True{} : Bool}: 1442 replace_found_g(~K, ~V, ~cmp, v, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m)) 1443 1444 def replace_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.replace(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, v) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.replace(~K, ~V, ~cmp, m, k, v)) : M.TreeMap & Maybe<&2, V>}: 1445 %Equal.sym(M.TreeMap & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)), search_s(~K, ~V, ~cmp, m, k, g_m)) : {M.replace_found(~K, ~V, ~cmp, v, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.replace(~K, ~V, ~cmp, m, k, v)) : M.TreeMap & Maybe<&2, V>} 1446 replace_found_s(~K, ~V, ~cmp, v, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m)) 1447 1448 1449 def iterator_reseek_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: Maybe<&2, K>, +lower: M.Bound, +upper: M.Bound, +forward: Bool, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_reseek(~K, ~V, ~cmp, k, lower, upper, forward, r)) == True{} : Bool}: 1450 match k r: 1451 case None{} Tuple{+px4, +px5}: 1452 g_r 1453 case Some{+px3} Tuple{+px6, +px7}: 1454 iterator_relocated_g(~K, ~V, ~cmp, lower, upper, forward, px7, MI.search(~K, ~V, ~cmp, px6, px3), search_g(~K, ~V, ~cmp, px6, px3, g_r)) 1455 1456 def iterator_reseek_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: Maybe<&2, K>, +lower: M.Bound, +upper: M.Bound, +forward: Bool, r: ST.Sh & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.iterator_reseek(~K, ~V, ~cmp, k, lower, upper, forward, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_reseek(~K, ~V, ~cmp, k, lower, upper, forward, r)) : M.Cursor & Maybe<&2, V>}: 1457 match k r: 1458 case None{} Tuple{+px4, +px5}: 1459 {==} 1460 case Some{+px3} Tuple{+px6, +px7}: 1461 %Equal.sym(M.TreeMap & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px6), px3), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, px6, px3)), search_s(~K, ~V, ~cmp, px6, px3, g_r)) : {M.iterator_relocated(~K, ~V, ~cmp, lower, upper, forward, px7, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_reseek(~K, ~V, ~cmp, Some{px3}, lower, upper, forward, Tuple{px6, px7})) : M.Cursor & Maybe<&2, V>} 1462 iterator_relocated_s(~K, ~V, ~cmp, lower, upper, forward, px7, MI.search(~K, ~V, ~cmp, px6, px3), search_g(~K, ~V, ~cmp, px6, px3, g_r)) 1463 1464 1465 def replace_if_equal_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh, +k: K, +expected: V, +replacement: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.replace_if_equal(~K, ~V, ~cmp, ~eq, m, k, expected, replacement)) == True{} : Bool}: 1466 replace_if_found_g(~K, ~V, ~cmp, ~eq, expected, replacement, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m)) 1467 1468 def replace_if_equal_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh, +k: K, +expected: V, +replacement: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.replace_if_equal(~K, ~V, ~cmp, ~eq, ST.real(~K, ~V, ~cmp, m), k, expected, replacement) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_equal(~K, ~V, ~cmp, ~eq, m, k, expected, replacement)) : M.TreeMap & Bool}: 1469 %Equal.sym(M.TreeMap & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)), search_s(~K, ~V, ~cmp, m, k, g_m)) : {M.replace_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_equal(~K, ~V, ~cmp, ~eq, m, k, expected, replacement)) : M.TreeMap & Bool} 1470 replace_if_found_s(~K, ~V, ~cmp, ~eq, expected, replacement, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m)) 1471 1472 1473 def rotate_left_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_left_2(~K, ~V, ~cmp, x, xn, pair_result)) == True{} : Bool}: 1474 match pair_result: 1475 case Tuple{+m2, +yn}: 1476 rotate_left_3_g(~K, ~V, ~cmp, x, xn, yn, MI.read(~K, ~V, ~cmp, m2, M.node_parent(~K, xn)), read_g(~K, ~V, ~cmp, m2, M.node_parent(~K, xn), g_pair_result)) 1477 1478 def rotate_left_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {M.rotate_left_2(~K, ~V, ~cmp, x, xn, MI.rp(~K, ~V, ~cmp, M.Node, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_2(~K, ~V, ~cmp, x, xn, pair_result)) : M.TreeMap}: 1479 match pair_result: 1480 case Tuple{+m2, +yn}: 1481 %Equal.sym(M.TreeMap & M.Node, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), M.node_parent(~K, xn)), MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, m2, M.node_parent(~K, xn))), read_s(~K, ~V, ~cmp, m2, M.node_parent(~K, xn), g_pair_result)) : {M.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, _) == ST.real(~K, ~V, ~cmp, MI.rotate_left_2(~K, ~V, ~cmp, x, xn, Tuple{m2, yn})) : M.TreeMap} 1482 rotate_left_3_s(~K, ~V, ~cmp, x, xn, yn, MI.read(~K, ~V, ~cmp, m2, M.node_parent(~K, xn)), read_g(~K, ~V, ~cmp, m2, M.node_parent(~K, xn), g_pair_result)) 1483 1484 1485 def rotate_right_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_right_2(~K, ~V, ~cmp, x, xn, pair_result)) == True{} : Bool}: 1486 match pair_result: 1487 case Tuple{+m2, +yn}: 1488 rotate_right_3_g(~K, ~V, ~cmp, x, xn, yn, MI.read(~K, ~V, ~cmp, m2, M.node_parent(~K, xn)), read_g(~K, ~V, ~cmp, m2, M.node_parent(~K, xn), g_pair_result)) 1489 1490 def rotate_right_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {M.rotate_right_2(~K, ~V, ~cmp, x, xn, MI.rp(~K, ~V, ~cmp, M.Node, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_2(~K, ~V, ~cmp, x, xn, pair_result)) : M.TreeMap}: 1491 match pair_result: 1492 case Tuple{+m2, +yn}: 1493 %Equal.sym(M.TreeMap & M.Node, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), M.node_parent(~K, xn)), MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, m2, M.node_parent(~K, xn))), read_s(~K, ~V, ~cmp, m2, M.node_parent(~K, xn), g_pair_result)) : {M.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, _) == ST.real(~K, ~V, ~cmp, MI.rotate_right_2(~K, ~V, ~cmp, x, xn, Tuple{m2, yn})) : M.TreeMap} 1494 rotate_right_3_s(~K, ~V, ~cmp, x, xn, yn, MI.read(~K, ~V, ~cmp, m2, M.node_parent(~K, xn)), read_g(~K, ~V, ~cmp, m2, M.node_parent(~K, xn), g_pair_result)) 1495 1496 def probe_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, k) == MI.rp(~K, ~V, ~cmp, (M.Node & Cmp), MI.probe(~K, ~V, ~cmp, m, id, k)) : M.TreeMap & (M.Node & Cmp)}: 1497 %Equal.sym(M.TreeMap & M.Node, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, m, id)), read_s(~K, ~V, ~cmp, m, id, g_m)) : {M.probe_node(~K, ~V, ~cmp, id, k, _) == MI.rp(~K, ~V, ~cmp, (M.Node & Cmp), MI.probe(~K, ~V, ~cmp, m, id, k)) : M.TreeMap & (M.Node & Cmp)} 1498 probe_node_s(~K, ~V, ~cmp, id, k, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m)) 1499 1500 1501 def ascend_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +forward: Bool, st: ST.Sh & M.Ascend, +g_st: {MI.dgp(K, V, M.Ascend, st) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.ascend_loop(~K, ~V, ~cmp, fuel, forward, st)) == True{} : Bool}: 1502 match fuel st: 1503 case 0n Tuple{+px4, +px5}: 1504 g_st 1505 case 1n+ +px3 Tuple{+px6, M.Ascend{+px8, +px9, True{}}}: 1506 g_st 1507 case 1n+ +px3 Tuple{+px6, M.Ascend{+px8, +px9, False{}}}: 1508 ascend_loop_g(~K, ~V, ~cmp, px3, forward, MI.ascend_step_node(~K, ~V, ~cmp, px8, px9, forward, MI.read(~K, ~V, ~cmp, px6, px9)), ascend_step_node_g(~K, ~V, ~cmp, px8, px9, forward, MI.read(~K, ~V, ~cmp, px6, px9), read_g(~K, ~V, ~cmp, px6, px9, g_st))) 1509 1510 def ascend_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +forward: Bool, st: ST.Sh & M.Ascend, +g_st: {MI.dgp(K, V, M.Ascend, st) == True{} : Bool}) -> {M.ascend_loop(~K, ~V, ~cmp, fuel, forward, MI.rp(~K, ~V, ~cmp, M.Ascend, st)) == MI.rp(~K, ~V, ~cmp, Nat, MI.ascend_loop(~K, ~V, ~cmp, fuel, forward, st)) : M.TreeMap & Nat}: 1511 match fuel st: 1512 case 0n Tuple{+px4, +px5}: 1513 {==} 1514 case 1n+ +px3 Tuple{+px6, M.Ascend{+px8, +px9, True{}}}: 1515 {==} 1516 case 1n+ +px3 Tuple{+px6, M.Ascend{+px8, +px9, False{}}}: 1517 %Equal.sym(M.TreeMap & M.Node, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px6), px9), MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, px6, px9)), read_s(~K, ~V, ~cmp, px6, px9, g_st)) : {M.ascend_loop(~K, ~V, ~cmp, px3, forward, M.ascend_step_node(~K, ~V, ~cmp, px8, px9, forward, _)) == MI.rp(~K, ~V, ~cmp, Nat, MI.ascend_loop(~K, ~V, ~cmp, 1n+ px3, forward, Tuple{px6, M.Ascend{px8, px9, False{}}})) : M.TreeMap & Nat} 1518 %Equal.sym(M.TreeMap & M.Ascend, M.ascend_step_node(~K, ~V, ~cmp, px8, px9, forward, MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, px6, px9))), MI.rp(~K, ~V, ~cmp, M.Ascend, MI.ascend_step_node(~K, ~V, ~cmp, px8, px9, forward, MI.read(~K, ~V, ~cmp, px6, px9))), ascend_step_node_s(~K, ~V, ~cmp, px8, px9, forward, MI.read(~K, ~V, ~cmp, px6, px9), read_g(~K, ~V, ~cmp, px6, px9, g_st))) : {M.ascend_loop(~K, ~V, ~cmp, px3, forward, _) == MI.rp(~K, ~V, ~cmp, Nat, MI.ascend_loop(~K, ~V, ~cmp, 1n+ px3, forward, Tuple{px6, M.Ascend{px8, px9, False{}}})) : M.TreeMap & Nat} 1519 ascend_loop_s(~K, ~V, ~cmp, px3, forward, MI.ascend_step_node(~K, ~V, ~cmp, px8, px9, forward, MI.read(~K, ~V, ~cmp, px6, px9)), ascend_step_node_g(~K, ~V, ~cmp, px8, px9, forward, MI.read(~K, ~V, ~cmp, px6, px9), read_g(~K, ~V, ~cmp, px6, px9, g_st))) 1520 1521 1522 def neighbor_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.neighbor(~K, ~V, ~cmp, m, id, forward)) == True{} : Bool}: 1523 neighbor_node_g(~K, ~V, ~cmp, id, forward, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m)) 1524 1525 def neighbor_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.neighbor(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, forward) == MI.rp(~K, ~V, ~cmp, Nat, MI.neighbor(~K, ~V, ~cmp, m, id, forward)) : M.TreeMap & Nat}: 1526 %Equal.sym(M.TreeMap & M.Node, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, m, id)), read_s(~K, ~V, ~cmp, m, id, g_m)) : {M.neighbor_node(~K, ~V, ~cmp, id, forward, _) == MI.rp(~K, ~V, ~cmp, Nat, MI.neighbor(~K, ~V, ~cmp, m, id, forward)) : M.TreeMap & Nat} 1527 neighbor_node_s(~K, ~V, ~cmp, id, forward, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m)) 1528 1529 1530 def set_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_key(~K, ~V, ~cmp, m, id, k)) == True{} : Bool}: 1531 set_key_1_g(~K, ~V, ~cmp, id, k, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m)) 1532 1533 def set_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, k) == ST.real(~K, ~V, ~cmp, MI.set_key(~K, ~V, ~cmp, m, id, k)) : M.TreeMap}: 1534 %Equal.sym(M.TreeMap & M.Node, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, m, id)), read_s(~K, ~V, ~cmp, m, id, g_m)) : {M.set_key_1(~K, ~V, ~cmp, id, k, _) == ST.real(~K, ~V, ~cmp, MI.set_key(~K, ~V, ~cmp, m, id, k)) : M.TreeMap} 1535 set_key_1_s(~K, ~V, ~cmp, id, k, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m)) 1536 1537 1538 def refresh_ends_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +r: Nat, pair_result: ST.Sh & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.refresh_ends_2(~K, ~V, ~cmp, r, pair_result)) == True{} : Bool}: 1539 match pair_result: 1540 case Tuple{+m2, +lo}: 1541 refresh_ends_3_g(~K, ~V, ~cmp, lo, MI.extreme(~K, ~V, ~cmp, m2, r, True{}), extreme_g(~K, ~V, ~cmp, m2, r, True{}, g_pair_result)) 1542 1543 def refresh_ends_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +r: Nat, pair_result: ST.Sh & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {M.refresh_ends_2(~K, ~V, ~cmp, r, MI.rp(~K, ~V, ~cmp, Nat, pair_result)) == ST.real(~K, ~V, ~cmp, MI.refresh_ends_2(~K, ~V, ~cmp, r, pair_result)) : M.TreeMap}: 1544 match pair_result: 1545 case Tuple{+m2, +lo}: 1546 %Equal.sym(M.TreeMap & Nat, M.extreme(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), r, True{}), MI.rp(~K, ~V, ~cmp, Nat, MI.extreme(~K, ~V, ~cmp, m2, r, True{})), extreme_s(~K, ~V, ~cmp, m2, r, True{}, g_pair_result)) : {M.refresh_ends_3(~K, ~V, ~cmp, lo, _) == ST.real(~K, ~V, ~cmp, MI.refresh_ends_2(~K, ~V, ~cmp, r, Tuple{m2, lo})) : M.TreeMap} 1547 refresh_ends_3_s(~K, ~V, ~cmp, lo, MI.extreme(~K, ~V, ~cmp, m2, r, True{}), extreme_g(~K, ~V, ~cmp, m2, r, True{}, g_pair_result)) 1548 1549 1550 def key_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.key_id(~K, ~V, ~cmp, r)) == True{} : Bool}: 1551 match r: 1552 case Tuple{+m, +id}: 1553 key_finish_g(~K, ~V, ~cmp, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_r)) 1554 1555 def key_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.key_id(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.key_id(~K, ~V, ~cmp, r)) : M.TreeMap & Maybe<&2, K>}: 1556 match r: 1557 case Tuple{+m, +id}: 1558 %Equal.sym(M.TreeMap & M.Node, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, m, id)), read_s(~K, ~V, ~cmp, m, id, g_r)) : {M.key_finish(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.key_id(~K, ~V, ~cmp, Tuple{m, id})) : M.TreeMap & Maybe<&2, K>} 1559 key_finish_s(~K, ~V, ~cmp, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_r)) 1560 1561 1562 def get_or_default_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +fallback: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, V, MI.get_or_default(~K, ~V, ~cmp, m, k, fallback)) == True{} : Bool}: 1563 default_value_g(~K, ~V, ~cmp, fallback, MI.get(~K, ~V, ~cmp, m, k), get_g(~K, ~V, ~cmp, m, k, g_m)) 1564 1565 def get_or_default_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +fallback: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.get_or_default(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, fallback) == MI.rp(~K, ~V, ~cmp, V, MI.get_or_default(~K, ~V, ~cmp, m, k, fallback)) : M.TreeMap & V}: 1566 %Equal.sym(M.TreeMap & Maybe<&2, V>, M.get(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get(~K, ~V, ~cmp, m, k)), get_s(~K, ~V, ~cmp, m, k, g_m)) : {M.default_value(~K, ~V, ~cmp, fallback, _) == MI.rp(~K, ~V, ~cmp, V, MI.get_or_default(~K, ~V, ~cmp, m, k, fallback)) : M.TreeMap & V} 1567 default_value_s(~K, ~V, ~cmp, fallback, MI.get(~K, ~V, ~cmp, m, k), get_g(~K, ~V, ~cmp, m, k, g_m)) 1568 1569 1570 def view_get_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +lower: M.Bound, +upper: M.Bound, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, V>, MI.view_get_checked(~K, ~V, ~cmp, m, k, lower, upper, descending, valid)) == True{} : Bool}: 1571 match valid: 1572 case True{}: 1573 view_value_g(~K, ~V, ~cmp, lower, upper, descending, MI.get(~K, ~V, ~cmp, m, k), get_g(~K, ~V, ~cmp, m, k, g_m)) 1574 case False{}: 1575 g_m 1576 1577 def view_get_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +lower: M.Bound, +upper: M.Bound, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.view_get_checked(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, lower, upper, descending, valid) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_get_checked(~K, ~V, ~cmp, m, k, lower, upper, descending, valid)) : M.View & Maybe<&2, V>}: 1578 match valid: 1579 case True{}: 1580 %Equal.sym(M.TreeMap & Maybe<&2, V>, M.get(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get(~K, ~V, ~cmp, m, k)), get_s(~K, ~V, ~cmp, m, k, g_m)) : {M.view_value(~K, ~V, ~cmp, lower, upper, descending, _) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_get_checked(~K, ~V, ~cmp, m, k, lower, upper, descending, True{})) : M.View & Maybe<&2, V>} 1581 view_value_s(~K, ~V, ~cmp, lower, upper, descending, MI.get(~K, ~V, ~cmp, m, k), get_g(~K, ~V, ~cmp, m, k, g_m)) 1582 case False{}: 1583 {==} 1584 1585 1586 def iterator_has_next_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgcp(K, V, Bool, MI.iterator_has_next(~K, ~V, ~cmp, cursor)) == True{} : Bool}: 1587 match cursor: 1588 case MI.MC{+m, +next, +current, +lower, +upper, +forward}: 1589 iterator_has_checked_g(~K, ~V, ~cmp, next, current, lower, upper, forward, MI.read(~K, ~V, ~cmp, m, next), read_g(~K, ~V, ~cmp, m, next, g_cursor)) 1590 1591 def iterator_has_next_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_has_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == MI.rcp(~K, ~V, ~cmp, Bool, MI.iterator_has_next(~K, ~V, ~cmp, cursor)) : M.Cursor & Bool}: 1592 match cursor: 1593 case MI.MC{+m, +next, +current, +lower, +upper, +forward}: 1594 %Equal.sym(M.TreeMap & M.Node, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), next), MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, m, next)), read_s(~K, ~V, ~cmp, m, next, g_cursor)) : {M.iterator_has_checked(~K, ~V, ~cmp, next, current, lower, upper, forward, _) == MI.rcp(~K, ~V, ~cmp, Bool, MI.iterator_has_next(~K, ~V, ~cmp, MI.MC{m, next, current, lower, upper, forward})) : M.Cursor & Bool} 1595 iterator_has_checked_s(~K, ~V, ~cmp, next, current, lower, upper, forward, MI.read(~K, ~V, ~cmp, m, next), read_g(~K, ~V, ~cmp, m, next, g_cursor)) 1596 1597 1598 def rotate_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_left_1(~K, ~V, ~cmp, x, pair_result)) == True{} : Bool}: 1599 match pair_result: 1600 case Tuple{+m1, +xn}: 1601 rotate_left_2_g(~K, ~V, ~cmp, x, xn, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, xn)), read_g(~K, ~V, ~cmp, m1, M.node_right(~K, xn), g_pair_result)) 1602 1603 def rotate_left_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {M.rotate_left_1(~K, ~V, ~cmp, x, MI.rp(~K, ~V, ~cmp, M.Node, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_1(~K, ~V, ~cmp, x, pair_result)) : M.TreeMap}: 1604 match pair_result: 1605 case Tuple{+m1, +xn}: 1606 %Equal.sym(M.TreeMap & M.Node, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_right(~K, xn)), MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, xn))), read_s(~K, ~V, ~cmp, m1, M.node_right(~K, xn), g_pair_result)) : {M.rotate_left_2(~K, ~V, ~cmp, x, xn, _) == ST.real(~K, ~V, ~cmp, MI.rotate_left_1(~K, ~V, ~cmp, x, Tuple{m1, xn})) : M.TreeMap} 1607 rotate_left_2_s(~K, ~V, ~cmp, x, xn, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, xn)), read_g(~K, ~V, ~cmp, m1, M.node_right(~K, xn), g_pair_result)) 1608 1609 1610 def rotate_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_right_1(~K, ~V, ~cmp, x, pair_result)) == True{} : Bool}: 1611 match pair_result: 1612 case Tuple{+m1, +xn}: 1613 rotate_right_2_g(~K, ~V, ~cmp, x, xn, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, xn)), read_g(~K, ~V, ~cmp, m1, M.node_left(~K, xn), g_pair_result)) 1614 1615 def rotate_right_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {M.rotate_right_1(~K, ~V, ~cmp, x, MI.rp(~K, ~V, ~cmp, M.Node, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_1(~K, ~V, ~cmp, x, pair_result)) : M.TreeMap}: 1616 match pair_result: 1617 case Tuple{+m1, +xn}: 1618 %Equal.sym(M.TreeMap & M.Node, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_left(~K, xn)), MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, xn))), read_s(~K, ~V, ~cmp, m1, M.node_left(~K, xn), g_pair_result)) : {M.rotate_right_2(~K, ~V, ~cmp, x, xn, _) == ST.real(~K, ~V, ~cmp, MI.rotate_right_1(~K, ~V, ~cmp, x, Tuple{m1, xn})) : M.TreeMap} 1619 rotate_right_2_s(~K, ~V, ~cmp, x, xn, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, xn)), read_g(~K, ~V, ~cmp, m1, M.node_left(~K, xn), g_pair_result)) 1620 1621 def search_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +k: K, +id: Nat, +p: Nat, +on_left: Bool, st: ST.Sh & (M.Node & Cmp), +g_st: {MI.dgp(K, V, (M.Node & Cmp), st) == True{} : Bool}) -> {M.search_loop(~K, ~V, ~cmp, fuel, k, id, p, on_left, MI.rp(~K, ~V, ~cmp, (M.Node & Cmp), st)) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, fuel, k, id, p, on_left, st)) : M.TreeMap & M.Search}: 1622 match fuel st: 1623 case 0n Tuple{+px4, Tuple{M.Free{+px8}, LT{}}}: 1624 {==} 1625 case 0n Tuple{+px4, Tuple{M.Free{+px8}, EQ{}}}: 1626 {==} 1627 case 0n Tuple{+px4, Tuple{M.Free{+px8}, GT{}}}: 1628 {==} 1629 case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, LT{}}}: 1630 {==} 1631 case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, EQ{}}}: 1632 {==} 1633 case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, GT{}}}: 1634 {==} 1635 case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, LT{}}}: 1636 {==} 1637 case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, EQ{}}}: 1638 {==} 1639 case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, GT{}}}: 1640 {==} 1641 case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, LT{}}}: 1642 %Equal.sym(M.TreeMap & (M.Node & Cmp), M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px14), px20, k), MI.rp(~K, ~V, ~cmp, (M.Node & Cmp), MI.probe(~K, ~V, ~cmp, px14, px20, k)), probe_s(~K, ~V, ~cmp, px14, px20, k, g_st)) : {M.search_loop(~K, ~V, ~cmp, px3, k, px20, id, True{}, _) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+ px3, k, id, p, on_left, Tuple{px14, Tuple{M.N{px19, px20, px21, px22, px23}, LT{}}})) : M.TreeMap & M.Search} 1643 search_loop_s(~K, ~V, ~cmp, px3, k, px20, id, True{}, MI.probe(~K, ~V, ~cmp, px14, px20, k), probe_g(~K, ~V, ~cmp, px14, px20, k, g_st)) 1644 case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, GT{}}}: 1645 %Equal.sym(M.TreeMap & (M.Node & Cmp), M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px14), px21, k), MI.rp(~K, ~V, ~cmp, (M.Node & Cmp), MI.probe(~K, ~V, ~cmp, px14, px21, k)), probe_s(~K, ~V, ~cmp, px14, px21, k, g_st)) : {M.search_loop(~K, ~V, ~cmp, px3, k, px21, id, False{}, _) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+ px3, k, id, p, on_left, Tuple{px14, Tuple{M.N{px19, px20, px21, px22, px23}, GT{}}})) : M.TreeMap & M.Search} 1646 search_loop_s(~K, ~V, ~cmp, px3, k, px21, id, False{}, MI.probe(~K, ~V, ~cmp, px14, px21, k), probe_g(~K, ~V, ~cmp, px14, px21, k, g_st)) 1647 case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, EQ{}}}: 1648 {==} 1649 1650 1651 def copy_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +target: Nat, +node: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.copy_key(~K, ~V, ~cmp, m, target, node)) == True{} : Bool}: 1652 match node: 1653 case M.Free{+px2}: 1654 g_m 1655 case M.N{+px3, +px4, +px5, +px6, +px7}: 1656 set_key_g(~K, ~V, ~cmp, m, target, px7, g_m) 1657 1658 def copy_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +target: Nat, +node: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.copy_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), target, node) == ST.real(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m, target, node)) : M.TreeMap}: 1659 match node: 1660 case M.Free{+px2}: 1661 {==} 1662 case M.N{+px3, +px4, +px5, +px6, +px7}: 1663 set_key_s(~K, ~V, ~cmp, m, target, px7, g_m) 1664 1665 1666 def refresh_ends_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.refresh_ends_1(~K, ~V, ~cmp, pair_result)) == True{} : Bool}: 1667 match pair_result: 1668 case Tuple{+m1, +r}: 1669 refresh_ends_2_g(~K, ~V, ~cmp, r, MI.extreme(~K, ~V, ~cmp, m1, r, False{}), extreme_g(~K, ~V, ~cmp, m1, r, False{}, g_pair_result)) 1670 1671 def refresh_ends_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {M.refresh_ends_1(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, pair_result)) == ST.real(~K, ~V, ~cmp, MI.refresh_ends_1(~K, ~V, ~cmp, pair_result)) : M.TreeMap}: 1672 match pair_result: 1673 case Tuple{+m1, +r}: 1674 %Equal.sym(M.TreeMap & Nat, M.extreme(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), r, False{}), MI.rp(~K, ~V, ~cmp, Nat, MI.extreme(~K, ~V, ~cmp, m1, r, False{})), extreme_s(~K, ~V, ~cmp, m1, r, False{}, g_pair_result)) : {M.refresh_ends_2(~K, ~V, ~cmp, r, _) == ST.real(~K, ~V, ~cmp, MI.refresh_ends_1(~K, ~V, ~cmp, Tuple{m1, r})) : M.TreeMap} 1675 refresh_ends_2_s(~K, ~V, ~cmp, r, MI.extreme(~K, ~V, ~cmp, m1, r, False{}), extreme_g(~K, ~V, ~cmp, m1, r, False{}, g_pair_result)) 1676 1677 1678 def nav_equal_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +higher: Bool, +inclusive: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.nav_equal(~K, ~V, ~cmp, m, id, higher, inclusive)) == True{} : Bool}: 1679 match inclusive: 1680 case True{}: 1681 g_m 1682 case False{}: 1683 neighbor_g(~K, ~V, ~cmp, m, id, higher, g_m) 1684 1685 def nav_equal_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +id: Nat, +higher: Bool, +inclusive: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.nav_equal(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, higher, inclusive) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_equal(~K, ~V, ~cmp, m, id, higher, inclusive)) : M.TreeMap & Nat}: 1686 match inclusive: 1687 case True{}: 1688 {==} 1689 case False{}: 1690 neighbor_s(~K, ~V, ~cmp, m, id, higher, g_m) 1691 1692 1693 def first_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.first_key(~K, ~V, ~cmp, m)) == True{} : Bool}: 1694 key_id_g(~K, ~V, ~cmp, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m)) 1695 1696 def first_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.first_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.first_key(~K, ~V, ~cmp, m)) : M.TreeMap & Maybe<&2, K>}: 1697 %Equal.sym(M.TreeMap & Nat, M.first_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.first_id(~K, ~V, ~cmp, m)), first_id_s(~K, ~V, ~cmp, m, g_m)) : {M.key_id(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.first_key(~K, ~V, ~cmp, m)) : M.TreeMap & Maybe<&2, K>} 1698 key_id_s(~K, ~V, ~cmp, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m)) 1699 1700 1701 def last_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.last_key(~K, ~V, ~cmp, m)) == True{} : Bool}: 1702 key_id_g(~K, ~V, ~cmp, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m)) 1703 1704 def last_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.last_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.last_key(~K, ~V, ~cmp, m)) : M.TreeMap & Maybe<&2, K>}: 1705 %Equal.sym(M.TreeMap & Nat, M.last_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.last_id(~K, ~V, ~cmp, m)), last_id_s(~K, ~V, ~cmp, m, g_m)) : {M.key_id(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.last_key(~K, ~V, ~cmp, m)) : M.TreeMap & Maybe<&2, K>} 1706 key_id_s(~K, ~V, ~cmp, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m)) 1707 1708 1709 def view_get_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, V>, MI.view_get(~K, ~V, ~cmp, view, k)) == True{} : Bool}: 1710 match view: 1711 case MI.MV{+m, +lower, +upper, +descending}: 1712 view_get_checked_g(~K, ~V, ~cmp, m, k, lower, upper, descending, M.in_range(~K, ~V, ~cmp, k, lower, upper), g_view) 1713 1714 def view_get_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_get(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_get(~K, ~V, ~cmp, view, k)) : M.View & Maybe<&2, V>}: 1715 match view: 1716 case MI.MV{+m, +lower, +upper, +descending}: 1717 view_get_checked_s(~K, ~V, ~cmp, m, k, lower, upper, descending, M.in_range(~K, ~V, ~cmp, k, lower, upper), g_view) 1718 1719 1720 def rotate_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +x: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_left(~K, ~V, ~cmp, m, x)) == True{} : Bool}: 1721 rotate_left_1_g(~K, ~V, ~cmp, x, MI.read(~K, ~V, ~cmp, m, x), read_g(~K, ~V, ~cmp, m, x, g_m)) 1722 1723 def rotate_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +x: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x) == ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, x)) : M.TreeMap}: 1724 %Equal.sym(M.TreeMap & M.Node, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x), MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, m, x)), read_s(~K, ~V, ~cmp, m, x, g_m)) : {M.rotate_left_1(~K, ~V, ~cmp, x, _) == ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, x)) : M.TreeMap} 1725 rotate_left_1_s(~K, ~V, ~cmp, x, MI.read(~K, ~V, ~cmp, m, x), read_g(~K, ~V, ~cmp, m, x, g_m)) 1726 1727 1728 def rotate_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +x: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_right(~K, ~V, ~cmp, m, x)) == True{} : Bool}: 1729 rotate_right_1_g(~K, ~V, ~cmp, x, MI.read(~K, ~V, ~cmp, m, x), read_g(~K, ~V, ~cmp, m, x, g_m)) 1730 1731 def rotate_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +x: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x) == ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, x)) : M.TreeMap}: 1732 %Equal.sym(M.TreeMap & M.Node, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x), MI.rp(~K, ~V, ~cmp, M.Node, MI.read(~K, ~V, ~cmp, m, x)), read_s(~K, ~V, ~cmp, m, x, g_m)) : {M.rotate_right_1(~K, ~V, ~cmp, x, _) == ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, x)) : M.TreeMap} 1733 rotate_right_1_s(~K, ~V, ~cmp, x, MI.read(~K, ~V, ~cmp, m, x), read_g(~K, ~V, ~cmp, m, x, g_m)) 1734 1735 1736 def move_successor_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, +source: Nat, +source_node: M.Node, pair_result: ST.Sh & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.move_successor_2(~K, ~V, ~cmp, target, source, source_node, pair_result)) == True{} : Bool}: 1737 match pair_result: 1738 case Tuple{+m2, +value}: 1739 move_successor_3_g(~K, ~V, ~cmp, source, MI.exchange(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node), target, value), exchange_g(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node), target, value, copy_key_g(~K, ~V, ~cmp, m2, target, source_node, g_pair_result))) 1740 1741 def move_successor_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, +source: Nat, +source_node: M.Node, pair_result: ST.Sh & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {M.move_successor_2(~K, ~V, ~cmp, target, source, source_node, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, pair_result)) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_2(~K, ~V, ~cmp, target, source, source_node, pair_result)) : M.TreeMap & Nat}: 1742 match pair_result: 1743 case Tuple{+m2, +value}: 1744 %Equal.sym(M.TreeMap, M.copy_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), target, source_node), ST.real(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node)), copy_key_s(~K, ~V, ~cmp, m2, target, source_node, g_pair_result)) : {M.move_successor_3(~K, ~V, ~cmp, source, M.exchange(~K, ~V, ~cmp, _, target, value)) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_2(~K, ~V, ~cmp, target, source, source_node, Tuple{m2, value})) : M.TreeMap & Nat} 1745 %Equal.sym(M.TreeMap & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node)), target, value), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node), target, value)), exchange_s(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node), target, value, copy_key_g(~K, ~V, ~cmp, m2, target, source_node, g_pair_result))) : {M.move_successor_3(~K, ~V, ~cmp, source, _) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_2(~K, ~V, ~cmp, target, source, source_node, Tuple{m2, value})) : M.TreeMap & Nat} 1746 move_successor_3_s(~K, ~V, ~cmp, source, MI.exchange(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node), target, value), exchange_g(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node), target, value, copy_key_g(~K, ~V, ~cmp, m2, target, source_node, g_pair_result))) 1747 1748 1749 def refresh_ends_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.refresh_ends(~K, ~V, ~cmp, m)) == True{} : Bool}: 1750 refresh_ends_1_g(~K, ~V, ~cmp, MI.root_id(~K, ~V, ~cmp, m), root_id_g(~K, ~V, ~cmp, m, g_m)) 1751 1752 def refresh_ends_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.refresh_ends(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == ST.real(~K, ~V, ~cmp, MI.refresh_ends(~K, ~V, ~cmp, m)) : M.TreeMap}: 1753 %Equal.sym(M.TreeMap & Nat, M.root_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.root_id(~K, ~V, ~cmp, m)), root_id_s(~K, ~V, ~cmp, m, g_m)) : {M.refresh_ends_1(~K, ~V, ~cmp, _) == ST.real(~K, ~V, ~cmp, MI.refresh_ends(~K, ~V, ~cmp, m)) : M.TreeMap} 1754 refresh_ends_1_s(~K, ~V, ~cmp, MI.root_id(~K, ~V, ~cmp, m), root_id_g(~K, ~V, ~cmp, m, g_m)) 1755 1756 1757 def nav_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +k: K, +higher: Bool, +inclusive: Bool, +id: Nat, +best: Nat, st: ST.Sh & (M.Node & Cmp), +g_st: {MI.dgp(K, V, (M.Node & Cmp), st) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.nav_loop(~K, ~V, ~cmp, fuel, k, higher, inclusive, id, best, st)) == True{} : Bool}: 1758 match fuel st: 1759 case 0n Tuple{+px4, Tuple{M.Free{+px8}, LT{}}}: 1760 g_st 1761 case 0n Tuple{+px4, Tuple{M.Free{+px8}, EQ{}}}: 1762 g_st 1763 case 0n Tuple{+px4, Tuple{M.Free{+px8}, GT{}}}: 1764 g_st 1765 case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, LT{}}}: 1766 g_st 1767 case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, EQ{}}}: 1768 g_st 1769 case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, GT{}}}: 1770 g_st 1771 case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, LT{}}}: 1772 g_st 1773 case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, EQ{}}}: 1774 g_st 1775 case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, GT{}}}: 1776 g_st 1777 case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, LT{}}}: 1778 nav_loop_g(~K, ~V, ~cmp, px3, k, higher, inclusive, px20, M.pick(Nat, higher, id, best), MI.probe(~K, ~V, ~cmp, px14, px20, k), probe_g(~K, ~V, ~cmp, px14, px20, k, g_st)) 1779 case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, GT{}}}: 1780 nav_loop_g(~K, ~V, ~cmp, px3, k, higher, inclusive, px21, M.pick(Nat, higher, best, id), MI.probe(~K, ~V, ~cmp, px14, px21, k), probe_g(~K, ~V, ~cmp, px14, px21, k, g_st)) 1781 case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, EQ{}}}: 1782 nav_equal_g(~K, ~V, ~cmp, px14, id, higher, inclusive, g_st) 1783 1784 def nav_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +k: K, +higher: Bool, +inclusive: Bool, +id: Nat, +best: Nat, st: ST.Sh & (M.Node & Cmp), +g_st: {MI.dgp(K, V, (M.Node & Cmp), st) == True{} : Bool}) -> {M.nav_loop(~K, ~V, ~cmp, fuel, k, higher, inclusive, id, best, MI.rp(~K, ~V, ~cmp, (M.Node & Cmp), st)) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, fuel, k, higher, inclusive, id, best, st)) : M.TreeMap & Nat}: 1785 match fuel st: 1786 case 0n Tuple{+px4, Tuple{M.Free{+px8}, LT{}}}: 1787 {==} 1788 case 0n Tuple{+px4, Tuple{M.Free{+px8}, EQ{}}}: 1789 {==} 1790 case 0n Tuple{+px4, Tuple{M.Free{+px8}, GT{}}}: 1791 {==} 1792 case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, LT{}}}: 1793 {==} 1794 case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, EQ{}}}: 1795 {==} 1796 case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, GT{}}}: 1797 {==} 1798 case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, LT{}}}: 1799 {==} 1800 case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, EQ{}}}: 1801 {==} 1802 case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, GT{}}}: 1803 {==} 1804 case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, LT{}}}: 1805 %Equal.sym(M.TreeMap & (M.Node & Cmp), M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px14), px20, k), MI.rp(~K, ~V, ~cmp, (M.Node & Cmp), MI.probe(~K, ~V, ~cmp, px14, px20, k)), probe_s(~K, ~V, ~cmp, px14, px20, k, g_st)) : {M.nav_loop(~K, ~V, ~cmp, px3, k, higher, inclusive, px20, M.pick(Nat, higher, id, best), _) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+ px3, k, higher, inclusive, id, best, Tuple{px14, Tuple{M.N{px19, px20, px21, px22, px23}, LT{}}})) : M.TreeMap & Nat} 1806 nav_loop_s(~K, ~V, ~cmp, px3, k, higher, inclusive, px20, M.pick(Nat, higher, id, best), MI.probe(~K, ~V, ~cmp, px14, px20, k), probe_g(~K, ~V, ~cmp, px14, px20, k, g_st)) 1807 case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, GT{}}}: 1808 %Equal.sym(M.TreeMap & (M.Node & Cmp), M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px14), px21, k), MI.rp(~K, ~V, ~cmp, (M.Node & Cmp), MI.probe(~K, ~V, ~cmp, px14, px21, k)), probe_s(~K, ~V, ~cmp, px14, px21, k, g_st)) : {M.nav_loop(~K, ~V, ~cmp, px3, k, higher, inclusive, px21, M.pick(Nat, higher, best, id), _) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+ px3, k, higher, inclusive, id, best, Tuple{px14, Tuple{M.N{px19, px20, px21, px22, px23}, GT{}}})) : M.TreeMap & Nat} 1809 nav_loop_s(~K, ~V, ~cmp, px3, k, higher, inclusive, px21, M.pick(Nat, higher, best, id), MI.probe(~K, ~V, ~cmp, px14, px21, k), probe_g(~K, ~V, ~cmp, px14, px21, k, g_st)) 1810 case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, EQ{}}}: 1811 nav_equal_s(~K, ~V, ~cmp, px14, id, higher, inclusive, g_st) 1812 1813 1814 def view_contains_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Bool, MI.view_contains_key(~K, ~V, ~cmp, view, k)) == True{} : Bool}: 1815 view_contains_value_g(~K, ~V, ~cmp, MI.view_get(~K, ~V, ~cmp, view, k), view_get_g(~K, ~V, ~cmp, view, k, g_view)) 1816 1817 def view_contains_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_contains_key(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Bool, MI.view_contains_key(~K, ~V, ~cmp, view, k)) : M.View & Bool}: 1818 %Equal.sym(M.View & Maybe<&2, V>, M.view_get(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k), MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_get(~K, ~V, ~cmp, view, k)), view_get_s(~K, ~V, ~cmp, view, k, g_view)) : {M.view_contains_value(~K, ~V, ~cmp, _) == MI.rvp(~K, ~V, ~cmp, Bool, MI.view_contains_key(~K, ~V, ~cmp, view, k)) : M.View & Bool} 1819 view_contains_value_s(~K, ~V, ~cmp, MI.view_get(~K, ~V, ~cmp, view, k), view_get_g(~K, ~V, ~cmp, view, k, g_view)) 1820 1821 1822 def insert_black_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +z: Nat, +p: Nat, +g: Nat, +triangle: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, triangle)) == True{} : Bool}: 1823 match triangle: 1824 case True{}: 1825 rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}, rotate_left_g(~K, ~V, ~cmp, m, p, g_m)))) 1826 case False{}: 1827 rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m))) 1828 1829 def insert_black_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +z: Nat, +p: Nat, +g: Nat, +triangle: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_black_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, triangle) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, triangle)) : M.TreeMap & M.Fix}: 1830 match triangle: 1831 case True{}: 1832 %Equal.sym(M.TreeMap, M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p), ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p)), rotate_left_s(~K, ~V, ~cmp, m, p, g_m)) : {(M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, z, False{}), g, True{}), g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap & M.Fix} 1833 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p)), z, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{})), set_red_s(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}, rotate_left_g(~K, ~V, ~cmp, m, p, g_m))) : {(M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, g, True{}), g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap & M.Fix} 1834 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{})), g, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}, rotate_left_g(~K, ~V, ~cmp, m, p, g_m)))) : {(M.rotate_right(~K, ~V, ~cmp, _, g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap & M.Fix} 1835 %Equal.sym(M.TreeMap, M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{})), g), ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{}), g)), rotate_right_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}, rotate_left_g(~K, ~V, ~cmp, m, p, g_m))))) : {(_, M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap & M.Fix} 1836 {==} 1837 case False{}: 1838 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), set_red_s(~K, ~V, ~cmp, m, p, False{}, g_m)) : {(M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, g, True{}), g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, False{})) : M.TreeMap & M.Fix} 1839 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), g, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m))) : {(M.rotate_right(~K, ~V, ~cmp, _, g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, False{})) : M.TreeMap & M.Fix} 1840 %Equal.sym(M.TreeMap, M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{})), g), ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}), g)), rotate_right_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m)))) : {(_, M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, False{})) : M.TreeMap & M.Fix} 1841 {==} 1842 1843 1844 def insert_black_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +z: Nat, +p: Nat, +g: Nat, +triangle: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, triangle)) == True{} : Bool}: 1845 match triangle: 1846 case True{}: 1847 rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}, rotate_right_g(~K, ~V, ~cmp, m, p, g_m)))) 1848 case False{}: 1849 rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m))) 1850 1851 def insert_black_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +z: Nat, +p: Nat, +g: Nat, +triangle: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_black_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, triangle) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, triangle)) : M.TreeMap & M.Fix}: 1852 match triangle: 1853 case True{}: 1854 %Equal.sym(M.TreeMap, M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p), ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p)), rotate_right_s(~K, ~V, ~cmp, m, p, g_m)) : {(M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, z, False{}), g, True{}), g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap & M.Fix} 1855 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p)), z, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{})), set_red_s(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}, rotate_right_g(~K, ~V, ~cmp, m, p, g_m))) : {(M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, g, True{}), g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap & M.Fix} 1856 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{})), g, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}, rotate_right_g(~K, ~V, ~cmp, m, p, g_m)))) : {(M.rotate_left(~K, ~V, ~cmp, _, g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap & M.Fix} 1857 %Equal.sym(M.TreeMap, M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{})), g), ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{}), g)), rotate_left_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}, rotate_right_g(~K, ~V, ~cmp, m, p, g_m))))) : {(_, M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap & M.Fix} 1858 {==} 1859 case False{}: 1860 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), set_red_s(~K, ~V, ~cmp, m, p, False{}, g_m)) : {(M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, g, True{}), g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, False{})) : M.TreeMap & M.Fix} 1861 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), g, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m))) : {(M.rotate_left(~K, ~V, ~cmp, _, g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, False{})) : M.TreeMap & M.Fix} 1862 %Equal.sym(M.TreeMap, M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{})), g), ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}), g)), rotate_left_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m)))) : {(_, M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, False{})) : M.TreeMap & M.Fix} 1863 {==} 1864 1865 1866 def move_successor_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, +source: Nat, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.move_successor_1(~K, ~V, ~cmp, target, source, pair_result)) == True{} : Bool}: 1867 match pair_result: 1868 case Tuple{+m1, +source_node}: 1869 move_successor_2_g(~K, ~V, ~cmp, target, source, source_node, MI.exchange(~K, ~V, ~cmp, m1, source, None{}), exchange_g(~K, ~V, ~cmp, m1, source, None{}, g_pair_result)) 1870 1871 def move_successor_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, +source: Nat, pair_result: ST.Sh & M.Node, +g_pair_result: {MI.dgp(K, V, M.Node, pair_result) == True{} : Bool}) -> {M.move_successor_1(~K, ~V, ~cmp, target, source, MI.rp(~K, ~V, ~cmp, M.Node, pair_result)) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_1(~K, ~V, ~cmp, target, source, pair_result)) : M.TreeMap & Nat}: 1872 match pair_result: 1873 case Tuple{+m1, +source_node}: 1874 %Equal.sym(M.TreeMap & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), source, None{}), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, m1, source, None{})), exchange_s(~K, ~V, ~cmp, m1, source, None{}, g_pair_result)) : {M.move_successor_2(~K, ~V, ~cmp, target, source, source_node, _) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_1(~K, ~V, ~cmp, target, source, Tuple{m1, source_node})) : M.TreeMap & Nat} 1875 move_successor_2_s(~K, ~V, ~cmp, target, source, source_node, MI.exchange(~K, ~V, ~cmp, m1, source, None{}), exchange_g(~K, ~V, ~cmp, m1, source, None{}, g_pair_result)) 1876 1877 1878 def delete_borrow_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +p: Nat, +w: Nat, +pn: M.Node, +wn: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_left(~K, ~V, ~cmp, m, p, w, pn, wn)) == True{} : Bool}: 1879 rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m)))) 1880 1881 def delete_borrow_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +p: Nat, +w: Nat, +pn: M.Node, +wn: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_borrow_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, pn, wn) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_left(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap & M.DeleteFix}: 1882 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), w, M.node_red(~K, pn)), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn))), set_red_s(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m)) : {(M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, p, False{}), M.node_right(~K, wn), False{}), p), M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_left(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap & M.DeleteFix} 1883 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn))), p, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m))) : {(M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, M.node_right(~K, wn), False{}), p), M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_left(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap & M.DeleteFix} 1884 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{})), M.node_right(~K, wn), False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m)))) : {(M.rotate_left(~K, ~V, ~cmp, _, p), M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_left(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap & M.DeleteFix} 1885 %Equal.sym(M.TreeMap, M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{})), p), ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{}), p)), rotate_left_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m))))) : {(_, M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_left(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap & M.DeleteFix} 1886 {==} 1887 1888 1889 def delete_borrow_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +p: Nat, +w: Nat, +pn: M.Node, +wn: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_right(~K, ~V, ~cmp, m, p, w, pn, wn)) == True{} : Bool}: 1890 rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m)))) 1891 1892 def delete_borrow_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +p: Nat, +w: Nat, +pn: M.Node, +wn: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_borrow_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, pn, wn) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_right(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap & M.DeleteFix}: 1893 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), w, M.node_red(~K, pn)), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn))), set_red_s(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m)) : {(M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, p, False{}), M.node_left(~K, wn), False{}), p), M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_right(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap & M.DeleteFix} 1894 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn))), p, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m))) : {(M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, M.node_left(~K, wn), False{}), p), M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_right(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap & M.DeleteFix} 1895 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{})), M.node_left(~K, wn), False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m)))) : {(M.rotate_right(~K, ~V, ~cmp, _, p), M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_right(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap & M.DeleteFix} 1896 %Equal.sym(M.TreeMap, M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{})), p), ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{}), p)), rotate_right_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m))))) : {(_, M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_right(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap & M.DeleteFix} 1897 {==} 1898 1899 1900 # ---- navigate: the fast descent keeps the candidate, the mirror's loop probes ---- 1901 1902 1903 # the order of a live node decides: descend (the rest by ih) or finish at the equal node 1904 def nq_o(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +f: Nat, +i: Nat, +b: Nat, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +hy: {ST.nth_or(M.Node, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node}, ih: @+id2: Nat -> @+b2: Nat -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, b2, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id2, k))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, f, k, h, inc, id2, b2, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id2, k))) : M.TreeMap & Nat}, +c0: Cmp) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 1n+f, k, h, b, (ST.nodes(~K, l, d, nl), (1n+i, Some{c0})))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, c0)))) : M.TreeMap & Nat}: 1905 match c0: 1906 case LT{}: 1907 %Equal.sym(M.NodeStore & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), True{}, i), (ST.nodes(~K, l, d, nl), M.pick(Nat, True{}, M.nleft(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, True{}, i)) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, M.pick(Nat, h, 1n+i, b), M.search_down2(~K, ~V, ~cmp, k, _))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, LT{})))) : M.TreeMap & Nat} 1908 %Equal.sym(M.Node, ST.nth_or(M.Node, nl, i, M.Free{0n}), M.N{c, lf, rt, q, key}, hy) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, M.pick(Nat, h, 1n+i, b), M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), M.nleft(~K, _), k))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, LT{})))) : M.TreeMap & Nat} 1909 ih(lf, M.pick(Nat, h, 1n+i, b)) 1910 case GT{}: 1911 %Equal.sym(M.NodeStore & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), False{}, i), (ST.nodes(~K, l, d, nl), M.pick(Nat, False{}, M.nleft(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, False{}, i)) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, M.pick(Nat, h, b, 1n+i), M.search_down2(~K, ~V, ~cmp, k, _))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, GT{})))) : M.TreeMap & Nat} 1912 %Equal.sym(M.Node, ST.nth_or(M.Node, nl, i, M.Free{0n}), M.N{c, lf, rt, q, key}, hy) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, M.pick(Nat, h, b, 1n+i), M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), M.nright(~K, _), k))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, GT{})))) : M.TreeMap & Nat} 1913 ih(rt, M.pick(Nat, h, b, 1n+i)) 1914 case EQ{}: 1915 nav_equal_s(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, h, inc, g) 1916 1917 def nq_c(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +f: Nat, +i: Nat, +b: Nat, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +hy: {ST.nth_or(M.Node, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node}, ih: @+id2: Nat -> @+b2: Nat -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, b2, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id2, k))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, f, k, h, inc, id2, b2, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id2, k))) : M.TreeMap & Nat}, +c0: Cmp, +hco: {cmp(k, key) == c0 : Cmp}) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 1n+f, k, h, b, (ST.nodes(~K, l, d, nl), (1n+i, Some{cmp(k, key)})))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, cmp(k, key))))) : M.TreeMap & Nat}: 1918 %Equal.sym(Cmp, cmp(k, key), c0, hco) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 1n+f, k, h, b, (ST.nodes(~K, l, d, nl), (1n+i, Some{_})))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, _)))) : M.TreeMap & Nat} 1919 nq_o(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, f, i, b, c, lf, rt, q, key, hy, ih, c0) 1920 1921 def nq_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +f: Nat, +i: Nat, +b: Nat, +y: M.Node, +hy: {ST.nth_or(M.Node, nl, i, M.Free{0n}) == y : M.Node}, ih: @+id2: Nat -> @+b2: Nat -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, b2, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id2, k))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, f, k, h, inc, id2, b2, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id2, k))) : M.TreeMap & Nat}) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 1n+f, k, h, b, M.search_key(~K, ~V, ~cmp, 1n+i, k, (ST.nodes(~K, l, d, nl), M.nkey(~K, y))))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, y)))) : M.TreeMap & Nat}: 1922 match y: 1923 case M.Free{z}: 1924 {==} 1925 case M.N{+c, +lf, +rt, +q, +key}: 1926 nq_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, f, i, b, c, lf, rt, q, key, hy, ih, cmp(k, key), {==}) 1927 1928 def n0_o(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +i: Nat, +b: Nat, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +c0: Cmp) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 0n, k, h, b, (ST.nodes(~K, l, d, nl), (1n+i, Some{c0})))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 0n, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, c0)))) : M.TreeMap & Nat}: 1929 match c0: 1930 case LT{}: 1931 {==} 1932 case GT{}: 1933 {==} 1934 case EQ{}: 1935 {==} 1936 1937 def n0_c(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +i: Nat, +b: Nat, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +c0: Cmp, +hco: {cmp(k, key) == c0 : Cmp}) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 0n, k, h, b, (ST.nodes(~K, l, d, nl), (1n+i, Some{cmp(k, key)})))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 0n, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, cmp(k, key))))) : M.TreeMap & Nat}: 1938 %Equal.sym(Cmp, cmp(k, key), c0, hco) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 0n, k, h, b, (ST.nodes(~K, l, d, nl), (1n+i, Some{_})))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 0n, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, _)))) : M.TreeMap & Nat} 1939 n0_o(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, i, b, c, lf, rt, q, key, c0) 1940 1941 def n0_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +i: Nat, +b: Nat, +y: M.Node) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 0n, k, h, b, M.search_key(~K, ~V, ~cmp, 1n+i, k, (ST.nodes(~K, l, d, nl), M.nkey(~K, y))))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 0n, k, h, inc, 1n+i, b, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, y)))) : M.TreeMap & Nat}: 1942 match y: 1943 case M.Free{z}: 1944 {==} 1945 case M.N{+c, +lf, +rt, +q, +key}: 1946 n0_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, i, b, c, lf, rt, q, key, cmp(k, key), {==}) 1947 1948 # the fast descent, ended in the map, is the mirror's loop 1949 def nq(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +fuel: Nat, +id: Nat, +b: Nat) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, fuel, k, h, b, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id, k))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, fuel, k, h, inc, id, b, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id, k))) : M.TreeMap & Nat}: 1950 match fuel id: 1951 case 0n 0n: 1952 {==} 1953 case 0n 1n+ +i: 1954 %Equal.sym(M.NodeStore & Maybe<&2, K>, M.ns_key_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nkey(~K, ST.nth_or(M.Node, nl, i, M.Free{0n}))), NSL.key_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 0n, k, h, b, M.search_key(~K, ~V, ~cmp, 1n+i, k, _))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 0n, k, h, inc, 1n+i, b, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, ST.nth_or(M.Node, nl, i, M.Free{0n}))))) : M.TreeMap & Nat} 1955 n0_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, i, b, ST.nth_or(M.Node, nl, i, M.Free{0n})) 1956 case 1n+f 0n: 1957 {==} 1958 case 1n+ +f 1n+ +i: 1959 %Equal.sym(M.NodeStore & Maybe<&2, K>, M.ns_key_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nkey(~K, ST.nth_or(M.Node, nl, i, M.Free{0n}))), NSL.key_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 1n+f, k, h, b, M.search_key(~K, ~V, ~cmp, 1n+i, k, _))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, ST.nth_or(M.Node, nl, i, M.Free{0n}))))) : M.TreeMap & Nat} 1960 nq_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, f, i, b, ST.nth_or(M.Node, nl, i, M.Free{0n}), {==}, id2 => b2 => nq(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, f, id2, b2)) 1961 1962 def navigate_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +higher: Bool, +inclusive: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, higher, inclusive) == MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, higher, inclusive)) : M.TreeMap & Nat}: 1963 match m: 1964 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}: 1965 nq(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node, nl)))), g_m))), g_m, k, higher, inclusive, 1n+n, root, 0n) 1966 1967 def navigate_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +k: K, +higher: Bool, +inclusive: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.navigate(~K, ~V, ~cmp, m, k, higher, inclusive)) == True{} : Bool}: 1968 match m: 1969 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}: 1970 nav_loop_g(~K, ~V, ~cmp, 1n+n, k, higher, inclusive, root, 0n, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, root, k), probe_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, root, k, g_m)) 1971 1972 def insert_uncle_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +z: Nat, +p: Nat, +g: Nat, +u: Nat, +triangle: Bool, +uncle: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_uncle_left(~K, ~V, ~cmp, m, z, p, g, u, triangle, uncle)) == True{} : Bool}: 1973 match uncle: 1974 case M.N{True{}, +px4, +px5, +px6, +px7}: 1975 set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m))) 1976 case M.Free{+px2}: 1977 insert_black_left_g(~K, ~V, ~cmp, m, z, p, g, triangle, g_m) 1978 case M.N{False{}, +px4, +px5, +px6, +px7}: 1979 insert_black_left_g(~K, ~V, ~cmp, m, z, p, g, triangle, g_m) 1980 1981 def insert_uncle_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +z: Nat, +p: Nat, +g: Nat, +u: Nat, +triangle: Bool, +uncle: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_uncle_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, u, triangle, uncle) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_uncle_left(~K, ~V, ~cmp, m, z, p, g, u, triangle, uncle)) : M.TreeMap & M.Fix}: 1982 match uncle: 1983 case M.N{True{}, +px4, +px5, +px6, +px7}: 1984 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), set_red_s(~K, ~V, ~cmp, m, p, False{}, g_m)) : {(M.set_red(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, u, False{}), g, True{}), M.Fix{g, True{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_uncle_left(~K, ~V, ~cmp, m, z, p, g, u, triangle, M.N{True{}, px4, px5, px6, px7})) : M.TreeMap & M.Fix} 1985 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), u, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m))) : {(M.set_red(~K, ~V, ~cmp, _, g, True{}), M.Fix{g, True{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_uncle_left(~K, ~V, ~cmp, m, z, p, g, u, triangle, M.N{True{}, px4, px5, px6, px7})) : M.TreeMap & M.Fix} 1986 %Equal.sym(M.TreeMap, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{})), g, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}), g, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m)))) : {(_, M.Fix{g, True{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_uncle_left(~K, ~V, ~cmp, m, z, p, g, u, triangle, M.N{True{}, px4, px5, px6, px7})) : M.TreeMap & M.Fix} 1987 {==} 1988 case M.Free{+px2}: 1989 insert_black_left_s(~K, ~V, ~cmp, m, z, p, g, triangle, g_m) 1990 case M.N{False{}, +px4, +px5, +px6, +px7}: 1991 insert_black_left_s(~K, ~V, ~cmp, m, z, p, g, triangle, g_m) 1992 1993 1994 def insert_uncle_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh, +z: Nat, +p: Nat, +g: Nat, +u: Nat, +triangle: Bool, +uncle: M.Node, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_uncle_right(~K, ~V, ~cmp, m, z, p, g, u, triangle, uncle)) == True{} : Bool}: 1995 match uncle: 1996 case M.N{True{}, +px4, +px5, +px6, +px7}: 1997 set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m))) 1998 case M.Free{+px2}: 1999 insert_black_right_g(~K, ~V, ~cmp, m, z, p, g, triangle, g_m) 2000 case M.N{False{}, +px4, +px5, +px6, +px7}: Lines 1-2000 of 3454. More: https://jend.leeeet.dev/read.txt?path=bend-collections-laws-containers@1.0.0.0/proofs/containers/balanced_search_tree/sim.bend&start_line=2001