proofs/containers/balanced_search_tree/sim.bend
bend-collections-laws-containers@1.0.0.0 · 3,454 lines · 0 definitions
1import Base
2import bend-collections-laws-containers@1.0.0.0/proofs/lib/logic.bend as L
3import bend-collections-laws-containers@1.0.0.0/proofs/lib/nat.bend as N
4import bend-collections-laws-containers@1.0.0.0/proofs/lib/u32.bend as U
5import bend-collections-laws-containers@1.0.0.0/proofs/lib/array.bend as AR
6import bend-collections-laws-containers@1.0.0.0/proofs/lib/list.bend as LL
7import bend-collections-laws-containers@1.0.0.0/spec/lib/common.bend as SC
8import bend-collections-laws-containers@1.0.0.0/src/containers/balanced_search_tree.bend as M
9import bend-collections-laws-containers@1.0.0.0/src/containers/dynamic_array.bend as D
10import bend-collections-laws-containers@1.0.0.0/src/containers/types/dynamic_array.bend as DE
11import bend-collections-laws-containers@1.0.0.0/proofs/containers/dynamic_array/layout.bend as LY
12import bend-collections-laws-containers@1.0.0.0/proofs/containers/dynamic_array/state.bend as DAS
13import bend-collections-laws-containers@1.0.0.0/proofs/containers/dynamic_array/steps.bend as DST
14import bend-collections-laws-containers@1.0.0.0/proofs/containers/balanced_search_tree/state.bend as ST
15import bend-collections-laws-containers@1.0.0.0/proofs/containers/balanced_search_tree/mk.bend as MK
16import bend-collections-laws-containers@1.0.0.0/proofs/containers/balanced_search_tree/da.bend as DA
17import bend-collections-laws-containers@1.0.0.0/proofs/containers/balanced_search_tree/arr.bend as AB
18import bend-collections-laws-containers@1.0.0.0/proofs/containers/balanced_search_tree/prim.bend as PR
19import bend-collections-laws-containers@1.0.0.0/proofs/containers/balanced_search_tree/nsl.bend as NSL
20import bend-collections-laws-containers@1.0.0.0/proofs/containers/balanced_search_tree/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
31def read_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Node<K>, 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
36def read_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K>, MI.read(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & M.Node<K>}:
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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), id)
40
41def get_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
46def get_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), id)
50
51# ---- writes ----
52
53def len_wr_c(-K: Data, +nl: List<&2, M.Node<K>>, +i: Nat, +x: M.Node<K>, +b: Bool) -> {SC.length(M.Node<K>, ST.pk(List<&2, M.Node<K>>, b, SC.update(M.Node<K>, nl, i, x), nl)) == SC.length(M.Node<K>, nl) : Nat}:
54 match b:
55 case True{}:
56 LL.length_update(M.Node<K>, nl, i, x)
57 case False{}:
58 {==}
59
60def len_wr(-K: Data, +nl: List<&2, M.Node<K>>, +id: Nat, +x: M.Node<K>) -> {SC.length(M.Node<K>, PR.wr_nl(K, nl, id, x)) == SC.length(M.Node<K>, 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<K>, nl)))
66
67
68def 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
75def 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
83def write_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +node: M.Node<K>, +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<K>, PR.wr_nl(K, nl, id, node)), SC.length(M.Node<K>, 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<K>, PR.wr_nl(K, nl, id, node)))))) == True{} : Bool}
87 %Equal.sym(Nat, SC.length(M.Node<K>, PR.wr_nl(K, nl, id, node)), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), _)))) == True{} : Bool}
88 g_m
89
90def write_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +node: M.Node<K>, +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<K, V, cmp>}:
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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), id, node)
94
95def exchange_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K>, nl), SC.pow2(d)), Nat.is_eq(_, SC.length(M.Node<K>, nl))))) == True{} : Bool}
99 g_m
100
101def exchange_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), id, value)
105
106def clear_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_intro(Nat.is_le(0n, SC.pow2(d)), True{}, N.zero_le(SC.pow2(d)), {==})))
110
111def clear_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
112 match m:
113 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
114 %Equal.sym(M.NodeStore<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K, V, cmp>}
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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.subst(Nat, z => {Nat.is_le(z, SC.pow2(d)) == True{} : Bool}, SC.length(M.Node<K>, nl), SC.length(Maybe<&2, V>, pl), Equal.sym(Nat, SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl), N.eq_from_is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))))), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)))))) : {M.TM{0n, 0n, 0n, 0n, 0n, ST.nodes(~K, l, d, Nil{}), _} == ST.real(~K, ~V, ~cmp, ST.SH{0n, 0n, 0n, 0n, 0n, l, d, Nil{}, Nil{}, t, fl}) : M.TreeMap<K, V, cmp>}
116 {==}
117
118# ---- append ----
119
120
121def lt_pl(~K: Data, ~V: Data, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +x: Nat, +b: Bool, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +h: {Nat.is_lt(SC.length(M.Node<K>, 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<K>, nl), SC.length(Maybe<&2, V>, pl), Equal.sym(Nat, SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl), N.eq_from_is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl), hp)), h)
123
124def le_pl(~K: Data, ~V: Data, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +x: Nat, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +h: {Nat.is_le(SC.length(M.Node<K>, 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<K>, nl), SC.length(Maybe<&2, V>, pl), Equal.sym(Nat, SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl), N.eq_from_is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl), hp)), h)
126
127def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +room: Bool, +hr: {Nat.is_lt(SC.length(M.Node<K>, 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<K, V>, 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<K>, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})), 1n+SC.length(M.Node<K>, nl), LL.length_snoc(M.Node<K>, 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<K>, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})))))) == True{} : Bool}
131 %Equal.sym(Nat, SC.length(M.Node<K>, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})), 1n+SC.length(M.Node<K>, nl), LL.length_snoc(M.Node<K>, 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<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(_, 1n+SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), hl, L.and_intro(Nat.is_le(d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), hd, L.and_intro(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), N.lt_succ_le_succ(SC.length(M.Node<K>, nl), SC.pow2(d), hr), hp)))
134 case False{} True{}:
135 %Equal.sym(Nat, SC.length(M.Node<K>, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})), 1n+SC.length(M.Node<K>, nl), LL.length_snoc(M.Node<K>, 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<K>, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})))))) == True{} : Bool}
136 %Equal.sym(Nat, SC.length(M.Node<K>, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})), 1n+SC.length(M.Node<K>, nl), LL.length_snoc(M.Node<K>, 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<K>, 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<K>, nl), SC.pow2(1n+d)), Nat.is_eq(_, 1n+SC.length(M.Node<K>, nl))))) == True{} : Bool}
138 +h3 = N.lt_succ_le_succ(SC.length(M.Node<K>, nl), SC.pow2(1n+d), N.le_lt_trans(SC.length(M.Node<K>, 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<K>, nl), SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), hl, L.and_intro(Nat.is_le(1n+d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), N.lt_succ_le_succ(d, l, hgr), L.and_intro(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), hl, L.and_intro(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), hd, L.and_intro(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), hc, hp)))
142
143
144def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +room: Bool, +hr: {Nat.is_lt(SC.length(M.Node<K>, 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<K>, 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<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, room, grow)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}:
145 match room grow:
146 case True{} _:
147 %Equal.sym(M.NodeStore<K> & 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<K>, 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<K>, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, True{}, grow)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, 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<K>, nl, M.N{True{}, 0n, 0n, p, k})), k, v, 1n+SC.length(M.Node<K>, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, True{}, grow)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
149 {==}
150 case False{} True{}:
151 %Equal.sym(M.NodeStore<K> & 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<K>, 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<K>, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, False{}, True{})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, 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<K>, nl, M.N{True{}, 0n, 0n, p, k})), k, v, 1n+SC.length(M.Node<K>, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, False{}, True{})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
153 {==}
154 case False{} False{}:
155 %Equal.sym(M.NodeStore<K> & 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<K>, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, False{}, False{})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
156 {==}
157
158def append_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), Nat.is_lt(SC.length(M.Node<K>, nl), SC.pow2(d)), {==}, Nat.is_lt(d, l), {==})
162
163def append_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V>, Nat>, MI.append(~K, ~V, ~cmp, m, k, v, p)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), Nat.is_lt(SC.length(M.Node<K>, nl), SC.pow2(d)), {==}, Nat.is_lt(d, l), {==})
167
168
169# ---- field writes: the mirror keeps the layout ----
170
171def set_left_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Nat, +node: M.Node<K>, +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
178def set_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +v: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, 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
183def set_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
186def set_right_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Nat, +node: M.Node<K>, +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
193def set_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +v: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, 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
198def set_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
201def set_parent_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Nat, +node: M.Node<K>, +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
208def set_parent_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +v: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, 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
213def set_parent_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
216def set_red_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Bool, +node: M.Node<K>, +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
223def set_red_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +v: Bool, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, 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
228def set_red_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
234def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +i: Nat, +v: Nat, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}) -> {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<K, V, cmp>}:
235 match y:
236 case M.Free{+z}:
237 %Equal.sym(M.NodeStore<K>, 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<K, V, cmp>}
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<K>, M.ns_set_left(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, SC.update(M.Node<K>, 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<K, V, cmp>}
242 %Equal.sym(Bool, Nat.is_lt(i, SC.length(M.Node<K>, nl)), True{}, hlt) : {M.TM{n, root, lo, hi, free, ST.nodes(~K, l, d, SC.update(M.Node<K>, 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<K>>, _, SC.update(M.Node<K>, nl, i, M.N{c, v, rt, q, k}), nl), pl, t, fl}) : M.TreeMap<K, V, cmp>}
243 {==}
244
245def set_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), i, v, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==})
251
252def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +i: Nat, +v: Nat, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}) -> {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<K, V, cmp>}:
253 match y:
254 case M.Free{+z}:
255 %Equal.sym(M.NodeStore<K>, 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<K, V, cmp>}
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<K>, M.ns_set_right(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, SC.update(M.Node<K>, 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<K, V, cmp>}
260 %Equal.sym(Bool, Nat.is_lt(i, SC.length(M.Node<K>, nl)), True{}, hlt) : {M.TM{n, root, lo, hi, free, ST.nodes(~K, l, d, SC.update(M.Node<K>, 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<K>>, _, SC.update(M.Node<K>, nl, i, M.N{c, lf, v, q, k}), nl), pl, t, fl}) : M.TreeMap<K, V, cmp>}
261 {==}
262
263def set_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), i, v, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==})
269
270def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +i: Nat, +v: Nat, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}) -> {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<K, V, cmp>}:
271 match y:
272 case M.Free{+z}:
273 %Equal.sym(M.NodeStore<K>, 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<K, V, cmp>}
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<K>, M.ns_set_parent(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, SC.update(M.Node<K>, 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<K, V, cmp>}
278 %Equal.sym(Bool, Nat.is_lt(i, SC.length(M.Node<K>, nl)), True{}, hlt) : {M.TM{n, root, lo, hi, free, ST.nodes(~K, l, d, SC.update(M.Node<K>, 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<K>>, _, SC.update(M.Node<K>, nl, i, M.N{c, lf, rt, v, k}), nl), pl, t, fl}) : M.TreeMap<K, V, cmp>}
279 {==}
280
281def set_parent_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), i, v, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==})
287
288def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +i: Nat, +v: Bool, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}) -> {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<K, V, cmp>}:
289 match y:
290 case M.Free{+z}:
291 %Equal.sym(M.NodeStore<K>, 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<K, V, cmp>}
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<K>, M.ns_set_red(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, SC.update(M.Node<K>, 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<K, V, cmp>}
296 %Equal.sym(Bool, Nat.is_lt(i, SC.length(M.Node<K>, nl)), True{}, hlt) : {M.TM{n, root, lo, hi, free, ST.nodes(~K, l, d, SC.update(M.Node<K>, 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<K>>, _, SC.update(M.Node<K>, nl, i, M.N{v, lf, rt, q, k}), nl), pl, t, fl}) : M.TreeMap<K, V, cmp>}
297 {==}
298
299def set_red_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), i, v, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==})
305
306# ---- the neighbour walks: field reads are the node list's ----
307
308
309def side_ok(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, 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<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})))) : M.NodeStore<K> & 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
316def asc_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +x: Nat, +i: Nat, +forward: Bool, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}) -> {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<K> & 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<K> & 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<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, 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<K> & M.Ascend}
322 %Equal.sym(M.NodeStore<K> & 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<K>, 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<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, 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<K> & M.Ascend}
323 %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, 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<K> & M.Ascend}
324 {==}
325 case M.N{False{}, +lf, +rt, +q, +k}:
326 %Equal.sym(M.NodeStore<K> & 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<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, 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<K> & M.Ascend}
327 %Equal.sym(M.NodeStore<K> & 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<K>, 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<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, 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<K> & M.Ascend}
328 %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, 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<K> & M.Ascend}
329 {==}
330
331# one ascending step reads the node's tag, child and parent
332def asc_at(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, 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<K> & M.Ascend}:
333 match p:
334 case 0n:
335 {==}
336 case 1n+ +i:
337 %Equal.sym(M.NodeStore<K> & 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<K>, 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<K>, nl, i, M.Free{0n}))) : M.NodeStore<K> & M.Ascend}
338 asc_y(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, x, i, forward, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==})
339
340def ext_pick(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, -a: M.NodeStore<K>, +fw: Bool, +lf: Nat, +rt: Nat) -> {(a, M.pick(Nat, Bool.not(fw), lf, rt)) == (a, M.pick(Nat, fw, rt, lf)) : M.NodeStore<K> & Nat}:
341 match fw:
342 case True{}:
343 {==}
344 case False{}:
345 {==}
346
347def ext_free(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, -a: M.NodeStore<K>, +forward: Bool, +z: Nat) -> {(a, 0n) == (a, M.child(~K, M.Free{z}, forward)) : M.NodeStore<K> & Nat}:
348 match forward:
349 case True{}:
350 {==}
351 case False{}:
352 {==}
353
354def ext_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +forward: Bool, +j: Nat, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, j, M.Free{0n}) == y : M.Node<K>}) -> {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<K> & 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<K> & 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<K>, nl, j, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, 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<K> & Nat}
360 %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, 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<K> & 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<K> & 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<K>, nl, j, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, 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<K> & Nat}
364 %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, 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<K> & 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
368def ext_at(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, 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<K>, nl, j, M.Free{0n}), forward)) : M.NodeStore<K> & Nat}:
369 %Equal.sym(M.NodeStore<K> & 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<K>, 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<K>, nl, j, M.Free{0n}), forward)) : M.NodeStore<K> & Nat}
370 ext_y(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, forward, j, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), {==})
371
372def asl(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, 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<K> & 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<K> & 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<K> & 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
382def esl(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, 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<K> & 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<K> & 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<K>, 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<K> & Nat}
390 esl(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, f, forward, 1n+j, M.child(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), forward))
391
392def nbl(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, 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<K> & 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<K> & 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<K>, 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<K> & 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<K>, nl, j, M.Free{0n}), Bool.not(forward)))
399
400def neighbor_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, 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
405def neighbor_node_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.neighbor_node(~K, ~V, ~cmp, id, forward, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rp(~K, ~V, ~cmp, Nat, MI.neighbor_node(~K, ~V, ~cmp, id, forward, r)) : M.TreeMap<K, V, cmp> & 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<K> & 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_r), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_r)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K, V, cmp> & Nat}
409 {==}
410
411def size_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
416def size_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & 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
422def root_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
427def root_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & 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
433def first_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
438def first_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & 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
444def last_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
449def last_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & 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
455def set_root_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
460def set_root_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
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
466def probe_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +k: K, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgp(K, V, (M.Node<K> & 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
473def probe_node_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +k: K, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.probe_node(~K, ~V, ~cmp, id, k, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rp(~K, ~V, ~cmp, (M.Node<K> & Cmp), MI.probe_node(~K, ~V, ~cmp, id, k, r)) : M.TreeMap<K, V, cmp> & (M.Node<K> & 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
481def free_header_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
486def free_header_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
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
492def reuse_slot_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & 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<K, V>, 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
497def reuse_slot_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & 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<K, V>, Nat>, MI.reuse_slot_1(~K, ~V, ~cmp, id, pair_result)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}:
498 match pair_result:
499 case Tuple{+m1, +old}:
500 {==}
501
502
503def put_replaced_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_replaced(~K, ~V, ~cmp, r)) == True{} : Bool}:
504 match r:
505 case Tuple{+m, +old}:
506 g_r
507
508def put_replaced_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & 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<K, V>, Maybe<&2, V>>, MI.put_replaced(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
509 match r:
510 case Tuple{+m, +old}:
511 {==}
512
513
514def contains_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & 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
519def contains_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & 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<K, V, cmp> & Bool}:
520 match r:
521 case Tuple{+m, M.Search{+id, +p, +left}}:
522 {==}
523
524
525def move_successor_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +source: Nat, pair_result: ST.Sh<K, V> & 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
530def move_successor_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +source: Nat, pair_result: ST.Sh<K, V> & 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<K, V, cmp> & Nat}:
531 match pair_result:
532 case Tuple{+m3, +old}:
533 {==}
534
535
536def release_header_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
541def release_header_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
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
547def set_ends_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
552def set_ends_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
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
558def is_empty_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh<K, V> & 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
563def is_empty_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh<K, V> & 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<K, V, cmp> & Bool}:
564 match pair_result:
565 case Tuple{+m1, +n}:
566 {==}
567
568
569def entry_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: Maybe<&2, K>, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, 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
580def entry_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: Maybe<&2, K>, r: ST.Sh<K, V> & 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<K, V>>, MI.entry_value(~K, ~V, ~cmp, k, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
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
592def default_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fallback: V, r: ST.Sh<K, V> & 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
599def default_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fallback: V, r: ST.Sh<K, V> & 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<K, V, cmp> & V}:
600 match r:
601 case Tuple{+px2, None{}}:
602 {==}
603 case Tuple{+px2, Some{+px4}}:
604 {==}
605
606
607def view_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +upper: M.Bound<K>, +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
614def view_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +upper: M.Bound<K>, +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<K, V, cmp>, M.View<K, V, cmp>>}:
615 match valid:
616 case True{}:
617 {==}
618 case False{}:
619 {==}
620
621
622def head_map_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +upper: M.Bound<K>, +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
625def head_map_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +upper: M.Bound<K>, +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<K, V, cmp>}:
626 {==}
627
628
629def tail_map_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +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
632def tail_map_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +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<K, V, cmp>}:
633 {==}
634
635
636def descending_map_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
639def descending_map_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
640 {==}
641
642
643def view_reverse_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +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
648def view_reverse_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +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<K, V, cmp>}:
649 match view:
650 case MI.MV{+m, +lower, +upper, +descending}:
651 {==}
652
653
654def view_finish_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +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
659def view_finish_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +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<K, V, cmp>}:
660 match view:
661 case MI.MV{+m, +lower, +upper, +descending}:
662 {==}
663
664
665def view_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, r: ST.Sh<K, V> & 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
670def view_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, r: ST.Sh<K, V> & 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<K, V, cmp> & Maybe<&2, V>}:
671 match r:
672 case Tuple{+m, +v}:
673 {==}
674
675
676def view_put_finish_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, r: ST.Sh<K, V> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, +g_r: {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, r) == True{} : Bool}) -> {MI.dgvp(K, V, Result<&2, &2, M.Rejected<K, V>, 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
681def view_put_finish_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, r: ST.Sh<K, V> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, +g_r: {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, 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<K, V>, Maybe<&2, V>>, r)) == MI.rvp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put_finish(~K, ~V, ~cmp, lower, upper, descending, r)) : M.View<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
682 match r:
683 case Tuple{+m, +status}:
684 {==}
685
686
687def cursor_started_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & 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
692def cursor_started_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & 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<K, V, cmp>}:
693 match r:
694 case Tuple{+m, +id}:
695 {==}
696
697
698def iterator_finish_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +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
703def iterator_finish_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +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<K, V, cmp>}:
704 match cursor:
705 case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
706 {==}
707
708
709def iterator_view_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +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
714def iterator_view_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +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<K, V, cmp>}:
715 match cursor:
716 case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
717 {==}
718
719
720def iterator_yield_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +entry: M.Entry<K, V>, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, 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
725def iterator_yield_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +entry: M.Entry<K, V>, r: ST.Sh<K, V> & 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<K, V>>, MI.iterator_yield(~K, ~V, ~cmp, id, lower, upper, forward, entry, r)) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
726 match r:
727 case Tuple{+m, +next}:
728 {==}
729
730
731def iterator_set_done_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +next: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & 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
738def iterator_set_done_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +next: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & 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<K, V, cmp> & Result<&2, &2, M.Error, V>}:
739 match r:
740 case Tuple{+px2, Some{+px4}}:
741 {==}
742 case Tuple{+px2, None{}}:
743 {==}
744
745
746def iterator_relocated_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +removed: Maybe<&2, V>, r: ST.Sh<K, V> & 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
751def iterator_relocated_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +removed: Maybe<&2, V>, r: ST.Sh<K, V> & 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<K, V, cmp> & Maybe<&2, V>}:
752 match r:
753 case Tuple{+m, M.Search{+id, +p, +on_left}}:
754 {==}
755
756
757def iterator_key_result_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, 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
764def iterator_key_result_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, r) == True{} : Bool}) -> {M.iterator_key_result(~K, ~V, ~cmp, MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, K>, MI.iterator_key_result(~K, ~V, ~cmp, r)) : M.Cursor<K, V, cmp> & Maybe<&2, K>}:
765 match r:
766 case Tuple{+px2, None{}}:
767 {==}
768 case Tuple{+px2, Some{M.Entry{+px5, +px6}}}:
769 {==}
770
771
772def iterator_value_result_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, 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
779def iterator_value_result_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, r) == True{} : Bool}) -> {M.iterator_value_result(~K, ~V, ~cmp, MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_value_result(~K, ~V, ~cmp, r)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}:
780 match r:
781 case Tuple{+px2, None{}}:
782 {==}
783 case Tuple{+px2, Some{M.Entry{+px5, +px6}}}:
784 {==}
785
786
787def changed_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & 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
794def changed_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & 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<K, V, cmp> & Bool}:
795 match r:
796 case Tuple{+px2, None{}}:
797 {==}
798 case Tuple{+px2, Some{+px4}}:
799 {==}
800
801
802def view_contains_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MView<K, V> & 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
809def view_contains_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MView<K, V> & 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<K, V, cmp> & Bool}:
810 match r:
811 case Tuple{+px2, None{}}:
812 {==}
813 case Tuple{+px2, Some{+px4}}:
814 {==}
815
816
817def view_entry_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +entry: M.Entry<K, V>, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, 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
824def view_entry_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +entry: M.Entry<K, V>, +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<K, V>>, MI.view_entry_checked(~K, ~V, ~cmp, m, lower, upper, descending, entry, valid)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
825 match valid:
826 case True{}:
827 {==}
828 case False{}:
829 {==}
830
831
832def insert_header_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
837def insert_header_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
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
843def ascend_step_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, 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
850def ascend_step_node_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.ascend_step_node(~K, ~V, ~cmp, x, p, forward, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rp(~K, ~V, ~cmp, M.Ascend, MI.ascend_step_node(~K, ~V, ~cmp, x, p, forward, r)) : M.TreeMap<K, V, cmp> & 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
858def refresh_ends_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lo: Nat, pair_result: ST.Sh<K, V> & 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
863def refresh_ends_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lo: Nat, pair_result: ST.Sh<K, V> & 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<K, V, cmp>}:
864 match pair_result:
865 case Tuple{+m3, +hi}:
866 set_ends_s(~K, ~V, ~cmp, m3, lo, hi, g_pair_result)
867
868
869def is_empty_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
872def is_empty_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & Bool}:
873 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
877def key_finish_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, 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
882def key_finish_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.key_finish(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.key_finish(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
883 match r:
884 case Tuple{+m, +node}:
885 {==}
886
887
888def range_unbounded_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
895def range_unbounded_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & 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
903def iterator_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
906def iterator_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
907 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp>}
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
911def descending_iterator_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
914def descending_iterator_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
915 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp>}
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
919def get_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & 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
924def get_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & 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<K, V, cmp> & 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
930def replace_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +v: V, r: ST.Sh<K, V> & 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
937def replace_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +v: V, r: ST.Sh<K, V> & 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<K, V, cmp> & 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
945def sub_map_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +upper: M.Bound<K>, +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
948def sub_map_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +upper: M.Bound<K>, +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<K, V, cmp>, M.View<K, V, cmp>>}:
949 view_checked_s(~K, ~V, ~cmp, m, lower, upper, False{}, M.bounds_valid(~K, ~V, ~cmp, lower, upper), g_m)
950
951
952def iterator_set_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +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
959def iterator_set_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +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<K, V, cmp> & 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<K, V, cmp> & 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<K, V, cmp> & 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
968def entry_set_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
971def entry_set_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
972 iterator_s(~K, ~V, ~cmp, m, g_m)
973
974
975def key_set_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
978def key_set_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
979 iterator_s(~K, ~V, ~cmp, m, g_m)
980
981
982def values_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
985def values_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
986 iterator_s(~K, ~V, ~cmp, m, g_m)
987
988
989def replace_if_apply_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
996def replace_if_apply_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & Bool}:
997 match equal:
998 case False{}:
999 {==}
1000 case True{}:
1001 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
1005def 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<K, V> & 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
1012def 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<K, V> & 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<K, V, cmp> & 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
1020def iterator_has_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +next: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, 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
1027def iterator_has_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +next: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.iterator_has_checked(~K, ~V, ~cmp, next, current, lower, upper, forward, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rcp(~K, ~V, ~cmp, Bool, MI.iterator_has_checked(~K, ~V, ~cmp, next, current, lower, upper, forward, r)) : M.Cursor<K, V, cmp> & 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
1035def view_entry_result_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, r: ST.Sh<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, r) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, 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
1042def view_entry_result_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, r: ST.Sh<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, r) == True{} : Bool}) -> {M.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, r)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, r)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
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
1050def attach_side_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1061def attach_side_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
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
1073def replace_if_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +expected: V, +replacement: V, r: ST.Sh<K, V> & 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
1078def replace_if_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +expected: V, +replacement: V, r: ST.Sh<K, V> & 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<K, V, cmp> & Bool}:
1079 match r:
1080 case Tuple{+m, M.Search{+id, +p, +on_left}}:
1081 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
1085def attach_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1088def attach_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
1089 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp>}
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
1093def black_root_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh<K, V> & 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
1098def black_root_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh<K, V> & 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<K, V, cmp>}:
1099 match pair_result:
1100 case Tuple{+m1, +r}:
1101 set_red_s(~K, ~V, ~cmp, m1, r, False{}, g_pair_result)
1102
1103
1104def reuse_slot_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V>, 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
1107def reuse_slot_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V>, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}:
1108 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V>, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
1109 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V>, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
1110 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V>, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, 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
1114def set_key_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +k: K, +node: M.Node<K>, +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
1121def set_key_node_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +k: K, +node: M.Node<K>, +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<K, V, cmp>}:
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
1129def recycle_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1134def recycle_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
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<K, V, cmp>, 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<K, V, cmp>}
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
1144def 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<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +y: M.Node<K>, +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<K, V>>, 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<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
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
1155def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id))) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
1156 match id:
1157 case 0n:
1158 {==}
1159 case 1n+ +i:
1160 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i))) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
1161 %Equal.sym(M.NodeStore<K> & 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<K>, 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<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i))) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
1162 es_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), ST.nth_or(Maybe<&2, V>, pl, i, None{}))
1163
1164def es_m(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, (m, id))) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), id)
1168
1169def entry_snapshot_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & 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<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
1170 match r:
1171 case Tuple{+m, +id}:
1172 es_m(~K, ~V, ~cmp, m, id, g_r)
1173
1174def entry_snapshot_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, 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
1179def entry_snapshot_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, 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
1184def rotate_left_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, +yn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, 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
1189def rotate_left_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, +yn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, pair_result)) : M.TreeMap<K, V, cmp>}:
1190 match pair_result:
1191 case Tuple{+m3, +pn}:
1192 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp>}
1193 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp>}
1194 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp>}
1195 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp>}
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
1199def rotate_right_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, +yn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, 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
1204def rotate_right_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, +yn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, pair_result)) : M.TreeMap<K, V, cmp>}:
1205 match pair_result:
1206 case Tuple{+m3, +pn}:
1207 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp>}
1208 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp>}
1209 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp>}
1210 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp>}
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
1214def black_root_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1217def black_root_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
1218 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp>}
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
1222def alloc_read_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +p: Nat, +k: K, +v: V, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, 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
1229def alloc_read_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +p: Nat, +k: K, +v: V, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.alloc_read(~K, ~V, ~cmp, id, p, k, v, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.alloc_read(~K, ~V, ~cmp, id, p, k, v, r)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, 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
1237def set_key_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +k: K, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, 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
1242def set_key_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +k: K, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.set_key_1(~K, ~V, ~cmp, id, k, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.set_key_1(~K, ~V, ~cmp, id, k, pair_result)) : M.TreeMap<K, V, cmp>}:
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
1248def first_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, 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
1251def first_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V>>, MI.first_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
1252 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V>>, MI.first_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
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
1256def last_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, 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
1259def last_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V>>, MI.last_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
1260 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V>>, MI.last_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
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
1268def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node<K>}, 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<K, V, cmp> & 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<K, V, cmp> & M.Search}:
1269 match c0:
1270 case LT{}:
1271 %Equal.sym(M.NodeStore<K> & 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<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, 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<K, V, cmp> & M.Search}
1272 %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, 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<K, V, cmp> & M.Search}
1273 ih(lf, 1n+i, True{})
1274 case GT{}:
1275 %Equal.sym(M.NodeStore<K> & 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<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, 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<K, V, cmp> & M.Search}
1276 %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, 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<K, V, cmp> & M.Search}
1277 ih(rt, 1n+i, False{})
1278 case EQ{}:
1279 {==}
1280
1281def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node<K>}, 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<K, V, cmp> & 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<K, V, cmp> & 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<K, V, cmp> & 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
1285def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +k: K, +f: Nat, +i: Nat, +p: Nat, +ol: Bool, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}, 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<K, V, cmp> & 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<K, V, cmp> & 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
1292def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K, V, cmp> & M.Search}:
1293 match c0:
1294 case LT{}:
1295 {==}
1296 case GT{}:
1297 {==}
1298 case EQ{}:
1299 {==}
1300
1301def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K, V, cmp> & 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<K, V, cmp> & 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
1305def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +k: K, +i: Nat, +p: Nat, +ol: Bool, +y: M.Node<K>) -> {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<K, V, cmp> & 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
1313def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K, V, cmp> & M.Search}:
1314 match fuel id:
1315 case 0n 0n:
1316 {==}
1317 case 0n 1n+ +i:
1318 %Equal.sym(M.NodeStore<K> & 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<K>, 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<K>, nl, i, M.Free{0n}))))) : M.TreeMap<K, V, cmp> & 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<K>, nl, i, M.Free{0n}))
1320 case 1n+f 0n:
1321 {==}
1322 case 1n+ +f 1n+ +i:
1323 %Equal.sym(M.NodeStore<K> & 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<K>, 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<K>, nl, i, M.Free{0n}))))) : M.TreeMap<K, V, cmp> & 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<K>, 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
1326def search_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), k, 1n+n, root, 0n, False{})
1330
1331
1332def probe_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, (M.Node<K> & 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
1336def 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<K, V> & (M.Node<K> & Cmp), +g_st: {MI.dgp(K, V, (M.Node<K> & 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
1363def search_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1368def get_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1371def get_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & Maybe<&2, V>}:
1372 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
1376def contains_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1379def contains_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & Bool}:
1380 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
1387def 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<K>>, +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<K, V> & 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
1398def 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<K>>, +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<K> & Nat}:
1399 match fw:
1400 case True{}:
1401 {==}
1402 case False{}:
1403 {==}
1404
1405def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K> & 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<K> & 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<K>, 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<K> & 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<K>, nl, j, M.Free{0n}), fw))
1412
1413def extreme_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & Nat}:
1414 match m:
1415 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
1416 %Equal.sym(ST.Sh<K, V> & 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<K, V, cmp> & Nat}
1417 %Equal.sym(M.NodeStore<K> & 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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, id), forward)))) : M.TreeMap<K, V, cmp> & Nat}
1418 {==}
1419
1420def extreme_probe_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, 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
1425def extreme_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +forward: Bool, +id: Nat, st: ST.Sh<K, V> & 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
1436def extreme_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1441def replace_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1444def replace_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & Maybe<&2, V>}:
1445 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
1449def iterator_reseek_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: Maybe<&2, K>, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & 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
1456def iterator_reseek_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: Maybe<&2, K>, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & 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<K, V, cmp> & 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<K, V, cmp> & 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<K, V, cmp> & 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
1465def replace_if_equal_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh<K, V>, +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
1468def replace_if_equal_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh<K, V>, +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<K, V, cmp> & Bool}:
1469 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
1473def rotate_left_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, 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
1478def rotate_left_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.rotate_left_2(~K, ~V, ~cmp, x, xn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_2(~K, ~V, ~cmp, x, xn, pair_result)) : M.TreeMap<K, V, cmp>}:
1479 match pair_result:
1480 case Tuple{+m2, +yn}:
1481 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), M.node_parent(~K, xn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K, V, cmp>}
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
1485def rotate_right_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, 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
1490def rotate_right_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.rotate_right_2(~K, ~V, ~cmp, x, xn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_2(~K, ~V, ~cmp, x, xn, pair_result)) : M.TreeMap<K, V, cmp>}:
1491 match pair_result:
1492 case Tuple{+m2, +yn}:
1493 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), M.node_parent(~K, xn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K, V, cmp>}
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
1496def probe_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K> & Cmp), MI.probe(~K, ~V, ~cmp, m, id, k)) : M.TreeMap<K, V, cmp> & (M.Node<K> & Cmp)}:
1497 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K> & Cmp), MI.probe(~K, ~V, ~cmp, m, id, k)) : M.TreeMap<K, V, cmp> & (M.Node<K> & 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
1501def ascend_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +forward: Bool, st: ST.Sh<K, V> & 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
1510def ascend_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +forward: Bool, st: ST.Sh<K, V> & 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<K, V, cmp> & 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<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px6), px9), MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K, V, cmp> & Nat}
1518 %Equal.sym(M.TreeMap<K, V, cmp> & M.Ascend, M.ascend_step_node(~K, ~V, ~cmp, px8, px9, forward, MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K, V, cmp> & 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
1522def neighbor_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1525def neighbor_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & Nat}:
1526 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K, V, cmp> & 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
1530def set_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1533def set_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
1534 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K, V, cmp>}
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
1538def refresh_ends_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +r: Nat, pair_result: ST.Sh<K, V> & 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
1543def refresh_ends_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +r: Nat, pair_result: ST.Sh<K, V> & 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<K, V, cmp>}:
1544 match pair_result:
1545 case Tuple{+m2, +lo}:
1546 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp>}
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
1550def key_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & 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
1555def key_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & 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<K, V, cmp> & Maybe<&2, K>}:
1556 match r:
1557 case Tuple{+m, +id}:
1558 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K, V, cmp> & 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
1562def get_or_default_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1565def get_or_default_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & V}:
1566 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
1570def view_get_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +lower: M.Bound<K>, +upper: M.Bound<K>, +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
1577def view_get_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +lower: M.Bound<K>, +upper: M.Bound<K>, +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<K, V, cmp> & Maybe<&2, V>}:
1578 match valid:
1579 case True{}:
1580 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
1586def iterator_has_next_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +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
1591def iterator_has_next_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +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<K, V, cmp> & Bool}:
1592 match cursor:
1593 case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
1594 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), next), MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K, V, cmp> & 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
1598def rotate_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, 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
1603def rotate_left_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.rotate_left_1(~K, ~V, ~cmp, x, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_1(~K, ~V, ~cmp, x, pair_result)) : M.TreeMap<K, V, cmp>}:
1604 match pair_result:
1605 case Tuple{+m1, +xn}:
1606 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_right(~K, xn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K, V, cmp>}
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
1610def rotate_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, 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
1615def rotate_right_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.rotate_right_1(~K, ~V, ~cmp, x, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_1(~K, ~V, ~cmp, x, pair_result)) : M.TreeMap<K, V, cmp>}:
1616 match pair_result:
1617 case Tuple{+m1, +xn}:
1618 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_left(~K, xn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K, V, cmp>}
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
1621def 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<K, V> & (M.Node<K> & Cmp), +g_st: {MI.dgp(K, V, (M.Node<K> & Cmp), st) == True{} : Bool}) -> {M.search_loop(~K, ~V, ~cmp, fuel, k, id, p, on_left, MI.rp(~K, ~V, ~cmp, (M.Node<K> & Cmp), st)) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, fuel, k, id, p, on_left, st)) : M.TreeMap<K, V, cmp> & 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<K, V, cmp> & (M.Node<K> & Cmp), M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px14), px20, k), MI.rp(~K, ~V, ~cmp, (M.Node<K> & 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<K, V, cmp> & 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<K, V, cmp> & (M.Node<K> & Cmp), M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px14), px21, k), MI.rp(~K, ~V, ~cmp, (M.Node<K> & 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<K, V, cmp> & 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
1651def copy_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +target: Nat, +node: M.Node<K>, +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
1658def copy_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +target: Nat, +node: M.Node<K>, +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<K, V, cmp>}:
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
1666def refresh_ends_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh<K, V> & 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
1671def refresh_ends_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh<K, V> & 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<K, V, cmp>}:
1672 match pair_result:
1673 case Tuple{+m1, +r}:
1674 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp>}
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
1678def nav_equal_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1685def nav_equal_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & Nat}:
1686 match inclusive:
1687 case True{}:
1688 {==}
1689 case False{}:
1690 neighbor_s(~K, ~V, ~cmp, m, id, higher, g_m)
1691
1692
1693def first_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1696def first_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & Maybe<&2, K>}:
1697 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
1701def last_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1704def last_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & Maybe<&2, K>}:
1705 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
1709def view_get_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +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
1714def view_get_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +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<K, V, cmp> & 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
1720def rotate_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1723def rotate_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
1724 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x), MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K, V, cmp>}
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
1728def rotate_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1731def rotate_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
1732 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x), MI.rp(~K, ~V, ~cmp, M.Node<K>, 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<K, V, cmp>}
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
1736def move_successor_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, +source: Nat, +source_node: M.Node<K>, pair_result: ST.Sh<K, V> & 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
1741def move_successor_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, +source: Nat, +source_node: M.Node<K>, pair_result: ST.Sh<K, V> & 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<K, V, cmp> & Nat}:
1742 match pair_result:
1743 case Tuple{+m2, +value}:
1744 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & Nat}
1745 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
1749def refresh_ends_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1752def refresh_ends_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp>}:
1753 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp>}
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
1757def 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<K, V> & (M.Node<K> & Cmp), +g_st: {MI.dgp(K, V, (M.Node<K> & 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
1784def 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<K, V> & (M.Node<K> & Cmp), +g_st: {MI.dgp(K, V, (M.Node<K> & Cmp), st) == True{} : Bool}) -> {M.nav_loop(~K, ~V, ~cmp, fuel, k, higher, inclusive, id, best, MI.rp(~K, ~V, ~cmp, (M.Node<K> & Cmp), st)) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, fuel, k, higher, inclusive, id, best, st)) : M.TreeMap<K, V, cmp> & 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<K, V, cmp> & (M.Node<K> & Cmp), M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px14), px20, k), MI.rp(~K, ~V, ~cmp, (M.Node<K> & 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<K, V, cmp> & 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<K, V, cmp> & (M.Node<K> & Cmp), M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px14), px21, k), MI.rp(~K, ~V, ~cmp, (M.Node<K> & 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<K, V, cmp> & 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
1814def view_contains_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +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
1817def view_contains_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +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<K, V, cmp> & Bool}:
1818 %Equal.sym(M.View<K, V, cmp> & 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<K, V, cmp> & 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
1822def insert_black_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1829def insert_black_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & M.Fix}:
1830 match triangle:
1831 case True{}:
1832 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1833 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1834 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1835 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1836 {==}
1837 case False{}:
1838 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1839 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1840 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1841 {==}
1842
1843
1844def insert_black_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1851def insert_black_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & M.Fix}:
1852 match triangle:
1853 case True{}:
1854 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1855 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1856 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1857 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1858 {==}
1859 case False{}:
1860 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1861 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1862 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1863 {==}
1864
1865
1866def move_successor_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, +source: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, 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
1871def move_successor_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, +source: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.move_successor_1(~K, ~V, ~cmp, target, source, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_1(~K, ~V, ~cmp, target, source, pair_result)) : M.TreeMap<K, V, cmp> & Nat}:
1872 match pair_result:
1873 case Tuple{+m1, +source_node}:
1874 %Equal.sym(M.TreeMap<K, V, cmp> & 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<K, V, cmp> & 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
1878def delete_borrow_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +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
1881def delete_borrow_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +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<K, V, cmp> & M.DeleteFix}:
1882 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.DeleteFix}
1883 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.DeleteFix}
1884 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.DeleteFix}
1885 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.DeleteFix}
1886 {==}
1887
1888
1889def delete_borrow_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +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
1892def delete_borrow_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +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<K, V, cmp> & M.DeleteFix}:
1893 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.DeleteFix}
1894 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.DeleteFix}
1895 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.DeleteFix}
1896 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & 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
1904def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node<K>}, 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<K, V, cmp> & 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<K, V, cmp> & Nat}:
1905 match c0:
1906 case LT{}:
1907 %Equal.sym(M.NodeStore<K> & 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<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, 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<K, V, cmp> & Nat}
1908 %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, 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<K, V, cmp> & Nat}
1909 ih(lf, M.pick(Nat, h, 1n+i, b))
1910 case GT{}:
1911 %Equal.sym(M.NodeStore<K> & 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<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, 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<K, V, cmp> & Nat}
1912 %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, 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<K, V, cmp> & 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
1917def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node<K>}, 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<K, V, cmp> & 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<K, V, cmp> & 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<K, V, cmp> & 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
1921def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}, 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<K, V, cmp> & 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<K, V, cmp> & 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
1928def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K, V, cmp> & Nat}:
1929 match c0:
1930 case LT{}:
1931 {==}
1932 case GT{}:
1933 {==}
1934 case EQ{}:
1935 {==}
1936
1937def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K, V, cmp> & 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<K, V, cmp> & 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
1941def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>) -> {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<K, V, cmp> & 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
1949def 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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K, V, cmp> & Nat}:
1950 match fuel id:
1951 case 0n 0n:
1952 {==}
1953 case 0n 1n+ +i:
1954 %Equal.sym(M.NodeStore<K> & 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<K>, 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<K>, nl, i, M.Free{0n}))))) : M.TreeMap<K, V, cmp> & 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<K>, nl, i, M.Free{0n}))
1956 case 1n+f 0n:
1957 {==}
1958 case 1n+ +f 1n+ +i:
1959 %Equal.sym(M.NodeStore<K> & 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<K>, 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<K>, nl, i, M.Free{0n}))))) : M.TreeMap<K, V, cmp> & 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<K>, 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
1962def navigate_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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<K, V, cmp> & 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), g_m, k, higher, inclusive, 1n+n, root, 0n)
1966
1967def navigate_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +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
1972def insert_uncle_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +u: Nat, +triangle: Bool, +uncle: M.Node<K>, +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
1981def insert_uncle_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +u: Nat, +triangle: Bool, +uncle: M.Node<K>, +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<K, V, cmp> & M.Fix}:
1982 match uncle:
1983 case M.N{True{}, +px4, +px5, +px6, +px7}:
1984 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1985 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & M.Fix}
1986 %Equal.sym(M.TreeMap<K, V, cmp>, 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<K, V, cmp> & 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
1994def insert_uncle_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +u: Nat, +triangle: Bool, +uncle: M.Node<K>, +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}:
2001 insert_black_right_g(~K, ~V, ~cmp, m, z, p, g, triangle, g_m)
2002
2003def insert_uncle_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +u: Nat, +triangle: Bool, +uncle: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_uncle_right(~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_right(~K, ~V, ~cmp, m, z, p, g, u, triangle, uncle)) : M.TreeMap<K, V, cmp> & M.Fix}:
2004 match uncle:
2005 case M.N{True{}, +px4, +px5, +px6, +px7}:
2006 %Equal.sym(M.TreeMap<K, V, cmp>, 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_right(~K, ~V, ~cmp, m, z, p, g, u, triangle, M.N{True{}, px4, px5, px6, px7})) : M.TreeMap<K, V, cmp> & M.Fix}
2007 %Equal.sym(M.TreeMap<K, V, cmp>, 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_right(~K, ~V, ~cmp, m, z, p, g, u, triangle, M.N{True{}, px4, px5, px6, px7})) : M.TreeMap<K, V, cmp> & M.Fix}
2008 %Equal.sym(M.TreeMap<K, V, cmp>, 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_right(~K, ~V, ~cmp, m, z, p, g, u, triangle, M.N{True{}, px4, px5, px6, px7})) : M.TreeMap<K, V, cmp> & M.Fix}
2009 {==}
2010 case M.Free{+px2}:
2011 insert_black_right_s(~K, ~V, ~cmp, m, z, p, g, triangle, g_m)
2012 case M.N{False{}, +px4, +px5, +px6, +px7}:
2013 insert_black_right_s(~K, ~V, ~cmp, m, z, p, g, triangle, g_m)
2014
2015
2016def move_successor_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +target: Nat, +source: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.move_successor(~K, ~V, ~cmp, m, target, source)) == True{} : Bool}:
2017 move_successor_1_g(~K, ~V, ~cmp, target, source, MI.read(~K, ~V, ~cmp, m, source), read_g(~K, ~V, ~cmp, m, source, g_m))
2018
2019def move_successor_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +target: Nat, +source: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.move_successor(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), target, source) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor(~K, ~V, ~cmp, m, target, source)) : M.TreeMap<K, V, cmp> & Nat}:
2020 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), source), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, source)), read_s(~K, ~V, ~cmp, m, source, g_m)) : {M.move_successor_1(~K, ~V, ~cmp, target, source, _) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor(~K, ~V, ~cmp, m, target, source)) : M.TreeMap<K, V, cmp> & Nat}
2021 move_successor_1_s(~K, ~V, ~cmp, target, source, MI.read(~K, ~V, ~cmp, m, source), read_g(~K, ~V, ~cmp, m, source, g_m))
2022
2023
2024def delete_borrow_read_left_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_read_left_2(~K, ~V, ~cmp, p, pn, pair_result)) == True{} : Bool}:
2025 match pair_result:
2026 case Tuple{+m2, +wn}:
2027 delete_borrow_left_g(~K, ~V, ~cmp, m2, p, M.node_right(~K, pn), pn, wn, g_pair_result)
2028
2029def delete_borrow_read_left_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_borrow_read_left_2(~K, ~V, ~cmp, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_left_2(~K, ~V, ~cmp, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2030 match pair_result:
2031 case Tuple{+m2, +wn}:
2032 delete_borrow_left_s(~K, ~V, ~cmp, m2, p, M.node_right(~K, pn), pn, wn, g_pair_result)
2033
2034
2035def delete_borrow_read_right_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_read_right_2(~K, ~V, ~cmp, p, pn, pair_result)) == True{} : Bool}:
2036 match pair_result:
2037 case Tuple{+m2, +wn}:
2038 delete_borrow_right_g(~K, ~V, ~cmp, m2, p, M.node_left(~K, pn), pn, wn, g_pair_result)
2039
2040def delete_borrow_read_right_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_borrow_read_right_2(~K, ~V, ~cmp, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_right_2(~K, ~V, ~cmp, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2041 match pair_result:
2042 case Tuple{+m2, +wn}:
2043 delete_borrow_right_s(~K, ~V, ~cmp, m2, p, M.node_left(~K, pn), pn, wn, g_pair_result)
2044
2045
2046def lower_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.lower_key(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
2047 key_id_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, False{}, g_m))
2048
2049def lower_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.lower_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.lower_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
2050 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, False{}, False{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, False{}, False{})), navigate_s(~K, ~V, ~cmp, m, k, False{}, False{}, g_m)) : {M.key_id(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.lower_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}
2051 key_id_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, False{}, g_m))
2052
2053
2054def floor_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.floor_key(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
2055 key_id_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, True{}, g_m))
2056
2057def floor_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.floor_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.floor_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
2058 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, False{}, True{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, False{}, True{})), navigate_s(~K, ~V, ~cmp, m, k, False{}, True{}, g_m)) : {M.key_id(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.floor_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}
2059 key_id_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, True{}, g_m))
2060
2061
2062def ceiling_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.ceiling_key(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
2063 key_id_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, True{}, g_m))
2064
2065def ceiling_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.ceiling_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.ceiling_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
2066 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, True{}, True{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, True{}, True{})), navigate_s(~K, ~V, ~cmp, m, k, True{}, True{}, g_m)) : {M.key_id(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.ceiling_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}
2067 key_id_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, True{}, g_m))
2068
2069
2070def higher_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.higher_key(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
2071 key_id_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, False{}, g_m))
2072
2073def higher_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.higher_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.higher_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
2074 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, True{}, False{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, True{}, False{})), navigate_s(~K, ~V, ~cmp, m, k, True{}, False{}, g_m)) : {M.key_id(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.higher_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}
2075 key_id_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, False{}, g_m))
2076
2077
2078def lower_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.lower_entry(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
2079 entry_snapshot_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, False{}, g_m))
2080
2081def lower_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.lower_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.lower_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2082 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, False{}, False{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, False{}, False{})), navigate_s(~K, ~V, ~cmp, m, k, False{}, False{}, g_m)) : {M.entry_snapshot(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.lower_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2083 entry_snapshot_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, False{}, g_m))
2084
2085
2086def floor_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.floor_entry(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
2087 entry_snapshot_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, True{}, g_m))
2088
2089def floor_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.floor_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.floor_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2090 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, False{}, True{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, False{}, True{})), navigate_s(~K, ~V, ~cmp, m, k, False{}, True{}, g_m)) : {M.entry_snapshot(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.floor_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2091 entry_snapshot_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, True{}, g_m))
2092
2093
2094def ceiling_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.ceiling_entry(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
2095 entry_snapshot_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, True{}, g_m))
2096
2097def ceiling_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.ceiling_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.ceiling_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2098 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, True{}, True{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, True{}, True{})), navigate_s(~K, ~V, ~cmp, m, k, True{}, True{}, g_m)) : {M.entry_snapshot(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.ceiling_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2099 entry_snapshot_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, True{}, g_m))
2100
2101
2102def higher_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.higher_entry(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
2103 entry_snapshot_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, False{}, g_m))
2104
2105def higher_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.higher_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.higher_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2106 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, True{}, False{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, True{}, False{})), navigate_s(~K, ~V, ~cmp, m, k, True{}, False{}, g_m)) : {M.entry_snapshot(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.higher_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2107 entry_snapshot_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, False{}, g_m))
2108
2109
2110def range_start_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +bound: M.Bound<K>, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.range_start(~K, ~V, ~cmp, m, bound, forward)) == True{} : Bool}:
2111 match bound:
2112 case M.Unbounded{}:
2113 range_unbounded_g(~K, ~V, ~cmp, m, forward, g_m)
2114 case M.Inclusive{+px2}:
2115 navigate_g(~K, ~V, ~cmp, m, px2, forward, True{}, g_m)
2116 case M.Exclusive{+px3}:
2117 navigate_g(~K, ~V, ~cmp, m, px3, forward, False{}, g_m)
2118
2119def range_start_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +bound: M.Bound<K>, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.range_start(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), bound, forward) == MI.rp(~K, ~V, ~cmp, Nat, MI.range_start(~K, ~V, ~cmp, m, bound, forward)) : M.TreeMap<K, V, cmp> & Nat}:
2120 match bound:
2121 case M.Unbounded{}:
2122 range_unbounded_s(~K, ~V, ~cmp, m, forward, g_m)
2123 case M.Inclusive{+px2}:
2124 navigate_s(~K, ~V, ~cmp, m, px2, forward, True{}, g_m)
2125 case M.Exclusive{+px3}:
2126 navigate_s(~K, ~V, ~cmp, m, px3, forward, False{}, g_m)
2127
2128
2129def insert_side_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_side_left_1(~K, ~V, ~cmp, z, p, g, pn, gn, pair_result)) == True{} : Bool}:
2130 match pair_result:
2131 case Tuple{+m1, +un}:
2132 insert_uncle_left_g(~K, ~V, ~cmp, m1, z, p, g, M.node_right(~K, gn), Nat.is_eq(z, M.node_right(~K, pn)), un, g_pair_result)
2133
2134def insert_side_left_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.insert_side_left_1(~K, ~V, ~cmp, z, p, g, pn, gn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side_left_1(~K, ~V, ~cmp, z, p, g, pn, gn, pair_result)) : M.TreeMap<K, V, cmp> & M.Fix}:
2135 match pair_result:
2136 case Tuple{+m1, +un}:
2137 insert_uncle_left_s(~K, ~V, ~cmp, m1, z, p, g, M.node_right(~K, gn), Nat.is_eq(z, M.node_right(~K, pn)), un, g_pair_result)
2138
2139
2140def insert_side_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_side_right_1(~K, ~V, ~cmp, z, p, g, pn, gn, pair_result)) == True{} : Bool}:
2141 match pair_result:
2142 case Tuple{+m1, +un}:
2143 insert_uncle_right_g(~K, ~V, ~cmp, m1, z, p, g, M.node_left(~K, gn), Nat.is_eq(z, M.node_left(~K, pn)), un, g_pair_result)
2144
2145def insert_side_right_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.insert_side_right_1(~K, ~V, ~cmp, z, p, g, pn, gn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side_right_1(~K, ~V, ~cmp, z, p, g, pn, gn, pair_result)) : M.TreeMap<K, V, cmp> & M.Fix}:
2146 match pair_result:
2147 case Tuple{+m1, +un}:
2148 insert_uncle_right_s(~K, ~V, ~cmp, m1, z, p, g, M.node_left(~K, gn), Nat.is_eq(z, M.node_left(~K, pn)), un, g_pair_result)
2149
2150
2151def allocate_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.allocate(~K, ~V, ~cmp, m, p, k, v)) == True{} : Bool}:
2152 match m:
2153 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
2154 match free:
2155 case 0n:
2156 append_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 0n, l_0, d_0, nl_0, pl_0, t_0, fl_0}, k, v, p, g_m)
2157 case 1n+ +px2:
2158 alloc_read_g(~K, ~V, ~cmp, 1n+px2, p, k, v, MI.read(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}, 1n+px2), read_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}, 1n+px2, g_m))
2159
2160def allocate_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.allocate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, k, v) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.allocate(~K, ~V, ~cmp, m, p, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}:
2161 match m:
2162 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
2163 match free:
2164 case 0n:
2165 append_s(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 0n, l_0, d_0, nl_0, pl_0, t_0, fl_0}, k, v, p, g_m)
2166 case 1n+ +px2:
2167 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}), 1n+px2), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}, 1n+px2)), read_s(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}, 1n+px2, g_m)) : {M.alloc_read(~K, ~V, ~cmp, 1n+px2, p, k, v, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.allocate(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, p, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
2168 alloc_read_s(~K, ~V, ~cmp, 1n+px2, p, k, v, MI.read(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}, 1n+px2), read_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}, 1n+px2, g_m))
2169
2170
2171def successor_ready_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.successor_ready(~K, ~V, ~cmp, target, r)) == True{} : Bool}:
2172 match r:
2173 case Tuple{+m, +source}:
2174 move_successor_g(~K, ~V, ~cmp, m, target, source, g_r)
2175
2176def successor_ready_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.successor_ready(~K, ~V, ~cmp, target, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rp(~K, ~V, ~cmp, Nat, MI.successor_ready(~K, ~V, ~cmp, target, r)) : M.TreeMap<K, V, cmp> & Nat}:
2177 match r:
2178 case Tuple{+m, +source}:
2179 move_successor_s(~K, ~V, ~cmp, m, target, source, g_r)
2180
2181
2182def delete_borrow_read_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_read_left_1(~K, ~V, ~cmp, p, pair_result)) == True{} : Bool}:
2183 match pair_result:
2184 case Tuple{+m1, +pn}:
2185 delete_borrow_read_left_2_g(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_right(~K, pn), g_pair_result))
2186
2187def delete_borrow_read_left_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_borrow_read_left_1(~K, ~V, ~cmp, p, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_left_1(~K, ~V, ~cmp, p, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2188 match pair_result:
2189 case Tuple{+m1, +pn}:
2190 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_right(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, pn))), read_s(~K, ~V, ~cmp, m1, M.node_right(~K, pn), g_pair_result)) : {M.delete_borrow_read_left_2(~K, ~V, ~cmp, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_left_1(~K, ~V, ~cmp, p, Tuple{m1, pn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2191 delete_borrow_read_left_2_s(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_right(~K, pn), g_pair_result))
2192
2193
2194def delete_borrow_read_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_read_right_1(~K, ~V, ~cmp, p, pair_result)) == True{} : Bool}:
2195 match pair_result:
2196 case Tuple{+m1, +pn}:
2197 delete_borrow_read_right_2_g(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_left(~K, pn), g_pair_result))
2198
2199def delete_borrow_read_right_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_borrow_read_right_1(~K, ~V, ~cmp, p, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_right_1(~K, ~V, ~cmp, p, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2200 match pair_result:
2201 case Tuple{+m1, +pn}:
2202 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_left(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, pn))), read_s(~K, ~V, ~cmp, m1, M.node_left(~K, pn), g_pair_result)) : {M.delete_borrow_read_right_2(~K, ~V, ~cmp, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_right_1(~K, ~V, ~cmp, p, Tuple{m1, pn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2203 delete_borrow_read_right_2_s(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_left(~K, pn), g_pair_result))
2204
2205
2206def view_iterator_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgc(K, V, MI.view_iterator(~K, ~V, ~cmp, view)) == True{} : Bool}:
2207 match view:
2208 case MI.MV{+m, +lower, +upper, +descending}:
2209 cursor_started_g(~K, ~V, ~cmp, lower, upper, Bool.not(descending), MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending)), range_start_g(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending), g_view))
2210
2211def view_iterator_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_iterator(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == MI.rc(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, view)) : M.Cursor<K, V, cmp>}:
2212 match view:
2213 case MI.MV{+m, +lower, +upper, +descending}:
2214 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.range_start(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending)), MI.rp(~K, ~V, ~cmp, Nat, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending))), range_start_s(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending), g_view)) : {M.cursor_started(~K, ~V, ~cmp, lower, upper, Bool.not(descending), _) == MI.rc(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{m, lower, upper, descending})) : M.Cursor<K, V, cmp>}
2215 cursor_started_s(~K, ~V, ~cmp, lower, upper, Bool.not(descending), MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending)), range_start_g(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending), g_view))
2216
2217
2218def view_nav_start_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +lower: M.Bound<K>, +upper: M.Bound<K>, +higher: Bool, +inclusive: Bool, +within: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, higher, inclusive, within)) == True{} : Bool}:
2219 match within:
2220 case True{}:
2221 navigate_g(~K, ~V, ~cmp, m, k, higher, inclusive, g_m)
2222 case False{}:
2223 range_start_g(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, higher, lower, upper), higher, g_m)
2224
2225def view_nav_start_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +lower: M.Bound<K>, +upper: M.Bound<K>, +higher: Bool, +inclusive: Bool, +within: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.view_nav_start(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, lower, upper, higher, inclusive, within) == MI.rp(~K, ~V, ~cmp, Nat, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, higher, inclusive, within)) : M.TreeMap<K, V, cmp> & Nat}:
2226 match within:
2227 case True{}:
2228 navigate_s(~K, ~V, ~cmp, m, k, higher, inclusive, g_m)
2229 case False{}:
2230 range_start_s(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, higher, lower, upper), higher, g_m)
2231
2232
2233def view_extreme_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +first: Bool, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_extreme(~K, ~V, ~cmp, view, first)) == True{} : Bool}:
2234 match view:
2235 case MI.MV{+m, +lower, +upper, +descending}:
2236 +up = M.pick(Bool, descending, Bool.not(first), first)
2237 view_entry_result_g(~K, ~V, ~cmp, lower, upper, descending, MI.entry_snapshot(~K, ~V, ~cmp, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up)), entry_snapshot_g(~K, ~V, ~cmp, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up), range_start_g(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up, g_view)))
2238
2239def view_extreme_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +first: Bool, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_extreme(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), first) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_extreme(~K, ~V, ~cmp, view, first)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2240 match view:
2241 case MI.MV{+m, +lower, +upper, +descending}:
2242 +up = M.pick(Bool, descending, Bool.not(first), first)
2243 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.range_start(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.pick(M.Bound<K>, up, lower, upper), up), MI.rp(~K, ~V, ~cmp, Nat, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up)), range_start_s(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up, g_view)) : {M.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, M.entry_snapshot(~K, ~V, ~cmp, _)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_extreme(~K, ~V, ~cmp, MI.MV{m, lower, upper, descending}, first)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2244 %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.entry_snapshot(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up))), MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up))), entry_snapshot_s(~K, ~V, ~cmp, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up), range_start_g(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up, g_view))) : {M.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, _) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_extreme(~K, ~V, ~cmp, MI.MV{m, lower, upper, descending}, first)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2245 view_entry_result_s(~K, ~V, ~cmp, lower, upper, descending, MI.entry_snapshot(~K, ~V, ~cmp, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up)), entry_snapshot_g(~K, ~V, ~cmp, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up), range_start_g(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up, g_view)))
2246
2247
2248def insert_side_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_side_left(~K, ~V, ~cmp, m, z, p, g, pn, gn)) == True{} : Bool}:
2249 insert_side_left_1_g(~K, ~V, ~cmp, z, p, g, pn, gn, MI.read(~K, ~V, ~cmp, m, M.node_right(~K, gn)), read_g(~K, ~V, ~cmp, m, M.node_right(~K, gn), g_m))
2250
2251def insert_side_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_side_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, pn, gn) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side_left(~K, ~V, ~cmp, m, z, p, g, pn, gn)) : M.TreeMap<K, V, cmp> & M.Fix}:
2252 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_right(~K, gn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, M.node_right(~K, gn))), read_s(~K, ~V, ~cmp, m, M.node_right(~K, gn), g_m)) : {M.insert_side_left_1(~K, ~V, ~cmp, z, p, g, pn, gn, _) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side_left(~K, ~V, ~cmp, m, z, p, g, pn, gn)) : M.TreeMap<K, V, cmp> & M.Fix}
2253 insert_side_left_1_s(~K, ~V, ~cmp, z, p, g, pn, gn, MI.read(~K, ~V, ~cmp, m, M.node_right(~K, gn)), read_g(~K, ~V, ~cmp, m, M.node_right(~K, gn), g_m))
2254
2255
2256def insert_side_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_side_right(~K, ~V, ~cmp, m, z, p, g, pn, gn)) == True{} : Bool}:
2257 insert_side_right_1_g(~K, ~V, ~cmp, z, p, g, pn, gn, MI.read(~K, ~V, ~cmp, m, M.node_left(~K, gn)), read_g(~K, ~V, ~cmp, m, M.node_left(~K, gn), g_m))
2258
2259def insert_side_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_side_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, pn, gn) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side_right(~K, ~V, ~cmp, m, z, p, g, pn, gn)) : M.TreeMap<K, V, cmp> & M.Fix}:
2260 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_left(~K, gn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, M.node_left(~K, gn))), read_s(~K, ~V, ~cmp, m, M.node_left(~K, gn), g_m)) : {M.insert_side_right_1(~K, ~V, ~cmp, z, p, g, pn, gn, _) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side_right(~K, ~V, ~cmp, m, z, p, g, pn, gn)) : M.TreeMap<K, V, cmp> & M.Fix}
2261 insert_side_right_1_s(~K, ~V, ~cmp, z, p, g, pn, gn, MI.read(~K, ~V, ~cmp, m, M.node_left(~K, gn)), read_g(~K, ~V, ~cmp, m, M.node_left(~K, gn), g_m))
2262
2263
2264def delete_target_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.delete_target(~K, ~V, ~cmp, id, r)) == True{} : Bool}:
2265 match r:
2266 case Tuple{+px2, M.N{+px5, 1n+ +px10, 1n+ +px11, +px8, +px9}}:
2267 successor_ready_g(~K, ~V, ~cmp, id, MI.extreme(~K, ~V, ~cmp, px2, 1n+px11, False{}), extreme_g(~K, ~V, ~cmp, px2, 1n+px11, False{}, g_r))
2268 case Tuple{+px2, M.Free{+px4}}:
2269 g_r
2270 case Tuple{+px2, M.N{+px5, 0n, 0n, +px8, +px9}}:
2271 g_r
2272 case Tuple{+px2, M.N{+px5, 0n, 1n+ +px12, +px8, +px9}}:
2273 g_r
2274 case Tuple{+px2, M.N{+px5, 1n+ +px10, 0n, +px8, +px9}}:
2275 g_r
2276
2277def delete_target_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.delete_target(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rp(~K, ~V, ~cmp, Nat, MI.delete_target(~K, ~V, ~cmp, id, r)) : M.TreeMap<K, V, cmp> & Nat}:
2278 match r:
2279 case Tuple{+px2, M.N{+px5, 1n+ +px10, 1n+ +px11, +px8, +px9}}:
2280 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.extreme(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), 1n+px11, False{}), MI.rp(~K, ~V, ~cmp, Nat, MI.extreme(~K, ~V, ~cmp, px2, 1n+px11, False{})), extreme_s(~K, ~V, ~cmp, px2, 1n+px11, False{}, g_r)) : {M.successor_ready(~K, ~V, ~cmp, id, _) == MI.rp(~K, ~V, ~cmp, Nat, MI.delete_target(~K, ~V, ~cmp, id, Tuple{px2, M.N{px5, 1n+ px10, 1n+ px11, px8, px9}})) : M.TreeMap<K, V, cmp> & Nat}
2281 successor_ready_s(~K, ~V, ~cmp, id, MI.extreme(~K, ~V, ~cmp, px2, 1n+px11, False{}), extreme_g(~K, ~V, ~cmp, px2, 1n+px11, False{}, g_r))
2282 case Tuple{+px2, M.Free{+px4}}:
2283 {==}
2284 case Tuple{+px2, M.N{+px5, 0n, 0n, +px8, +px9}}:
2285 {==}
2286 case Tuple{+px2, M.N{+px5, 0n, 1n+ +px12, +px8, +px9}}:
2287 {==}
2288 case Tuple{+px2, M.N{+px5, 1n+ +px10, 0n, +px8, +px9}}:
2289 {==}
2290
2291
2292def delete_borrow_read_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_read_left(~K, ~V, ~cmp, m, p)) == True{} : Bool}:
2293 delete_borrow_read_left_1_g(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))
2294
2295def delete_borrow_read_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_borrow_read_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_left(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2296 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, p)), read_s(~K, ~V, ~cmp, m, p, g_m)) : {M.delete_borrow_read_left_1(~K, ~V, ~cmp, p, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_left(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2297 delete_borrow_read_left_1_s(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))
2298
2299
2300def delete_borrow_read_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_read_right(~K, ~V, ~cmp, m, p)) == True{} : Bool}:
2301 delete_borrow_read_right_1_g(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))
2302
2303def delete_borrow_read_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_borrow_read_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_right(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2304 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, p)), read_s(~K, ~V, ~cmp, m, p, g_m)) : {M.delete_borrow_read_right_1(~K, ~V, ~cmp, p, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_right(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2305 delete_borrow_read_right_1_s(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))
2306
2307
2308# ---- iterator_next: the step reads four fields, the mirror's step the whole node ----
2309
2310
2311# the child the step reads is the one the node's neighbour walk starts from
2312def iq_f(~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<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +i: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +fw: Bool, +key: K, +v: V, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat) -> {M.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, M.neighbor_slots_finish(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.neighbor_slots(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, 1n+i, q, fw, M.pick(Nat, Bool.not(fw), lf, rt)))) == M.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, M.neighbor_node(~K, ~V, ~cmp, 1n+i, fw, (ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}), M.N{c, lf, rt, q, key}))) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2313 match fw:
2314 case True{}:
2315 {==}
2316 case False{}:
2317 {==}
2318
2319# in range: parent and child reads, then the mirror's neighbour and yield
2320def iq_v(~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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +i: Nat, +cur: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +fw: Bool, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +v: V, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node<K>}, +b: Bool) -> {M.iter_valid(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), ST.nodes(~K, l, d, nl), i, cur, lower, upper, fw, M.Entry{key, v}, b) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_checked(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, cur, lower, upper, fw, M.N{c, lf, rt, q, key}, M.Entry{key, v}, b)) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2321 match b:
2322 case False{}:
2323 {==}
2324 case True{}:
2325 %Equal.sym(M.NodeStore<K> & 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<K>, nl, i, M.Free{0n}))), NSL.parent_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.iter_link(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), i, lower, upper, fw, M.Entry{key, v}, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, MI.neighbor_node(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key})))) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2326 %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), M.N{c, lf, rt, q, key}, hy) : {M.iter_link(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), i, lower, upper, fw, M.Entry{key, v}, (ST.nodes(~K, l, d, nl), M.nparent(~K, _))) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, MI.neighbor_node(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key})))) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2327 %Equal.sym(M.NodeStore<K> & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), Bool.not(fw), i), (ST.nodes(~K, l, d, nl), M.pick(Nat, Bool.not(fw), M.nleft(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, Bool.not(fw), i)) : {M.iter_child(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), 1n+i, lower, upper, fw, M.Entry{key, v}, q, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, MI.neighbor_node(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key})))) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2328 %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), M.N{c, lf, rt, q, key}, hy) : {M.iter_child(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), 1n+i, lower, upper, fw, M.Entry{key, v}, q, (ST.nodes(~K, l, d, nl), M.pick(Nat, Bool.not(fw), M.nleft(~K, _), M.nright(~K, _)))) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, MI.neighbor_node(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key})))) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2329 %iterator_yield_s(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, MI.neighbor_node(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key})), neighbor_node_g(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key}), g)) : {M.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, M.neighbor_slots_finish(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.neighbor_slots(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, 1n+i, q, fw, M.pick(Nat, Bool.not(fw), lf, rt)))) == _ : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2330 %neighbor_node_s(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key}), g) : {M.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, M.neighbor_slots_finish(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.neighbor_slots(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, 1n+i, q, fw, M.pick(Nat, Bool.not(fw), lf, rt)))) == M.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, _) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2331 iq_f(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, i, lower, upper, fw, key, v, c, lf, rt, q)
2332
2333# the key and the value decide: a live node with a value is checked, else the walk ends
2334def iq_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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +i: Nat, +cur: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +fw: Bool, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}, +w: Maybe<&2, V>) -> {M.iter_kv(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), ST.nodes(~K, l, d, nl), i, cur, lower, upper, fw, M.nkey(~K, y), w) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_read(~K, ~V, ~cmp, 1n+i, cur, lower, upper, fw, y, 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.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2335 match y w:
2336 case M.Free{z} None{}:
2337 {==}
2338 case M.Free{z} Some{x}:
2339 {==}
2340 case M.N{c, lf, rt, q, key} None{}:
2341 {==}
2342 case M.N{+c, +lf, +rt, +q, +key} Some{+v}:
2343 iq_v(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, i, cur, lower, upper, fw, c, lf, rt, q, key, v, hy, M.in_range(~K, ~V, ~cmp, key, lower, upper))
2344
2345def iq_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<K>>, +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<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +next: Nat, +cur: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +fw: Bool) -> {M.iter_at(~K, ~V, ~cmp, next, cur, lower, upper, fw, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl})) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.MC{ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, next, cur, lower, upper, fw})) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2346 match next:
2347 case 0n:
2348 {==}
2349 case 1n+ +i:
2350 %Equal.sym(M.TreeMap<K, V, cmp> & 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.iter_value(~K, ~V, ~cmp, i, cur, lower, upper, fw, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.MC{ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, cur, lower, upper, fw})) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2351 %Equal.sym(M.NodeStore<K> & 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<K>, nl, i, M.Free{0n}))), NSL.key_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.iter_key(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), i, cur, lower, upper, fw, ST.nth_or(Maybe<&2, V>, pl, i, None{}), _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.MC{ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, cur, lower, upper, fw})) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2352 iq_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, i, cur, lower, upper, fw, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==}, ST.nth_or(Maybe<&2, V>, pl, i, None{}))
2353
2354def iq_m(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +next: Nat, +cur: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +fw: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.iter_at(~K, ~V, ~cmp, next, cur, lower, upper, fw, ST.real(~K, ~V, ~cmp, m)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.MC{m, next, cur, lower, upper, fw})) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2355 match m:
2356 case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
2357 iq_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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, 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<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), g_m, next, cur, lower, upper, fw)
2358
2359def iterator_next_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2360 match cursor:
2361 case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
2362 iq_m(~K, ~V, ~cmp, m, next, current, lower, upper, forward, g_cursor)
2363
2364def iterator_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +node: M.Node<K>, +entry: M.Entry<K, V>, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, MI.iterator_checked(~K, ~V, ~cmp, m, id, current, lower, upper, forward, node, entry, valid)) == True{} : Bool}:
2365 match valid:
2366 case True{}:
2367 iterator_yield_g(~K, ~V, ~cmp, id, lower, upper, forward, entry, MI.neighbor_node(~K, ~V, ~cmp, id, forward, (m, node)), neighbor_node_g(~K, ~V, ~cmp, id, forward, (m, node), g_m))
2368 case False{}:
2369 g_m
2370
2371def iterator_read_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +node: M.Node<K>, r: ST.Sh<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, MI.iterator_read(~K, ~V, ~cmp, id, current, lower, upper, forward, node, r)) == True{} : Bool}:
2372 match r:
2373 case Tuple{+px2, None{}}:
2374 g_r
2375 case Tuple{+px2, Some{M.Entry{+px5, +px6}}}:
2376 iterator_checked_g(~K, ~V, ~cmp, px2, id, current, lower, upper, forward, node, M.Entry{px5, px6}, M.in_range(~K, ~V, ~cmp, px5, lower, upper), g_r)
2377
2378def iterator_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, MI.iterator_node(~K, ~V, ~cmp, id, current, lower, upper, forward, r)) == True{} : Bool}:
2379 match r:
2380 case Tuple{+m, +node}:
2381 iterator_read_g(~K, ~V, ~cmp, id, current, lower, upper, forward, node, MI.entry_value(~K, ~V, ~cmp, M.node_key(~K, node), MI.get_id(~K, ~V, ~cmp, m, id)), 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)))
2382
2383def iterator_next_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, cursor)) == True{} : Bool}:
2384 match cursor:
2385 case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
2386 iterator_node_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))
2387
2388
2389def view_nav_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +higher: Bool, +inclusive: Bool, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_nav(~K, ~V, ~cmp, view, k, higher, inclusive)) == True{} : Bool}:
2390 match view:
2391 case MI.MV{+m, +lower, +upper, +descending}:
2392 +up = M.pick(Bool, descending, Bool.not(higher), higher)
2393 view_entry_result_g(~K, ~V, ~cmp, lower, upper, descending, MI.entry_snapshot(~K, ~V, ~cmp, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)))), entry_snapshot_g(~K, ~V, ~cmp, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper))), view_nav_start_g(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)), g_view)))
2394
2395def view_nav_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +higher: Bool, +inclusive: Bool, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_nav(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k, higher, inclusive) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_nav(~K, ~V, ~cmp, view, k, higher, inclusive)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2396 match view:
2397 case MI.MV{+m, +lower, +upper, +descending}:
2398 +up = M.pick(Bool, descending, Bool.not(higher), higher)
2399 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.view_nav_start(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper))), MI.rp(~K, ~V, ~cmp, Nat, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)))), view_nav_start_s(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)), g_view)) : {M.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, M.entry_snapshot(~K, ~V, ~cmp, _)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_nav(~K, ~V, ~cmp, MI.MV{m, lower, upper, descending}, k, higher, inclusive)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2400 %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.entry_snapshot(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper))))), MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper))))), entry_snapshot_s(~K, ~V, ~cmp, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper))), view_nav_start_g(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)), g_view))) : {M.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, _) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_nav(~K, ~V, ~cmp, MI.MV{m, lower, upper, descending}, k, higher, inclusive)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
2401 view_entry_result_s(~K, ~V, ~cmp, lower, upper, descending, MI.entry_snapshot(~K, ~V, ~cmp, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)))), entry_snapshot_g(~K, ~V, ~cmp, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper))), view_nav_start_g(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)), g_view)))
2402
2403
2404def view_first_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_first_entry(~K, ~V, ~cmp, view)) == True{} : Bool}:
2405 view_extreme_g(~K, ~V, ~cmp, view, True{}, g_view)
2406
2407def view_first_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_first_entry(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_first_entry(~K, ~V, ~cmp, view)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2408 view_extreme_s(~K, ~V, ~cmp, view, True{}, g_view)
2409
2410
2411def view_last_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_last_entry(~K, ~V, ~cmp, view)) == True{} : Bool}:
2412 view_extreme_g(~K, ~V, ~cmp, view, False{}, g_view)
2413
2414def view_last_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_last_entry(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_last_entry(~K, ~V, ~cmp, view)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2415 view_extreme_s(~K, ~V, ~cmp, view, False{}, g_view)
2416
2417
2418def insert_side_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_side(~K, ~V, ~cmp, m, z, p, g, pn, gn, on_left)) == True{} : Bool}:
2419 match on_left:
2420 case True{}:
2421 insert_side_left_g(~K, ~V, ~cmp, m, z, p, g, pn, gn, g_m)
2422 case False{}:
2423 insert_side_right_g(~K, ~V, ~cmp, m, z, p, g, pn, gn, g_m)
2424
2425def insert_side_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_side(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, pn, gn, on_left) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side(~K, ~V, ~cmp, m, z, p, g, pn, gn, on_left)) : M.TreeMap<K, V, cmp> & M.Fix}:
2426 match on_left:
2427 case True{}:
2428 insert_side_left_s(~K, ~V, ~cmp, m, z, p, g, pn, gn, g_m)
2429 case False{}:
2430 insert_side_right_s(~K, ~V, ~cmp, m, z, p, g, pn, gn, g_m)
2431
2432
2433def delete_far_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_far_left(~K, ~V, ~cmp, m, p, w, pn, wn, far_red)) == True{} : Bool}:
2434 match far_red:
2435 case True{}:
2436 delete_borrow_left_g(~K, ~V, ~cmp, m, p, w, pn, wn, g_m)
2437 case False{}:
2438 delete_borrow_read_left_g(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}), w), p, rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}), w, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}, g_m))))
2439
2440def delete_far_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_far_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, pn, wn, far_red) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_left(~K, ~V, ~cmp, m, p, w, pn, wn, far_red)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2441 match far_red:
2442 case True{}:
2443 delete_borrow_left_s(~K, ~V, ~cmp, m, p, w, pn, wn, g_m)
2444 case False{}:
2445 %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_left(~K, wn), False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{})), set_red_s(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}, g_m)) : {M.delete_borrow_read_left(~K, ~V, ~cmp, M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, w, True{}), w), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_left(~K, ~V, ~cmp, m, p, w, pn, wn, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2446 %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{})), w, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}, g_m))) : {M.delete_borrow_read_left(~K, ~V, ~cmp, M.rotate_right(~K, ~V, ~cmp, _, w), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_left(~K, ~V, ~cmp, m, p, w, pn, wn, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2447 %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{})), w), ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}), w)), rotate_right_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}), w, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}, g_m)))) : {M.delete_borrow_read_left(~K, ~V, ~cmp, _, p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_left(~K, ~V, ~cmp, m, p, w, pn, wn, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2448 delete_borrow_read_left_s(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}), w), p, rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}), w, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}, g_m))))
2449
2450
2451def delete_far_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_far_right(~K, ~V, ~cmp, m, p, w, pn, wn, far_red)) == True{} : Bool}:
2452 match far_red:
2453 case True{}:
2454 delete_borrow_right_g(~K, ~V, ~cmp, m, p, w, pn, wn, g_m)
2455 case False{}:
2456 delete_borrow_read_right_g(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}), w), p, rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}), w, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}, g_m))))
2457
2458def delete_far_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_far_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, pn, wn, far_red) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_right(~K, ~V, ~cmp, m, p, w, pn, wn, far_red)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2459 match far_red:
2460 case True{}:
2461 delete_borrow_right_s(~K, ~V, ~cmp, m, p, w, pn, wn, g_m)
2462 case False{}:
2463 %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_right(~K, wn), False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{})), set_red_s(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}, g_m)) : {M.delete_borrow_read_right(~K, ~V, ~cmp, M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, w, True{}), w), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_right(~K, ~V, ~cmp, m, p, w, pn, wn, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2464 %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{})), w, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}, g_m))) : {M.delete_borrow_read_right(~K, ~V, ~cmp, M.rotate_left(~K, ~V, ~cmp, _, w), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_right(~K, ~V, ~cmp, m, p, w, pn, wn, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2465 %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{})), w), ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}), w)), rotate_left_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}), w, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}, g_m)))) : {M.delete_borrow_read_right(~K, ~V, ~cmp, _, p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_right(~K, ~V, ~cmp, m, p, w, pn, wn, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2466 delete_borrow_read_right_s(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}), w), p, rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}), w, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}, g_m))))
2467
2468
2469def iterator_next_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, K>, MI.iterator_next_key(~K, ~V, ~cmp, cursor)) == True{} : Bool}:
2470 iterator_key_result_g(~K, ~V, ~cmp, MI.iterator_next(~K, ~V, ~cmp, cursor), iterator_next_g(~K, ~V, ~cmp, cursor, g_cursor))
2471
2472def iterator_next_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_next_key(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, K>, MI.iterator_next_key(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Maybe<&2, K>}:
2473 %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, cursor)), iterator_next_s(~K, ~V, ~cmp, cursor, g_cursor)) : {M.iterator_key_result(~K, ~V, ~cmp, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, K>, MI.iterator_next_key(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Maybe<&2, K>}
2474 iterator_key_result_s(~K, ~V, ~cmp, MI.iterator_next(~K, ~V, ~cmp, cursor), iterator_next_g(~K, ~V, ~cmp, cursor, g_cursor))
2475
2476
2477def iterator_next_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_next_value(~K, ~V, ~cmp, cursor)) == True{} : Bool}:
2478 iterator_value_result_g(~K, ~V, ~cmp, MI.iterator_next(~K, ~V, ~cmp, cursor), iterator_next_g(~K, ~V, ~cmp, cursor, g_cursor))
2479
2480def iterator_next_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_next_value(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_next_value(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}:
2481 %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, cursor)), iterator_next_s(~K, ~V, ~cmp, cursor, g_cursor)) : {M.iterator_value_result(~K, ~V, ~cmp, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_next_value(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}
2482 iterator_value_result_s(~K, ~V, ~cmp, MI.iterator_next(~K, ~V, ~cmp, cursor), iterator_next_g(~K, ~V, ~cmp, cursor, g_cursor))
2483
2484
2485def contains_value_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +fuel: Nat, +wanted: V, +found: Bool, st: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_st: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, st) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, fuel, wanted, found, st)) == True{} : Bool}:
2486 match fuel found st:
2487 case 0n True{} Tuple{+px4, None{}}:
2488 iterator_finish_g(~K, ~V, ~cmp, px4, g_st)
2489 case 0n True{} Tuple{+px4, Some{+px7}}:
2490 iterator_finish_g(~K, ~V, ~cmp, px4, g_st)
2491 case 1n+ +px6 True{} Tuple{+px4, None{}}:
2492 iterator_finish_g(~K, ~V, ~cmp, px4, g_st)
2493 case 1n+ +px6 True{} Tuple{+px4, Some{+px7}}:
2494 iterator_finish_g(~K, ~V, ~cmp, px4, g_st)
2495 case 0n False{} Tuple{+px9, None{}}:
2496 iterator_finish_g(~K, ~V, ~cmp, px9, g_st)
2497 case 0n False{} Tuple{+px9, Some{+px11}}:
2498 iterator_finish_g(~K, ~V, ~cmp, px9, g_st)
2499 case 1n+ +px8 False{} Tuple{+px12, None{}}:
2500 iterator_finish_g(~K, ~V, ~cmp, px12, g_st)
2501 case 1n+ +px8 False{} Tuple{+px12, Some{M.Entry{+px15, +px16}}}:
2502 contains_value_loop_g(~K, ~V, ~cmp, ~eq, px8, wanted, eq(px16, wanted), MI.iterator_next(~K, ~V, ~cmp, px12), iterator_next_g(~K, ~V, ~cmp, px12, g_st))
2503
2504def contains_value_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +fuel: Nat, +wanted: V, +found: Bool, st: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_st: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, st) == True{} : Bool}) -> {M.contains_value_loop(~K, ~V, ~cmp, ~eq, fuel, wanted, found, MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, st)) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, fuel, wanted, found, st)) : M.TreeMap<K, V, cmp> & Bool}:
2505 match fuel found st:
2506 case 0n True{} Tuple{+px4, None{}}:
2507 %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px4)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px4)), iterator_finish_s(~K, ~V, ~cmp, px4, g_st)) : {(_, True{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 0n, wanted, True{}, Tuple{px4, None{}})) : M.TreeMap<K, V, cmp> & Bool}
2508 {==}
2509 case 0n True{} Tuple{+px4, Some{+px7}}:
2510 %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px4)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px4)), iterator_finish_s(~K, ~V, ~cmp, px4, g_st)) : {(_, True{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 0n, wanted, True{}, Tuple{px4, Some{px7}})) : M.TreeMap<K, V, cmp> & Bool}
2511 {==}
2512 case 1n+ +px6 True{} Tuple{+px4, None{}}:
2513 %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px4)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px4)), iterator_finish_s(~K, ~V, ~cmp, px4, g_st)) : {(_, True{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 1n+ px6, wanted, True{}, Tuple{px4, None{}})) : M.TreeMap<K, V, cmp> & Bool}
2514 {==}
2515 case 1n+ +px6 True{} Tuple{+px4, Some{+px7}}:
2516 %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px4)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px4)), iterator_finish_s(~K, ~V, ~cmp, px4, g_st)) : {(_, True{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 1n+ px6, wanted, True{}, Tuple{px4, Some{px7}})) : M.TreeMap<K, V, cmp> & Bool}
2517 {==}
2518 case 0n False{} Tuple{+px9, None{}}:
2519 %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px9)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px9)), iterator_finish_s(~K, ~V, ~cmp, px9, g_st)) : {(_, False{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 0n, wanted, False{}, Tuple{px9, None{}})) : M.TreeMap<K, V, cmp> & Bool}
2520 {==}
2521 case 0n False{} Tuple{+px9, Some{+px11}}:
2522 %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px9)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px9)), iterator_finish_s(~K, ~V, ~cmp, px9, g_st)) : {(_, False{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 0n, wanted, False{}, Tuple{px9, Some{px11}})) : M.TreeMap<K, V, cmp> & Bool}
2523 {==}
2524 case 1n+ +px8 False{} Tuple{+px12, None{}}:
2525 %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px12)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px12)), iterator_finish_s(~K, ~V, ~cmp, px12, g_st)) : {(_, False{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 1n+ px8, wanted, False{}, Tuple{px12, None{}})) : M.TreeMap<K, V, cmp> & Bool}
2526 {==}
2527 case 1n+ +px8 False{} Tuple{+px12, Some{M.Entry{+px15, +px16}}}:
2528 %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px12)), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, px12)), iterator_next_s(~K, ~V, ~cmp, px12, g_st)) : {M.contains_value_loop(~K, ~V, ~cmp, ~eq, px8, wanted, eq(px16, wanted), _) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 1n+ px8, wanted, False{}, Tuple{px12, Some{M.Entry{px15, px16}}})) : M.TreeMap<K, V, cmp> & Bool}
2529 contains_value_loop_s(~K, ~V, ~cmp, ~eq, px8, wanted, eq(px16, wanted), MI.iterator_next(~K, ~V, ~cmp, px12), iterator_next_g(~K, ~V, ~cmp, px12, g_st))
2530
2531
2532def view_lower_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_lower_entry(~K, ~V, ~cmp, view, k)) == True{} : Bool}:
2533 view_nav_g(~K, ~V, ~cmp, view, k, False{}, False{}, g_view)
2534
2535def view_lower_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_lower_entry(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_lower_entry(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2536 view_nav_s(~K, ~V, ~cmp, view, k, False{}, False{}, g_view)
2537
2538
2539def view_floor_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_floor_entry(~K, ~V, ~cmp, view, k)) == True{} : Bool}:
2540 view_nav_g(~K, ~V, ~cmp, view, k, False{}, True{}, g_view)
2541
2542def view_floor_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_floor_entry(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_floor_entry(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2543 view_nav_s(~K, ~V, ~cmp, view, k, False{}, True{}, g_view)
2544
2545
2546def view_ceiling_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_ceiling_entry(~K, ~V, ~cmp, view, k)) == True{} : Bool}:
2547 view_nav_g(~K, ~V, ~cmp, view, k, True{}, True{}, g_view)
2548
2549def view_ceiling_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_ceiling_entry(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_ceiling_entry(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2550 view_nav_s(~K, ~V, ~cmp, view, k, True{}, True{}, g_view)
2551
2552
2553def view_higher_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_higher_entry(~K, ~V, ~cmp, view, k)) == True{} : Bool}:
2554 view_nav_g(~K, ~V, ~cmp, view, k, True{}, False{}, g_view)
2555
2556def view_higher_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_higher_entry(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_higher_entry(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2557 view_nav_s(~K, ~V, ~cmp, view, k, True{}, False{}, g_view)
2558
2559
2560def view_count_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +count: Nat, st: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_st: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, st) == True{} : Bool}) -> {MI.dgvp(K, V, Nat, MI.view_count_loop(~K, ~V, ~cmp, fuel, count, st)) == True{} : Bool}:
2561 match fuel st:
2562 case 0n Tuple{+px4, None{}}:
2563 iterator_view_g(~K, ~V, ~cmp, px4, g_st)
2564 case 0n Tuple{+px4, Some{+px6}}:
2565 iterator_view_g(~K, ~V, ~cmp, px4, g_st)
2566 case 1n+ +px3 Tuple{+px7, None{}}:
2567 iterator_view_g(~K, ~V, ~cmp, px7, g_st)
2568 case 1n+ +px3 Tuple{+px7, Some{+px9}}:
2569 view_count_loop_g(~K, ~V, ~cmp, px3, 1n+count, MI.iterator_next(~K, ~V, ~cmp, px7), iterator_next_g(~K, ~V, ~cmp, px7, g_st))
2570
2571def view_count_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +count: Nat, st: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_st: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, st) == True{} : Bool}) -> {M.view_count_loop(~K, ~V, ~cmp, fuel, count, MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, st)) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_count_loop(~K, ~V, ~cmp, fuel, count, st)) : M.View<K, V, cmp> & Nat}:
2572 match fuel st:
2573 case 0n Tuple{+px4, None{}}:
2574 %Equal.sym(M.View<K, V, cmp>, M.iterator_view(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px4)), MI.rv(~K, ~V, ~cmp, MI.iterator_view(~K, ~V, ~cmp, px4)), iterator_view_s(~K, ~V, ~cmp, px4, g_st)) : {(_, count) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_count_loop(~K, ~V, ~cmp, 0n, count, Tuple{px4, None{}})) : M.View<K, V, cmp> & Nat}
2575 {==}
2576 case 0n Tuple{+px4, Some{+px6}}:
2577 %Equal.sym(M.View<K, V, cmp>, M.iterator_view(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px4)), MI.rv(~K, ~V, ~cmp, MI.iterator_view(~K, ~V, ~cmp, px4)), iterator_view_s(~K, ~V, ~cmp, px4, g_st)) : {(_, count) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_count_loop(~K, ~V, ~cmp, 0n, count, Tuple{px4, Some{px6}})) : M.View<K, V, cmp> & Nat}
2578 {==}
2579 case 1n+ +px3 Tuple{+px7, None{}}:
2580 %Equal.sym(M.View<K, V, cmp>, M.iterator_view(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px7)), MI.rv(~K, ~V, ~cmp, MI.iterator_view(~K, ~V, ~cmp, px7)), iterator_view_s(~K, ~V, ~cmp, px7, g_st)) : {(_, count) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_count_loop(~K, ~V, ~cmp, 1n+ px3, count, Tuple{px7, None{}})) : M.View<K, V, cmp> & Nat}
2581 {==}
2582 case 1n+ +px3 Tuple{+px7, Some{+px9}}:
2583 %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px7)), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, px7)), iterator_next_s(~K, ~V, ~cmp, px7, g_st)) : {M.view_count_loop(~K, ~V, ~cmp, px3, 1n+count, _) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_count_loop(~K, ~V, ~cmp, 1n+ px3, count, Tuple{px7, Some{px9}})) : M.View<K, V, cmp> & Nat}
2584 view_count_loop_s(~K, ~V, ~cmp, px3, 1n+count, MI.iterator_next(~K, ~V, ~cmp, px7), iterator_next_g(~K, ~V, ~cmp, px7, g_st))
2585
2586
2587def view_clear_next_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor<K, V> & Maybe<&2, V>, +g_r: {MI.dgcp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_clear_next(~K, ~V, ~cmp, r)) == True{} : Bool}:
2588 match r:
2589 case Tuple{+cursor, +removed}:
2590 iterator_next_g(~K, ~V, ~cmp, cursor, g_r)
2591
2592def view_clear_next_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor<K, V> & Maybe<&2, V>, +g_r: {MI.dgcp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.view_clear_next(~K, ~V, ~cmp, MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_clear_next(~K, ~V, ~cmp, r)) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
2593 match r:
2594 case Tuple{+cursor, +removed}:
2595 iterator_next_s(~K, ~V, ~cmp, cursor, g_r)
2596
2597
2598def insert_grand_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_grand_1(~K, ~V, ~cmp, z, p, pn, pair_result)) == True{} : Bool}:
2599 match pair_result:
2600 case Tuple{+m1, +gn}:
2601 insert_side_g(~K, ~V, ~cmp, m1, z, p, M.node_parent(~K, pn), pn, gn, Nat.is_eq(p, M.node_left(~K, gn)), g_pair_result)
2602
2603def insert_grand_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.insert_grand_1(~K, ~V, ~cmp, z, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_grand_1(~K, ~V, ~cmp, z, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.Fix}:
2604 match pair_result:
2605 case Tuple{+m1, +gn}:
2606 insert_side_s(~K, ~V, ~cmp, m1, z, p, M.node_parent(~K, pn), pn, gn, Nat.is_eq(p, M.node_left(~K, gn)), g_pair_result)
2607
2608
2609def delete_children_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_red: Bool, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_children_left(~K, ~V, ~cmp, m, p, w, pn, wn, near_red, far_red)) == True{} : Bool}:
2610 match near_red far_red:
2611 case False{} False{}:
2612 set_red_g(~K, ~V, ~cmp, m, w, True{}, g_m)
2613 case True{} True{}:
2614 delete_far_left_g(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
2615 case True{} False{}:
2616 delete_far_left_g(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
2617 case False{} True{}:
2618 delete_far_left_g(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
2619
2620def delete_children_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_red: Bool, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_children_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, pn, wn, near_red, far_red) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_children_left(~K, ~V, ~cmp, m, p, w, pn, wn, near_red, far_red)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2621 match near_red far_red:
2622 case False{} False{}:
2623 %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), w, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, True{})), set_red_s(~K, ~V, ~cmp, m, w, True{}, g_m)) : {(_, M.DF{p, M.node_parent(~K, pn), True{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_children_left(~K, ~V, ~cmp, m, p, w, pn, wn, False{}, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2624 {==}
2625 case True{} True{}:
2626 delete_far_left_s(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
2627 case True{} False{}:
2628 delete_far_left_s(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
2629 case False{} True{}:
2630 delete_far_left_s(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
2631
2632
2633def delete_children_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_red: Bool, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_children_right(~K, ~V, ~cmp, m, p, w, pn, wn, near_red, far_red)) == True{} : Bool}:
2634 match near_red far_red:
2635 case False{} False{}:
2636 set_red_g(~K, ~V, ~cmp, m, w, True{}, g_m)
2637 case True{} True{}:
2638 delete_far_right_g(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
2639 case True{} False{}:
2640 delete_far_right_g(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
2641 case False{} True{}:
2642 delete_far_right_g(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
2643
2644def delete_children_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_red: Bool, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_children_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, pn, wn, near_red, far_red) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_children_right(~K, ~V, ~cmp, m, p, w, pn, wn, near_red, far_red)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2645 match near_red far_red:
2646 case False{} False{}:
2647 %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), w, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, True{})), set_red_s(~K, ~V, ~cmp, m, w, True{}, g_m)) : {(_, M.DF{p, M.node_parent(~K, pn), True{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_children_right(~K, ~V, ~cmp, m, p, w, pn, wn, False{}, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2648 {==}
2649 case True{} True{}:
2650 delete_far_right_s(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
2651 case True{} False{}:
2652 delete_far_right_s(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
2653 case False{} True{}:
2654 delete_far_right_s(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
2655
2656
2657def contains_value_start_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +wanted: V, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.contains_value_start(~K, ~V, ~cmp, ~eq, wanted, r)) == True{} : Bool}:
2658 match r:
2659 case Tuple{+m, +n}:
2660 contains_value_loop_g(~K, ~V, ~cmp, ~eq, 1n+n, wanted, False{}, MI.iterator_next(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m)), iterator_next_g(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m), iterator_g(~K, ~V, ~cmp, m, g_r)))
2661
2662def contains_value_start_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +wanted: V, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.contains_value_start(~K, ~V, ~cmp, ~eq, wanted, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_start(~K, ~V, ~cmp, ~eq, wanted, r)) : M.TreeMap<K, V, cmp> & Bool}:
2663 match r:
2664 case Tuple{+m, +n}:
2665 %Equal.sym(M.Cursor<K, V, cmp>, M.iterator(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rc(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m)), iterator_s(~K, ~V, ~cmp, m, g_r)) : {M.contains_value_loop(~K, ~V, ~cmp, ~eq, 1n+n, wanted, False{}, M.iterator_next(~K, ~V, ~cmp, _)) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_start(~K, ~V, ~cmp, ~eq, wanted, Tuple{m, n})) : M.TreeMap<K, V, cmp> & Bool}
2666 %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m))), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m))), iterator_next_s(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m), iterator_g(~K, ~V, ~cmp, m, g_r))) : {M.contains_value_loop(~K, ~V, ~cmp, ~eq, 1n+n, wanted, False{}, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_start(~K, ~V, ~cmp, ~eq, wanted, Tuple{m, n})) : M.TreeMap<K, V, cmp> & Bool}
2667 contains_value_loop_s(~K, ~V, ~cmp, ~eq, 1n+n, wanted, False{}, MI.iterator_next(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m)), iterator_next_g(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m), iterator_g(~K, ~V, ~cmp, m, g_r)))
2668
2669
2670def view_size_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Nat, MI.view_size(~K, ~V, ~cmp, view)) == True{} : Bool}:
2671 match view:
2672 case MI.MV{ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}, +lower, +upper, +descending}:
2673 view_count_loop_g(~K, ~V, ~cmp, 1n+n, 0n, MI.iterator_next(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})), iterator_next_g(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}), view_iterator_g(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view)))
2674
2675def view_size_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_size(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_size(~K, ~V, ~cmp, view)) : M.View<K, V, cmp> & Nat}:
2676 match view:
2677 case MI.MV{ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}, +lower, +upper, +descending}:
2678 %Equal.sym(M.Cursor<K, V, cmp>, M.view_iterator(~K, ~V, ~cmp, M.View{ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}), lower, upper, descending}), MI.rc(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})), view_iterator_s(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view)) : {M.view_count_loop(~K, ~V, ~cmp, 1n+n, 0n, M.iterator_next(~K, ~V, ~cmp, _)) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_size(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})) : M.View<K, V, cmp> & Nat}
2679 %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}))), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}))), iterator_next_s(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}), view_iterator_g(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view))) : {M.view_count_loop(~K, ~V, ~cmp, 1n+n, 0n, _) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_size(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})) : M.View<K, V, cmp> & Nat}
2680 view_count_loop_s(~K, ~V, ~cmp, 1n+n, 0n, MI.iterator_next(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})), iterator_next_g(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}), view_iterator_g(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view)))
2681
2682
2683def insert_grand_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +pn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_grand(~K, ~V, ~cmp, m, z, p, pn)) == True{} : Bool}:
2684 insert_grand_1_g(~K, ~V, ~cmp, z, p, pn, MI.read(~K, ~V, ~cmp, m, M.node_parent(~K, pn)), read_g(~K, ~V, ~cmp, m, M.node_parent(~K, pn), g_m))
2685
2686def insert_grand_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +pn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_grand(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, pn) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_grand(~K, ~V, ~cmp, m, z, p, pn)) : M.TreeMap<K, V, cmp> & M.Fix}:
2687 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_parent(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, M.node_parent(~K, pn))), read_s(~K, ~V, ~cmp, m, M.node_parent(~K, pn), g_m)) : {M.insert_grand_1(~K, ~V, ~cmp, z, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_grand(~K, ~V, ~cmp, m, z, p, pn)) : M.TreeMap<K, V, cmp> & M.Fix}
2688 insert_grand_1_s(~K, ~V, ~cmp, z, p, pn, MI.read(~K, ~V, ~cmp, m, M.node_parent(~K, pn)), read_g(~K, ~V, ~cmp, m, M.node_parent(~K, pn), g_m))
2689
2690
2691def delete_sibling_left_4_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_node: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_left_4(~K, ~V, ~cmp, p, pn, wn, near_node, pair_result)) == True{} : Bool}:
2692 match pair_result:
2693 case Tuple{+m4, +far_node}:
2694 delete_children_left_g(~K, ~V, ~cmp, m4, p, M.node_right(~K, pn), pn, wn, M.node_red(~K, near_node), M.node_red(~K, far_node), g_pair_result)
2695
2696def delete_sibling_left_4_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_node: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_left_4(~K, ~V, ~cmp, p, pn, wn, near_node, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_4(~K, ~V, ~cmp, p, pn, wn, near_node, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2697 match pair_result:
2698 case Tuple{+m4, +far_node}:
2699 delete_children_left_s(~K, ~V, ~cmp, m4, p, M.node_right(~K, pn), pn, wn, M.node_red(~K, near_node), M.node_red(~K, far_node), g_pair_result)
2700
2701
2702def delete_sibling_right_4_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_node: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_right_4(~K, ~V, ~cmp, p, pn, wn, near_node, pair_result)) == True{} : Bool}:
2703 match pair_result:
2704 case Tuple{+m4, +far_node}:
2705 delete_children_right_g(~K, ~V, ~cmp, m4, p, M.node_left(~K, pn), pn, wn, M.node_red(~K, near_node), M.node_red(~K, far_node), g_pair_result)
2706
2707def delete_sibling_right_4_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_node: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_right_4(~K, ~V, ~cmp, p, pn, wn, near_node, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_4(~K, ~V, ~cmp, p, pn, wn, near_node, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2708 match pair_result:
2709 case Tuple{+m4, +far_node}:
2710 delete_children_right_s(~K, ~V, ~cmp, m4, p, M.node_left(~K, pn), pn, wn, M.node_red(~K, near_node), M.node_red(~K, far_node), g_pair_result)
2711
2712
2713def contains_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh<K, V>, +wanted: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.contains_value(~K, ~V, ~cmp, ~eq, m, wanted)) == True{} : Bool}:
2714 contains_value_start_g(~K, ~V, ~cmp, ~eq, wanted, MI.size(~K, ~V, ~cmp, m), size_g(~K, ~V, ~cmp, m, g_m))
2715
2716def contains_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh<K, V>, +wanted: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.contains_value(~K, ~V, ~cmp, ~eq, ST.real(~K, ~V, ~cmp, m), wanted) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value(~K, ~V, ~cmp, ~eq, m, wanted)) : M.TreeMap<K, V, cmp> & Bool}:
2717 %Equal.sym(M.TreeMap<K, V, cmp> & 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.contains_value_start(~K, ~V, ~cmp, ~eq, wanted, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value(~K, ~V, ~cmp, ~eq, m, wanted)) : M.TreeMap<K, V, cmp> & Bool}
2718 contains_value_start_s(~K, ~V, ~cmp, ~eq, wanted, MI.size(~K, ~V, ~cmp, m), size_g(~K, ~V, ~cmp, m, g_m))
2719
2720
2721def insert_parent_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +pn: M.Node<K>, +is_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_parent(~K, ~V, ~cmp, m, z, p, pn, is_red)) == True{} : Bool}:
2722 match is_red:
2723 case False{}:
2724 g_m
2725 case True{}:
2726 insert_grand_g(~K, ~V, ~cmp, m, z, p, pn, g_m)
2727
2728def insert_parent_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +pn: M.Node<K>, +is_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_parent(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, pn, is_red) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_parent(~K, ~V, ~cmp, m, z, p, pn, is_red)) : M.TreeMap<K, V, cmp> & M.Fix}:
2729 match is_red:
2730 case False{}:
2731 {==}
2732 case True{}:
2733 insert_grand_s(~K, ~V, ~cmp, m, z, p, pn, g_m)
2734
2735
2736def delete_sibling_left_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_left_3(~K, ~V, ~cmp, p, pn, wn, pair_result)) == True{} : Bool}:
2737 match pair_result:
2738 case Tuple{+m3, +near_node}:
2739 delete_sibling_left_4_g(~K, ~V, ~cmp, p, pn, wn, near_node, MI.read(~K, ~V, ~cmp, m3, M.node_right(~K, wn)), read_g(~K, ~V, ~cmp, m3, M.node_right(~K, wn), g_pair_result))
2740
2741def delete_sibling_left_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_left_3(~K, ~V, ~cmp, p, pn, wn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_3(~K, ~V, ~cmp, p, pn, wn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2742 match pair_result:
2743 case Tuple{+m3, +near_node}:
2744 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m3), M.node_right(~K, wn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m3, M.node_right(~K, wn))), read_s(~K, ~V, ~cmp, m3, M.node_right(~K, wn), g_pair_result)) : {M.delete_sibling_left_4(~K, ~V, ~cmp, p, pn, wn, near_node, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_3(~K, ~V, ~cmp, p, pn, wn, Tuple{m3, near_node})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2745 delete_sibling_left_4_s(~K, ~V, ~cmp, p, pn, wn, near_node, MI.read(~K, ~V, ~cmp, m3, M.node_right(~K, wn)), read_g(~K, ~V, ~cmp, m3, M.node_right(~K, wn), g_pair_result))
2746
2747
2748def delete_sibling_right_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_right_3(~K, ~V, ~cmp, p, pn, wn, pair_result)) == True{} : Bool}:
2749 match pair_result:
2750 case Tuple{+m3, +near_node}:
2751 delete_sibling_right_4_g(~K, ~V, ~cmp, p, pn, wn, near_node, MI.read(~K, ~V, ~cmp, m3, M.node_left(~K, wn)), read_g(~K, ~V, ~cmp, m3, M.node_left(~K, wn), g_pair_result))
2752
2753def delete_sibling_right_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_right_3(~K, ~V, ~cmp, p, pn, wn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_3(~K, ~V, ~cmp, p, pn, wn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2754 match pair_result:
2755 case Tuple{+m3, +near_node}:
2756 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m3), M.node_left(~K, wn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m3, M.node_left(~K, wn))), read_s(~K, ~V, ~cmp, m3, M.node_left(~K, wn), g_pair_result)) : {M.delete_sibling_right_4(~K, ~V, ~cmp, p, pn, wn, near_node, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_3(~K, ~V, ~cmp, p, pn, wn, Tuple{m3, near_node})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2757 delete_sibling_right_4_s(~K, ~V, ~cmp, p, pn, wn, near_node, MI.read(~K, ~V, ~cmp, m3, M.node_left(~K, wn)), read_g(~K, ~V, ~cmp, m3, M.node_left(~K, wn), g_pair_result))
2758
2759
2760def insert_fix_step_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +zn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_fix_step_2(~K, ~V, ~cmp, z, zn, pair_result)) == True{} : Bool}:
2761 match pair_result:
2762 case Tuple{+m2, +pn}:
2763 insert_parent_g(~K, ~V, ~cmp, m2, z, M.node_parent(~K, zn), pn, M.node_red(~K, pn), g_pair_result)
2764
2765def insert_fix_step_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +zn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.insert_fix_step_2(~K, ~V, ~cmp, z, zn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_fix_step_2(~K, ~V, ~cmp, z, zn, pair_result)) : M.TreeMap<K, V, cmp> & M.Fix}:
2766 match pair_result:
2767 case Tuple{+m2, +pn}:
2768 insert_parent_s(~K, ~V, ~cmp, m2, z, M.node_parent(~K, zn), pn, M.node_red(~K, pn), g_pair_result)
2769
2770
2771def delete_sibling_left_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_left_2(~K, ~V, ~cmp, p, pn, pair_result)) == True{} : Bool}:
2772 match pair_result:
2773 case Tuple{+m2, +wn}:
2774 delete_sibling_left_3_g(~K, ~V, ~cmp, p, pn, wn, MI.read(~K, ~V, ~cmp, m2, M.node_left(~K, wn)), read_g(~K, ~V, ~cmp, m2, M.node_left(~K, wn), g_pair_result))
2775
2776def delete_sibling_left_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_left_2(~K, ~V, ~cmp, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_2(~K, ~V, ~cmp, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2777 match pair_result:
2778 case Tuple{+m2, +wn}:
2779 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), M.node_left(~K, wn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m2, M.node_left(~K, wn))), read_s(~K, ~V, ~cmp, m2, M.node_left(~K, wn), g_pair_result)) : {M.delete_sibling_left_3(~K, ~V, ~cmp, p, pn, wn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_2(~K, ~V, ~cmp, p, pn, Tuple{m2, wn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2780 delete_sibling_left_3_s(~K, ~V, ~cmp, p, pn, wn, MI.read(~K, ~V, ~cmp, m2, M.node_left(~K, wn)), read_g(~K, ~V, ~cmp, m2, M.node_left(~K, wn), g_pair_result))
2781
2782
2783def delete_sibling_right_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_right_2(~K, ~V, ~cmp, p, pn, pair_result)) == True{} : Bool}:
2784 match pair_result:
2785 case Tuple{+m2, +wn}:
2786 delete_sibling_right_3_g(~K, ~V, ~cmp, p, pn, wn, MI.read(~K, ~V, ~cmp, m2, M.node_right(~K, wn)), read_g(~K, ~V, ~cmp, m2, M.node_right(~K, wn), g_pair_result))
2787
2788def delete_sibling_right_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_right_2(~K, ~V, ~cmp, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_2(~K, ~V, ~cmp, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2789 match pair_result:
2790 case Tuple{+m2, +wn}:
2791 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), M.node_right(~K, wn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m2, M.node_right(~K, wn))), read_s(~K, ~V, ~cmp, m2, M.node_right(~K, wn), g_pair_result)) : {M.delete_sibling_right_3(~K, ~V, ~cmp, p, pn, wn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_2(~K, ~V, ~cmp, p, pn, Tuple{m2, wn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2792 delete_sibling_right_3_s(~K, ~V, ~cmp, p, pn, wn, MI.read(~K, ~V, ~cmp, m2, M.node_right(~K, wn)), read_g(~K, ~V, ~cmp, m2, M.node_right(~K, wn), g_pair_result))
2793
2794
2795def insert_fix_step_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_fix_step_1(~K, ~V, ~cmp, z, pair_result)) == True{} : Bool}:
2796 match pair_result:
2797 case Tuple{+m1, +zn}:
2798 insert_fix_step_2_g(~K, ~V, ~cmp, z, zn, MI.read(~K, ~V, ~cmp, m1, M.node_parent(~K, zn)), read_g(~K, ~V, ~cmp, m1, M.node_parent(~K, zn), g_pair_result))
2799
2800def insert_fix_step_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.insert_fix_step_1(~K, ~V, ~cmp, z, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_fix_step_1(~K, ~V, ~cmp, z, pair_result)) : M.TreeMap<K, V, cmp> & M.Fix}:
2801 match pair_result:
2802 case Tuple{+m1, +zn}:
2803 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_parent(~K, zn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_parent(~K, zn))), read_s(~K, ~V, ~cmp, m1, M.node_parent(~K, zn), g_pair_result)) : {M.insert_fix_step_2(~K, ~V, ~cmp, z, zn, _) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_fix_step_1(~K, ~V, ~cmp, z, Tuple{m1, zn})) : M.TreeMap<K, V, cmp> & M.Fix}
2804 insert_fix_step_2_s(~K, ~V, ~cmp, z, zn, MI.read(~K, ~V, ~cmp, m1, M.node_parent(~K, zn)), read_g(~K, ~V, ~cmp, m1, M.node_parent(~K, zn), g_pair_result))
2805
2806
2807def delete_sibling_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_left_1(~K, ~V, ~cmp, p, pair_result)) == True{} : Bool}:
2808 match pair_result:
2809 case Tuple{+m1, +pn}:
2810 delete_sibling_left_2_g(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_right(~K, pn), g_pair_result))
2811
2812def delete_sibling_left_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_left_1(~K, ~V, ~cmp, p, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_1(~K, ~V, ~cmp, p, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2813 match pair_result:
2814 case Tuple{+m1, +pn}:
2815 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_right(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, pn))), read_s(~K, ~V, ~cmp, m1, M.node_right(~K, pn), g_pair_result)) : {M.delete_sibling_left_2(~K, ~V, ~cmp, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_1(~K, ~V, ~cmp, p, Tuple{m1, pn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2816 delete_sibling_left_2_s(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_right(~K, pn), g_pair_result))
2817
2818
2819def delete_sibling_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_right_1(~K, ~V, ~cmp, p, pair_result)) == True{} : Bool}:
2820 match pair_result:
2821 case Tuple{+m1, +pn}:
2822 delete_sibling_right_2_g(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_left(~K, pn), g_pair_result))
2823
2824def delete_sibling_right_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_right_1(~K, ~V, ~cmp, p, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_1(~K, ~V, ~cmp, p, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2825 match pair_result:
2826 case Tuple{+m1, +pn}:
2827 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_left(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, pn))), read_s(~K, ~V, ~cmp, m1, M.node_left(~K, pn), g_pair_result)) : {M.delete_sibling_right_2(~K, ~V, ~cmp, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_1(~K, ~V, ~cmp, p, Tuple{m1, pn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2828 delete_sibling_right_2_s(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_left(~K, pn), g_pair_result))
2829
2830
2831def insert_fix_step_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_fix_step(~K, ~V, ~cmp, m, z)) == True{} : Bool}:
2832 insert_fix_step_1_g(~K, ~V, ~cmp, z, MI.read(~K, ~V, ~cmp, m, z), read_g(~K, ~V, ~cmp, m, z, g_m))
2833
2834def insert_fix_step_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_fix_step(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_fix_step(~K, ~V, ~cmp, m, z)) : M.TreeMap<K, V, cmp> & M.Fix}:
2835 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, z)), read_s(~K, ~V, ~cmp, m, z, g_m)) : {M.insert_fix_step_1(~K, ~V, ~cmp, z, _) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_fix_step(~K, ~V, ~cmp, m, z)) : M.TreeMap<K, V, cmp> & M.Fix}
2836 insert_fix_step_1_s(~K, ~V, ~cmp, z, MI.read(~K, ~V, ~cmp, m, z), read_g(~K, ~V, ~cmp, m, z, g_m))
2837
2838
2839def delete_sibling_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_left(~K, ~V, ~cmp, m, p)) == True{} : Bool}:
2840 delete_sibling_left_1_g(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))
2841
2842def delete_sibling_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_sibling_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2843 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, p)), read_s(~K, ~V, ~cmp, m, p, g_m)) : {M.delete_sibling_left_1(~K, ~V, ~cmp, p, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2844 delete_sibling_left_1_s(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))
2845
2846
2847def delete_sibling_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_right(~K, ~V, ~cmp, m, p)) == True{} : Bool}:
2848 delete_sibling_right_1_g(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))
2849
2850def delete_sibling_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_sibling_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2851 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, p)), read_s(~K, ~V, ~cmp, m, p, g_m)) : {M.delete_sibling_right_1(~K, ~V, ~cmp, p, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2852 delete_sibling_right_1_s(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))
2853
2854
2855def insert_fix_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, st: ST.Sh<K, V> & M.Fix, +g_st: {MI.dgp(K, V, M.Fix, st) == True{} : Bool}) -> {MI.dg(K, V, MI.insert_fix_loop(~K, ~V, ~cmp, fuel, st)) == True{} : Bool}:
2856 match fuel st:
2857 case 0n Tuple{+px4, +px5}:
2858 black_root_g(~K, ~V, ~cmp, px4, g_st)
2859 case 1n+ +px3 Tuple{+px6, M.Fix{+px8, False{}}}:
2860 black_root_g(~K, ~V, ~cmp, px6, g_st)
2861 case 1n+ +px3 Tuple{+px6, M.Fix{+px8, True{}}}:
2862 insert_fix_loop_g(~K, ~V, ~cmp, px3, MI.insert_fix_step(~K, ~V, ~cmp, px6, px8), insert_fix_step_g(~K, ~V, ~cmp, px6, px8, g_st))
2863
2864def insert_fix_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, st: ST.Sh<K, V> & M.Fix, +g_st: {MI.dgp(K, V, M.Fix, st) == True{} : Bool}) -> {M.insert_fix_loop(~K, ~V, ~cmp, fuel, MI.rp(~K, ~V, ~cmp, M.Fix, st)) == ST.real(~K, ~V, ~cmp, MI.insert_fix_loop(~K, ~V, ~cmp, fuel, st)) : M.TreeMap<K, V, cmp>}:
2865 match fuel st:
2866 case 0n Tuple{+px4, +px5}:
2867 black_root_s(~K, ~V, ~cmp, px4, g_st)
2868 case 1n+ +px3 Tuple{+px6, M.Fix{+px8, False{}}}:
2869 black_root_s(~K, ~V, ~cmp, px6, g_st)
2870 case 1n+ +px3 Tuple{+px6, M.Fix{+px8, True{}}}:
2871 %Equal.sym(M.TreeMap<K, V, cmp> & M.Fix, M.insert_fix_step(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px6), px8), MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_fix_step(~K, ~V, ~cmp, px6, px8)), insert_fix_step_s(~K, ~V, ~cmp, px6, px8, g_st)) : {M.insert_fix_loop(~K, ~V, ~cmp, px3, _) == ST.real(~K, ~V, ~cmp, MI.insert_fix_loop(~K, ~V, ~cmp, 1n+ px3, Tuple{px6, M.Fix{px8, True{}}})) : M.TreeMap<K, V, cmp>}
2872 insert_fix_loop_s(~K, ~V, ~cmp, px3, MI.insert_fix_step(~K, ~V, ~cmp, px6, px8), insert_fix_step_g(~K, ~V, ~cmp, px6, px8, g_st))
2873
2874
2875def delete_red_sibling_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +red_sibling: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_red_sibling_left(~K, ~V, ~cmp, m, p, w, red_sibling)) == True{} : Bool}:
2876 match red_sibling:
2877 case True{}:
2878 delete_sibling_left_g(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p), p, rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m))))
2879 case False{}:
2880 delete_sibling_left_g(~K, ~V, ~cmp, m, p, g_m)
2881
2882def delete_red_sibling_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +red_sibling: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_red_sibling_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, red_sibling) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_left(~K, ~V, ~cmp, m, p, w, red_sibling)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2883 match red_sibling:
2884 case True{}:
2885 %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), w, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{})), set_red_s(~K, ~V, ~cmp, m, w, False{}, g_m)) : {M.delete_sibling_left(~K, ~V, ~cmp, M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, p, True{}), p), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_left(~K, ~V, ~cmp, m, p, w, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2886 %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{})), p, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m))) : {M.delete_sibling_left(~K, ~V, ~cmp, M.rotate_left(~K, ~V, ~cmp, _, p), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_left(~K, ~V, ~cmp, m, p, w, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2887 %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{})), p), ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p)), rotate_left_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m)))) : {M.delete_sibling_left(~K, ~V, ~cmp, _, p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_left(~K, ~V, ~cmp, m, p, w, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2888 delete_sibling_left_s(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p), p, rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m))))
2889 case False{}:
2890 delete_sibling_left_s(~K, ~V, ~cmp, m, p, g_m)
2891
2892
2893def delete_red_sibling_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +red_sibling: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_red_sibling_right(~K, ~V, ~cmp, m, p, w, red_sibling)) == True{} : Bool}:
2894 match red_sibling:
2895 case True{}:
2896 delete_sibling_right_g(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p), p, rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m))))
2897 case False{}:
2898 delete_sibling_right_g(~K, ~V, ~cmp, m, p, g_m)
2899
2900def delete_red_sibling_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +red_sibling: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_red_sibling_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, red_sibling) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_right(~K, ~V, ~cmp, m, p, w, red_sibling)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2901 match red_sibling:
2902 case True{}:
2903 %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), w, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{})), set_red_s(~K, ~V, ~cmp, m, w, False{}, g_m)) : {M.delete_sibling_right(~K, ~V, ~cmp, M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, p, True{}), p), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_right(~K, ~V, ~cmp, m, p, w, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2904 %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{})), p, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m))) : {M.delete_sibling_right(~K, ~V, ~cmp, M.rotate_right(~K, ~V, ~cmp, _, p), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_right(~K, ~V, ~cmp, m, p, w, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2905 %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{})), p), ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p)), rotate_right_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m)))) : {M.delete_sibling_right(~K, ~V, ~cmp, _, p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_right(~K, ~V, ~cmp, m, p, w, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2906 delete_sibling_right_s(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p), p, rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m))))
2907 case False{}:
2908 delete_sibling_right_s(~K, ~V, ~cmp, m, p, g_m)
2909
2910
2911def insert_fixed_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dg(K, V, MI.insert_fixed(~K, ~V, ~cmp, id, r)) == True{} : Bool}:
2912 match r:
2913 case Tuple{+m, +n}:
2914 insert_fix_loop_g(~K, ~V, ~cmp, 1n+n, (m, M.Fix{id, True{}}), g_r)
2915
2916def insert_fixed_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.insert_fixed(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, Nat, r)) == ST.real(~K, ~V, ~cmp, MI.insert_fixed(~K, ~V, ~cmp, id, r)) : M.TreeMap<K, V, cmp>}:
2917 match r:
2918 case Tuple{+m, +n}:
2919 insert_fix_loop_s(~K, ~V, ~cmp, 1n+n, (m, M.Fix{id, True{}}), g_r)
2920
2921
2922def delete_side_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_side_left_1(~K, ~V, ~cmp, p, pn, pair_result)) == True{} : Bool}:
2923 match pair_result:
2924 case Tuple{+m1, +wn}:
2925 delete_red_sibling_left_g(~K, ~V, ~cmp, m1, p, M.node_right(~K, pn), M.node_red(~K, wn), g_pair_result)
2926
2927def delete_side_left_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_side_left_1(~K, ~V, ~cmp, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side_left_1(~K, ~V, ~cmp, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2928 match pair_result:
2929 case Tuple{+m1, +wn}:
2930 delete_red_sibling_left_s(~K, ~V, ~cmp, m1, p, M.node_right(~K, pn), M.node_red(~K, wn), g_pair_result)
2931
2932
2933def delete_side_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_side_right_1(~K, ~V, ~cmp, p, pn, pair_result)) == True{} : Bool}:
2934 match pair_result:
2935 case Tuple{+m1, +wn}:
2936 delete_red_sibling_right_g(~K, ~V, ~cmp, m1, p, M.node_left(~K, pn), M.node_red(~K, wn), g_pair_result)
2937
2938def delete_side_right_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_side_right_1(~K, ~V, ~cmp, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side_right_1(~K, ~V, ~cmp, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2939 match pair_result:
2940 case Tuple{+m1, +wn}:
2941 delete_red_sibling_right_s(~K, ~V, ~cmp, m1, p, M.node_left(~K, pn), M.node_red(~K, wn), g_pair_result)
2942
2943
2944def put_allocated_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +on_left: Bool, r: ST.Sh<K, V> & Result<&2, &2, M.Rejected<K, V>, Nat>, +g_r: {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Nat>, r) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_allocated(~K, ~V, ~cmp, p, on_left, r)) == True{} : Bool}:
2945 match r:
2946 case Tuple{+px2, Done{+px4}}:
2947 insert_fixed_g(~K, ~V, ~cmp, px4, MI.size(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left)), size_g(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left), insert_header_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left, attach_g(~K, ~V, ~cmp, px2, p, px4, on_left, g_r))))
2948 case Tuple{+px2, Fail{+px5}}:
2949 g_r
2950
2951def put_allocated_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +on_left: Bool, r: ST.Sh<K, V> & Result<&2, &2, M.Rejected<K, V>, Nat>, +g_r: {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Nat>, r) == True{} : Bool}) -> {M.put_allocated(~K, ~V, ~cmp, p, on_left, MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, r)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_allocated(~K, ~V, ~cmp, p, on_left, r)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
2952 match r:
2953 case Tuple{+px2, Done{+px4}}:
2954 %Equal.sym(M.TreeMap<K, V, cmp>, M.attach(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), p, px4, on_left), ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left)), attach_s(~K, ~V, ~cmp, px2, p, px4, on_left, g_r)) : {(M.insert_fixed(~K, ~V, ~cmp, px4, M.size(~K, ~V, ~cmp, M.insert_header(~K, ~V, ~cmp, _, px4, p, on_left))), Done{None{}}) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_allocated(~K, ~V, ~cmp, p, on_left, Tuple{px2, Done{px4}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
2955 %Equal.sym(M.TreeMap<K, V, cmp>, M.insert_header(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left)), px4, p, on_left), ST.real(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left)), insert_header_s(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left, attach_g(~K, ~V, ~cmp, px2, p, px4, on_left, g_r))) : {(M.insert_fixed(~K, ~V, ~cmp, px4, M.size(~K, ~V, ~cmp, _)), Done{None{}}) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_allocated(~K, ~V, ~cmp, p, on_left, Tuple{px2, Done{px4}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
2956 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.size(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left))), MI.rp(~K, ~V, ~cmp, Nat, MI.size(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left))), size_s(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left), insert_header_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left, attach_g(~K, ~V, ~cmp, px2, p, px4, on_left, g_r)))) : {(M.insert_fixed(~K, ~V, ~cmp, px4, _), Done{None{}}) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_allocated(~K, ~V, ~cmp, p, on_left, Tuple{px2, Done{px4}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
2957 %Equal.sym(M.TreeMap<K, V, cmp>, M.insert_fixed(~K, ~V, ~cmp, px4, MI.rp(~K, ~V, ~cmp, Nat, MI.size(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left)))), ST.real(~K, ~V, ~cmp, MI.insert_fixed(~K, ~V, ~cmp, px4, MI.size(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left)))), insert_fixed_s(~K, ~V, ~cmp, px4, MI.size(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left)), size_g(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left), insert_header_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left, attach_g(~K, ~V, ~cmp, px2, p, px4, on_left, g_r))))) : {(_, Done{None{}}) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_allocated(~K, ~V, ~cmp, p, on_left, Tuple{px2, Done{px4}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
2958 {==}
2959 case Tuple{+px2, Fail{+px5}}:
2960 {==}
2961
2962
2963def delete_side_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +pn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_side_left(~K, ~V, ~cmp, m, p, pn)) == True{} : Bool}:
2964 delete_side_left_1_g(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m, M.node_right(~K, pn)), read_g(~K, ~V, ~cmp, m, M.node_right(~K, pn), g_m))
2965
2966def delete_side_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +pn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_side_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, pn) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side_left(~K, ~V, ~cmp, m, p, pn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2967 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_right(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, M.node_right(~K, pn))), read_s(~K, ~V, ~cmp, m, M.node_right(~K, pn), g_m)) : {M.delete_side_left_1(~K, ~V, ~cmp, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side_left(~K, ~V, ~cmp, m, p, pn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2968 delete_side_left_1_s(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m, M.node_right(~K, pn)), read_g(~K, ~V, ~cmp, m, M.node_right(~K, pn), g_m))
2969
2970
2971def delete_side_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +pn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_side_right(~K, ~V, ~cmp, m, p, pn)) == True{} : Bool}:
2972 delete_side_right_1_g(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m, M.node_left(~K, pn)), read_g(~K, ~V, ~cmp, m, M.node_left(~K, pn), g_m))
2973
2974def delete_side_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +pn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_side_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, pn) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side_right(~K, ~V, ~cmp, m, p, pn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
2975 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_left(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, M.node_left(~K, pn))), read_s(~K, ~V, ~cmp, m, M.node_left(~K, pn), g_m)) : {M.delete_side_right_1(~K, ~V, ~cmp, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side_right(~K, ~V, ~cmp, m, p, pn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
2976 delete_side_right_1_s(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m, M.node_left(~K, pn)), read_g(~K, ~V, ~cmp, m, M.node_left(~K, pn), g_m))
2977
2978
2979def put_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: K, +v: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_found(~K, ~V, ~cmp, k, v, r)) == True{} : Bool}:
2980 match r:
2981 case Tuple{+px2, M.Search{0n, +px5, +px6}}:
2982 put_allocated_g(~K, ~V, ~cmp, px5, px6, MI.allocate(~K, ~V, ~cmp, px2, px5, k, v), allocate_g(~K, ~V, ~cmp, px2, px5, k, v, g_r))
2983 case Tuple{+px2, M.Search{1n+ +px7, +px5, +px6}}:
2984 put_replaced_g(~K, ~V, ~cmp, MI.exchange(~K, ~V, ~cmp, px2, 1n+px7, Some{v}), exchange_g(~K, ~V, ~cmp, px2, 1n+px7, Some{v}, g_r))
2985
2986def put_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: K, +v: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.put_found(~K, ~V, ~cmp, k, v, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_found(~K, ~V, ~cmp, k, v, r)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
2987 match r:
2988 case Tuple{+px2, M.Search{0n, +px5, +px6}}:
2989 %Equal.sym(M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>, M.allocate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), px5, k, v), MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.allocate(~K, ~V, ~cmp, px2, px5, k, v)), allocate_s(~K, ~V, ~cmp, px2, px5, k, v, g_r)) : {M.put_allocated(~K, ~V, ~cmp, px5, px6, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_found(~K, ~V, ~cmp, k, v, Tuple{px2, M.Search{0n, px5, px6}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
2990 put_allocated_s(~K, ~V, ~cmp, px5, px6, MI.allocate(~K, ~V, ~cmp, px2, px5, k, v), allocate_g(~K, ~V, ~cmp, px2, px5, k, v, g_r))
2991 case Tuple{+px2, M.Search{1n+ +px7, +px5, +px6}}:
2992 %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), 1n+px7, Some{v}), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, px2, 1n+px7, Some{v})), exchange_s(~K, ~V, ~cmp, px2, 1n+px7, Some{v}, g_r)) : {M.put_replaced(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_found(~K, ~V, ~cmp, k, v, Tuple{px2, M.Search{1n+ px7, px5, px6}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
2993 put_replaced_s(~K, ~V, ~cmp, MI.exchange(~K, ~V, ~cmp, px2, 1n+px7, Some{v}), exchange_g(~K, ~V, ~cmp, px2, 1n+px7, Some{v}, g_r))
2994
2995
2996def delete_side_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +pn: M.Node<K>, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_side(~K, ~V, ~cmp, m, x, p, pn, on_left)) == True{} : Bool}:
2997 match on_left:
2998 case True{}:
2999 delete_side_left_g(~K, ~V, ~cmp, m, p, pn, g_m)
3000 case False{}:
3001 delete_side_right_g(~K, ~V, ~cmp, m, p, pn, g_m)
3002
3003def delete_side_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +pn: M.Node<K>, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_side(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x, p, pn, on_left) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side(~K, ~V, ~cmp, m, x, p, pn, on_left)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
3004 match on_left:
3005 case True{}:
3006 delete_side_left_s(~K, ~V, ~cmp, m, p, pn, g_m)
3007 case False{}:
3008 delete_side_right_s(~K, ~V, ~cmp, m, p, pn, g_m)
3009
3010
3011def put_absent_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: K, +v: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_absent_found(~K, ~V, ~cmp, k, v, r)) == True{} : Bool}:
3012 match r:
3013 case Tuple{+px2, M.Search{0n, +px5, +px6}}:
3014 put_allocated_g(~K, ~V, ~cmp, px5, px6, MI.allocate(~K, ~V, ~cmp, px2, px5, k, v), allocate_g(~K, ~V, ~cmp, px2, px5, k, v, g_r))
3015 case Tuple{+px2, M.Search{1n+ +px7, +px5, +px6}}:
3016 put_replaced_g(~K, ~V, ~cmp, MI.get_id(~K, ~V, ~cmp, px2, 1n+px7), get_id_g(~K, ~V, ~cmp, px2, 1n+px7, g_r))
3017
3018def put_absent_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: K, +v: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.put_absent_found(~K, ~V, ~cmp, k, v, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_absent_found(~K, ~V, ~cmp, k, v, r)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
3019 match r:
3020 case Tuple{+px2, M.Search{0n, +px5, +px6}}:
3021 %Equal.sym(M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>, M.allocate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), px5, k, v), MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.allocate(~K, ~V, ~cmp, px2, px5, k, v)), allocate_s(~K, ~V, ~cmp, px2, px5, k, v, g_r)) : {M.put_allocated(~K, ~V, ~cmp, px5, px6, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_absent_found(~K, ~V, ~cmp, k, v, Tuple{px2, M.Search{0n, px5, px6}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
3022 put_allocated_s(~K, ~V, ~cmp, px5, px6, MI.allocate(~K, ~V, ~cmp, px2, px5, k, v), allocate_g(~K, ~V, ~cmp, px2, px5, k, v, g_r))
3023 case Tuple{+px2, M.Search{1n+ +px7, +px5, +px6}}:
3024 %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.get_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), 1n+px7), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get_id(~K, ~V, ~cmp, px2, 1n+px7)), get_id_s(~K, ~V, ~cmp, px2, 1n+px7, g_r)) : {M.put_replaced(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_absent_found(~K, ~V, ~cmp, k, v, Tuple{px2, M.Search{1n+ px7, px5, px6}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
3025 put_replaced_s(~K, ~V, ~cmp, MI.get_id(~K, ~V, ~cmp, px2, 1n+px7), get_id_g(~K, ~V, ~cmp, px2, 1n+px7, g_r))
3026
3027
3028def put_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put(~K, ~V, ~cmp, m, k, v)) == True{} : Bool}:
3029 put_found_g(~K, ~V, ~cmp, k, v, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))
3030
3031def put_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.put(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, v) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put(~K, ~V, ~cmp, m, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
3032 %Equal.sym(M.TreeMap<K, V, cmp> & 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.put_found(~K, ~V, ~cmp, k, v, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put(~K, ~V, ~cmp, m, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
3033 put_found_s(~K, ~V, ~cmp, k, v, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))
3034
3035
3036def delete_stop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +pn: M.Node<K>, +stop: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_stop(~K, ~V, ~cmp, m, x, p, pn, stop)) == True{} : Bool}:
3037 match stop:
3038 case True{}:
3039 set_red_g(~K, ~V, ~cmp, m, x, False{}, g_m)
3040 case False{}:
3041 delete_side_g(~K, ~V, ~cmp, m, x, p, pn, Nat.is_eq(x, M.node_left(~K, pn)), g_m)
3042
3043def delete_stop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +pn: M.Node<K>, +stop: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_stop(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x, p, pn, stop) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_stop(~K, ~V, ~cmp, m, x, p, pn, stop)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
3044 match stop:
3045 case True{}:
3046 %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, x, False{})), set_red_s(~K, ~V, ~cmp, m, x, False{}, g_m)) : {(_, M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_stop(~K, ~V, ~cmp, m, x, p, pn, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
3047 {==}
3048 case False{}:
3049 delete_side_s(~K, ~V, ~cmp, m, x, p, pn, Nat.is_eq(x, M.node_left(~K, pn)), g_m)
3050
3051
3052def put_if_absent_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_if_absent(~K, ~V, ~cmp, m, k, v)) == True{} : Bool}:
3053 put_absent_found_g(~K, ~V, ~cmp, k, v, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))
3054
3055def put_if_absent_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.put_if_absent(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, v) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_if_absent(~K, ~V, ~cmp, m, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
3056 %Equal.sym(M.TreeMap<K, V, cmp> & 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.put_absent_found(~K, ~V, ~cmp, k, v, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_if_absent(~K, ~V, ~cmp, m, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
3057 put_absent_found_s(~K, ~V, ~cmp, k, v, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))
3058
3059
3060def delete_fix_step_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +root_node: Nat, +xn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_fix_step_3(~K, ~V, ~cmp, x, p, root_node, xn, pair_result)) == True{} : Bool}:
3061 match pair_result:
3062 case Tuple{+m3, +pn}:
3063 delete_stop_g(~K, ~V, ~cmp, m3, x, p, pn, Bool.or(Nat.is_eq(x, root_node), M.node_red(~K, xn)), g_pair_result)
3064
3065def delete_fix_step_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +root_node: Nat, +xn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_fix_step_3(~K, ~V, ~cmp, x, p, root_node, xn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step_3(~K, ~V, ~cmp, x, p, root_node, xn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
3066 match pair_result:
3067 case Tuple{+m3, +pn}:
3068 delete_stop_s(~K, ~V, ~cmp, m3, x, p, pn, Bool.or(Nat.is_eq(x, root_node), M.node_red(~K, xn)), g_pair_result)
3069
3070
3071def view_put_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgvp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put_checked(~K, ~V, ~cmp, m, k, v, lower, upper, descending, valid)) == True{} : Bool}:
3072 match valid:
3073 case True{}:
3074 view_put_finish_g(~K, ~V, ~cmp, lower, upper, descending, MI.put(~K, ~V, ~cmp, m, k, v), put_g(~K, ~V, ~cmp, m, k, v, g_m))
3075 case False{}:
3076 g_m
3077
3078def view_put_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.view_put_checked(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, v, lower, upper, descending, valid) == MI.rvp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put_checked(~K, ~V, ~cmp, m, k, v, lower, upper, descending, valid)) : M.View<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
3079 match valid:
3080 case True{}:
3081 %Equal.sym(M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, M.put(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, v), MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put(~K, ~V, ~cmp, m, k, v)), put_s(~K, ~V, ~cmp, m, k, v, g_m)) : {M.view_put_finish(~K, ~V, ~cmp, lower, upper, descending, _) == MI.rvp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put_checked(~K, ~V, ~cmp, m, k, v, lower, upper, descending, True{})) : M.View<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
3082 view_put_finish_s(~K, ~V, ~cmp, lower, upper, descending, MI.put(~K, ~V, ~cmp, m, k, v), put_g(~K, ~V, ~cmp, m, k, v, g_m))
3083 case False{}:
3084 {==}
3085
3086
3087def delete_fix_step_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +root_node: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_fix_step_2(~K, ~V, ~cmp, x, p, root_node, pair_result)) == True{} : Bool}:
3088 match pair_result:
3089 case Tuple{+m2, +xn}:
3090 delete_fix_step_3_g(~K, ~V, ~cmp, x, p, root_node, xn, MI.read(~K, ~V, ~cmp, m2, p), read_g(~K, ~V, ~cmp, m2, p, g_pair_result))
3091
3092def delete_fix_step_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +root_node: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_fix_step_2(~K, ~V, ~cmp, x, p, root_node, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step_2(~K, ~V, ~cmp, x, p, root_node, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
3093 match pair_result:
3094 case Tuple{+m2, +xn}:
3095 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), p), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m2, p)), read_s(~K, ~V, ~cmp, m2, p, g_pair_result)) : {M.delete_fix_step_3(~K, ~V, ~cmp, x, p, root_node, xn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step_2(~K, ~V, ~cmp, x, p, root_node, Tuple{m2, xn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
3096 delete_fix_step_3_s(~K, ~V, ~cmp, x, p, root_node, xn, MI.read(~K, ~V, ~cmp, m2, p), read_g(~K, ~V, ~cmp, m2, p, g_pair_result))
3097
3098
3099def view_put_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +v: V, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put(~K, ~V, ~cmp, view, k, v)) == True{} : Bool}:
3100 match view:
3101 case MI.MV{+m, +lower, +upper, +descending}:
3102 view_put_checked_g(~K, ~V, ~cmp, m, k, v, lower, upper, descending, M.in_range(~K, ~V, ~cmp, k, lower, upper), g_view)
3103
3104def view_put_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +v: V, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_put(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k, v) == MI.rvp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put(~K, ~V, ~cmp, view, k, v)) : M.View<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
3105 match view:
3106 case MI.MV{+m, +lower, +upper, +descending}:
3107 view_put_checked_s(~K, ~V, ~cmp, m, k, v, lower, upper, descending, M.in_range(~K, ~V, ~cmp, k, lower, upper), g_view)
3108
3109
3110def delete_fix_step_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_fix_step_1(~K, ~V, ~cmp, x, p, pair_result)) == True{} : Bool}:
3111 match pair_result:
3112 case Tuple{+m1, +root_node}:
3113 delete_fix_step_2_g(~K, ~V, ~cmp, x, p, root_node, MI.read(~K, ~V, ~cmp, m1, x), read_g(~K, ~V, ~cmp, m1, x, g_pair_result))
3114
3115def delete_fix_step_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {M.delete_fix_step_1(~K, ~V, ~cmp, x, p, MI.rp(~K, ~V, ~cmp, Nat, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step_1(~K, ~V, ~cmp, x, p, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
3116 match pair_result:
3117 case Tuple{+m1, +root_node}:
3118 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), x), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, x)), read_s(~K, ~V, ~cmp, m1, x, g_pair_result)) : {M.delete_fix_step_2(~K, ~V, ~cmp, x, p, root_node, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step_1(~K, ~V, ~cmp, x, p, Tuple{m1, root_node})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
3119 delete_fix_step_2_s(~K, ~V, ~cmp, x, p, root_node, MI.read(~K, ~V, ~cmp, m1, x), read_g(~K, ~V, ~cmp, m1, x, g_pair_result))
3120
3121
3122def delete_fix_step_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_fix_step(~K, ~V, ~cmp, m, x, p)) == True{} : Bool}:
3123 delete_fix_step_1_g(~K, ~V, ~cmp, x, p, MI.root_id(~K, ~V, ~cmp, m), root_id_g(~K, ~V, ~cmp, m, g_m))
3124
3125def delete_fix_step_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_fix_step(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x, p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step(~K, ~V, ~cmp, m, x, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
3126 %Equal.sym(M.TreeMap<K, V, cmp> & 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.delete_fix_step_1(~K, ~V, ~cmp, x, p, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step(~K, ~V, ~cmp, m, x, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
3127 delete_fix_step_1_s(~K, ~V, ~cmp, x, p, MI.root_id(~K, ~V, ~cmp, m), root_id_g(~K, ~V, ~cmp, m, g_m))
3128
3129
3130def delete_fix_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, st: ST.Sh<K, V> & M.DeleteFix, +g_st: {MI.dgp(K, V, M.DeleteFix, st) == True{} : Bool}) -> {MI.dg(K, V, MI.delete_fix_loop(~K, ~V, ~cmp, fuel, st)) == True{} : Bool}:
3131 match fuel st:
3132 case 0n Tuple{+px4, +px5}:
3133 black_root_g(~K, ~V, ~cmp, px4, g_st)
3134 case 1n+ +px3 Tuple{+px6, M.DF{+px8, +px9, False{}}}:
3135 black_root_g(~K, ~V, ~cmp, px6, g_st)
3136 case 1n+ +px3 Tuple{+px6, M.DF{+px8, +px9, True{}}}:
3137 delete_fix_loop_g(~K, ~V, ~cmp, px3, MI.delete_fix_step(~K, ~V, ~cmp, px6, px8, px9), delete_fix_step_g(~K, ~V, ~cmp, px6, px8, px9, g_st))
3138
3139def delete_fix_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, st: ST.Sh<K, V> & M.DeleteFix, +g_st: {MI.dgp(K, V, M.DeleteFix, st) == True{} : Bool}) -> {M.delete_fix_loop(~K, ~V, ~cmp, fuel, MI.rp(~K, ~V, ~cmp, M.DeleteFix, st)) == ST.real(~K, ~V, ~cmp, MI.delete_fix_loop(~K, ~V, ~cmp, fuel, st)) : M.TreeMap<K, V, cmp>}:
3140 match fuel st:
3141 case 0n Tuple{+px4, +px5}:
3142 black_root_s(~K, ~V, ~cmp, px4, g_st)
3143 case 1n+ +px3 Tuple{+px6, M.DF{+px8, +px9, False{}}}:
3144 black_root_s(~K, ~V, ~cmp, px6, g_st)
3145 case 1n+ +px3 Tuple{+px6, M.DF{+px8, +px9, True{}}}:
3146 %Equal.sym(M.TreeMap<K, V, cmp> & M.DeleteFix, M.delete_fix_step(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px6), px8, px9), MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step(~K, ~V, ~cmp, px6, px8, px9)), delete_fix_step_s(~K, ~V, ~cmp, px6, px8, px9, g_st)) : {M.delete_fix_loop(~K, ~V, ~cmp, px3, _) == ST.real(~K, ~V, ~cmp, MI.delete_fix_loop(~K, ~V, ~cmp, 1n+ px3, Tuple{px6, M.DF{px8, px9, True{}}})) : M.TreeMap<K, V, cmp>}
3147 delete_fix_loop_s(~K, ~V, ~cmp, px3, MI.delete_fix_step(~K, ~V, ~cmp, px6, px8, px9), delete_fix_step_g(~K, ~V, ~cmp, px6, px8, px9, g_st))
3148
3149
3150def delete_repair_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +was_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.delete_repair(~K, ~V, ~cmp, m, x, p, was_red)) == True{} : Bool}:
3151 match m:
3152 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
3153 delete_fix_loop_g(~K, ~V, ~cmp, 1n+n, (ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, M.DF{x, p, Bool.not(was_red)}), g_m)
3154
3155def delete_repair_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +was_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_repair(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x, p, was_red) == ST.real(~K, ~V, ~cmp, MI.delete_repair(~K, ~V, ~cmp, m, x, p, was_red)) : M.TreeMap<K, V, cmp>}:
3156 match m:
3157 case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
3158 delete_fix_loop_s(~K, ~V, ~cmp, 1n+n, (ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, M.DF{x, p, Bool.not(was_red)}), g_m)
3159
3160
3161def unlink_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +node: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.unlink_2(~K, ~V, ~cmp, id, node, pair_result)) == True{} : Bool}:
3162 match pair_result:
3163 case Tuple{+m2, +pn}:
3164 delete_repair_g(~K, ~V, ~cmp, MI.recycle(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), id), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), M.node_parent(~K, node), M.node_red(~K, node), recycle_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), id, attach_g(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn)), g_pair_result)))
3165
3166def unlink_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +node: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.unlink_2(~K, ~V, ~cmp, id, node, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.unlink_2(~K, ~V, ~cmp, id, node, pair_result)) : M.TreeMap<K, V, cmp>}:
3167 match pair_result:
3168 case Tuple{+m2, +pn}:
3169 %Equal.sym(M.TreeMap<K, V, cmp>, M.attach(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn)))), attach_s(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn)), g_pair_result)) : {M.delete_repair(~K, ~V, ~cmp, M.recycle(~K, ~V, ~cmp, _, id), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), M.node_parent(~K, node), M.node_red(~K, node)) == ST.real(~K, ~V, ~cmp, MI.unlink_2(~K, ~V, ~cmp, id, node, Tuple{m2, pn})) : M.TreeMap<K, V, cmp>}
3170 %Equal.sym(M.TreeMap<K, V, cmp>, M.recycle(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn)))), id), ST.real(~K, ~V, ~cmp, MI.recycle(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), id)), recycle_s(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), id, attach_g(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn)), g_pair_result))) : {M.delete_repair(~K, ~V, ~cmp, _, M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), M.node_parent(~K, node), M.node_red(~K, node)) == ST.real(~K, ~V, ~cmp, MI.unlink_2(~K, ~V, ~cmp, id, node, Tuple{m2, pn})) : M.TreeMap<K, V, cmp>}
3171 delete_repair_s(~K, ~V, ~cmp, MI.recycle(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), id), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), M.node_parent(~K, node), M.node_red(~K, node), recycle_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), id, attach_g(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn)), g_pair_result)))
3172
3173
3174def unlink_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.unlink_1(~K, ~V, ~cmp, id, pair_result)) == True{} : Bool}:
3175 match pair_result:
3176 case Tuple{+m1, +node}:
3177 unlink_2_g(~K, ~V, ~cmp, id, node, MI.read(~K, ~V, ~cmp, m1, M.node_parent(~K, node)), read_g(~K, ~V, ~cmp, m1, M.node_parent(~K, node), g_pair_result))
3178
3179def unlink_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.unlink_1(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.unlink_1(~K, ~V, ~cmp, id, pair_result)) : M.TreeMap<K, V, cmp>}:
3180 match pair_result:
3181 case Tuple{+m1, +node}:
3182 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_parent(~K, node)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_parent(~K, node))), read_s(~K, ~V, ~cmp, m1, M.node_parent(~K, node), g_pair_result)) : {M.unlink_2(~K, ~V, ~cmp, id, node, _) == ST.real(~K, ~V, ~cmp, MI.unlink_1(~K, ~V, ~cmp, id, Tuple{m1, node})) : M.TreeMap<K, V, cmp>}
3183 unlink_2_s(~K, ~V, ~cmp, id, node, MI.read(~K, ~V, ~cmp, m1, M.node_parent(~K, node)), read_g(~K, ~V, ~cmp, m1, M.node_parent(~K, node), g_pair_result))
3184
3185
3186def unlink_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.unlink(~K, ~V, ~cmp, m, id)) == True{} : Bool}:
3187 unlink_1_g(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))
3188
3189def unlink_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.unlink(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == ST.real(~K, ~V, ~cmp, MI.unlink(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp>}:
3190 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, id)), read_s(~K, ~V, ~cmp, m, id, g_m)) : {M.unlink_1(~K, ~V, ~cmp, id, _) == ST.real(~K, ~V, ~cmp, MI.unlink(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp>}
3191 unlink_1_s(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))
3192
3193
3194def unlink_target_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dg(K, V, MI.unlink_target(~K, ~V, ~cmp, r)) == True{} : Bool}:
3195 match r:
3196 case Tuple{+m, +id}:
3197 refresh_ends_g(~K, ~V, ~cmp, MI.unlink(~K, ~V, ~cmp, m, id), unlink_g(~K, ~V, ~cmp, m, id, g_r))
3198
3199def unlink_target_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.unlink_target(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, r)) == ST.real(~K, ~V, ~cmp, MI.unlink_target(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp>}:
3200 match r:
3201 case Tuple{+m, +id}:
3202 %Equal.sym(M.TreeMap<K, V, cmp>, M.unlink(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), ST.real(~K, ~V, ~cmp, MI.unlink(~K, ~V, ~cmp, m, id)), unlink_s(~K, ~V, ~cmp, m, id, g_r)) : {M.refresh_ends(~K, ~V, ~cmp, _) == ST.real(~K, ~V, ~cmp, MI.unlink_target(~K, ~V, ~cmp, Tuple{m, id})) : M.TreeMap<K, V, cmp>}
3203 refresh_ends_s(~K, ~V, ~cmp, MI.unlink(~K, ~V, ~cmp, m, id), unlink_g(~K, ~V, ~cmp, m, id, g_r))
3204
3205
3206def remove_present_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.remove_present_1(~K, ~V, ~cmp, id, pair_result)) == True{} : Bool}:
3207 match pair_result:
3208 case Tuple{+m1, +value}:
3209 unlink_target_g(~K, ~V, ~cmp, MI.delete_target(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id)), delete_target_g(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id), read_g(~K, ~V, ~cmp, m1, id, g_pair_result)))
3210
3211def remove_present_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {M.remove_present_1(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, pair_result)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_present_1(~K, ~V, ~cmp, id, pair_result)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
3212 match pair_result:
3213 case Tuple{+m1, +value}:
3214 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, id)), read_s(~K, ~V, ~cmp, m1, id, g_pair_result)) : {(M.unlink_target(~K, ~V, ~cmp, M.delete_target(~K, ~V, ~cmp, id, _)), value) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_present_1(~K, ~V, ~cmp, id, Tuple{m1, value})) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}
3215 %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.delete_target(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, id))), MI.rp(~K, ~V, ~cmp, Nat, MI.delete_target(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id))), delete_target_s(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id), read_g(~K, ~V, ~cmp, m1, id, g_pair_result))) : {(M.unlink_target(~K, ~V, ~cmp, _), value) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_present_1(~K, ~V, ~cmp, id, Tuple{m1, value})) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}
3216 %Equal.sym(M.TreeMap<K, V, cmp>, M.unlink_target(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, MI.delete_target(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id)))), ST.real(~K, ~V, ~cmp, MI.unlink_target(~K, ~V, ~cmp, MI.delete_target(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id)))), unlink_target_s(~K, ~V, ~cmp, MI.delete_target(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id)), delete_target_g(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id), read_g(~K, ~V, ~cmp, m1, id, g_pair_result)))) : {(_, value) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_present_1(~K, ~V, ~cmp, id, Tuple{m1, value})) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}
3217 {==}
3218
3219
3220def remove_present_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.remove_present(~K, ~V, ~cmp, m, id)) == True{} : Bool}:
3221 remove_present_1_g(~K, ~V, ~cmp, id, MI.exchange(~K, ~V, ~cmp, m, id, None{}), exchange_g(~K, ~V, ~cmp, m, id, None{}, g_m))
3222
3223def remove_present_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.remove_present(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_present(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
3224 %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, None{}), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, m, id, None{})), exchange_s(~K, ~V, ~cmp, m, id, None{}, g_m)) : {M.remove_present_1(~K, ~V, ~cmp, id, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_present(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}
3225 remove_present_1_s(~K, ~V, ~cmp, id, MI.exchange(~K, ~V, ~cmp, m, id, None{}), exchange_g(~K, ~V, ~cmp, m, id, None{}, g_m))
3226
3227
3228def remove_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.remove_id(~K, ~V, ~cmp, m, id)) == True{} : Bool}:
3229 match id:
3230 case 0n:
3231 g_m
3232 case 1n+ +px2:
3233 remove_present_g(~K, ~V, ~cmp, m, 1n+px2, g_m)
3234
3235def remove_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.remove_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_id(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
3236 match id:
3237 case 0n:
3238 {==}
3239 case 1n+ +px2:
3240 remove_present_s(~K, ~V, ~cmp, m, 1n+px2, g_m)
3241
3242
3243def remove_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.remove_found(~K, ~V, ~cmp, r)) == True{} : Bool}:
3244 match r:
3245 case Tuple{+m, M.Search{+id, +p, +on_left}}:
3246 remove_id_g(~K, ~V, ~cmp, m, id, g_r)
3247
3248def remove_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.remove_found(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_found(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
3249 match r:
3250 case Tuple{+m, M.Search{+id, +p, +on_left}}:
3251 remove_id_s(~K, ~V, ~cmp, m, id, g_r)
3252
3253
3254def remove_entry_id_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.remove_entry_id_1(~K, ~V, ~cmp, id, pair_result)) == True{} : Bool}:
3255 match pair_result:
3256 case Tuple{+m1, +node}:
3257 entry_value_g(~K, ~V, ~cmp, M.node_key(~K, node), MI.remove_id(~K, ~V, ~cmp, m1, id), remove_id_g(~K, ~V, ~cmp, m1, id, g_pair_result))
3258
3259def remove_entry_id_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.remove_entry_id_1(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.remove_entry_id_1(~K, ~V, ~cmp, id, pair_result)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
3260 match pair_result:
3261 case Tuple{+m1, +node}:
3262 %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.remove_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), id), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_id(~K, ~V, ~cmp, m1, id)), remove_id_s(~K, ~V, ~cmp, m1, id, g_pair_result)) : {M.entry_value(~K, ~V, ~cmp, M.node_key(~K, node), _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.remove_entry_id_1(~K, ~V, ~cmp, id, Tuple{m1, node})) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
3263 entry_value_s(~K, ~V, ~cmp, M.node_key(~K, node), MI.remove_id(~K, ~V, ~cmp, m1, id), remove_id_g(~K, ~V, ~cmp, m1, id, g_pair_result))
3264
3265
3266def iterator_delete_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_delete_1(~K, ~V, ~cmp, current, lower, upper, forward, pair_result)) == True{} : Bool}:
3267 match pair_result:
3268 case Tuple{+m1, +node}:
3269 iterator_reseek_g(~K, ~V, ~cmp, M.node_key(~K, node), lower, upper, forward, MI.remove_id(~K, ~V, ~cmp, m1, current), remove_id_g(~K, ~V, ~cmp, m1, current, g_pair_result))
3270
3271def iterator_delete_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.iterator_delete_1(~K, ~V, ~cmp, current, lower, upper, forward, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_delete_1(~K, ~V, ~cmp, current, lower, upper, forward, pair_result)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}:
3272 match pair_result:
3273 case Tuple{+m1, +node}:
3274 %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.remove_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), current), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_id(~K, ~V, ~cmp, m1, current)), remove_id_s(~K, ~V, ~cmp, m1, current, g_pair_result)) : {M.iterator_reseek(~K, ~V, ~cmp, M.node_key(~K, node), lower, upper, forward, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_delete_1(~K, ~V, ~cmp, current, lower, upper, forward, Tuple{m1, node})) : M.Cursor<K, V, cmp> & Maybe<&2, V>}
3275 iterator_reseek_s(~K, ~V, ~cmp, M.node_key(~K, node), lower, upper, forward, MI.remove_id(~K, ~V, ~cmp, m1, current), remove_id_g(~K, ~V, ~cmp, m1, current, g_pair_result))
3276
3277
3278def remove_if_apply_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +replacement: V, +equal: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.remove_if_apply(~K, ~V, ~cmp, m, id, replacement, equal)) == True{} : Bool}:
3279 match equal:
3280 case False{}:
3281 g_m
3282 case True{}:
3283 changed_value_g(~K, ~V, ~cmp, MI.remove_id(~K, ~V, ~cmp, m, id), remove_id_g(~K, ~V, ~cmp, m, id, g_m))
3284
3285def remove_if_apply_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +replacement: V, +equal: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.remove_if_apply(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, replacement, equal) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_apply(~K, ~V, ~cmp, m, id, replacement, equal)) : M.TreeMap<K, V, cmp> & Bool}:
3286 match equal:
3287 case False{}:
3288 {==}
3289 case True{}:
3290 %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.remove_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_id(~K, ~V, ~cmp, m, id)), remove_id_s(~K, ~V, ~cmp, m, id, g_m)) : {M.changed_value(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_apply(~K, ~V, ~cmp, m, id, replacement, True{})) : M.TreeMap<K, V, cmp> & Bool}
3291 changed_value_s(~K, ~V, ~cmp, MI.remove_id(~K, ~V, ~cmp, m, id), remove_id_g(~K, ~V, ~cmp, m, id, g_m))
3292
3293
3294def remove_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.remove(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
3295 remove_found_g(~K, ~V, ~cmp, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))
3296
3297def remove_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.remove(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
3298 %Equal.sym(M.TreeMap<K, V, cmp> & 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.remove_found(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}
3299 remove_found_s(~K, ~V, ~cmp, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))
3300
3301
3302def remove_entry_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.remove_entry_id(~K, ~V, ~cmp, m, id)) == True{} : Bool}:
3303 remove_entry_id_1_g(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))
3304
3305def remove_entry_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.remove_entry_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.remove_entry_id(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
3306 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, id)), read_s(~K, ~V, ~cmp, m, id, g_m)) : {M.remove_entry_id_1(~K, ~V, ~cmp, id, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.remove_entry_id(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
3307 remove_entry_id_1_s(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))
3308
3309
3310def iterator_delete_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +next: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_delete(~K, ~V, ~cmp, m, next, current, lower, upper, forward)) == True{} : Bool}:
3311 iterator_delete_1_g(~K, ~V, ~cmp, current, lower, upper, forward, MI.read(~K, ~V, ~cmp, m, next), read_g(~K, ~V, ~cmp, m, next, g_m))
3312
3313def iterator_delete_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +next: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.iterator_delete(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), next, current, lower, upper, forward) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_delete(~K, ~V, ~cmp, m, next, current, lower, upper, forward)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}:
3314 %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), next), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, next)), read_s(~K, ~V, ~cmp, m, next, g_m)) : {M.iterator_delete_1(~K, ~V, ~cmp, current, lower, upper, forward, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_delete(~K, ~V, ~cmp, m, next, current, lower, upper, forward)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}
3315 iterator_delete_1_s(~K, ~V, ~cmp, current, lower, upper, forward, MI.read(~K, ~V, ~cmp, m, next), read_g(~K, ~V, ~cmp, m, next, g_m))
3316
3317
3318def remove_if_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +id: Nat, +expected: V, +replacement: V, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.remove_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, r)) == True{} : Bool}:
3319 match r:
3320 case Tuple{+px2, None{}}:
3321 g_r
3322 case Tuple{+px2, Some{+px4}}:
3323 remove_if_apply_g(~K, ~V, ~cmp, px2, id, replacement, eq(px4, expected), g_r)
3324
3325def remove_if_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +id: Nat, +expected: V, +replacement: V, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.remove_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.remove_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, r)) : M.TreeMap<K, V, cmp> & Bool}:
3326 match r:
3327 case Tuple{+px2, None{}}:
3328 {==}
3329 case Tuple{+px2, Some{+px4}}:
3330 remove_if_apply_s(~K, ~V, ~cmp, px2, id, replacement, eq(px4, expected), g_r)
3331
3332
3333def poll_ready_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.poll_ready(~K, ~V, ~cmp, r)) == True{} : Bool}:
3334 match r:
3335 case Tuple{+m, +id}:
3336 remove_entry_id_g(~K, ~V, ~cmp, m, id, g_r)
3337
3338def poll_ready_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.poll_ready(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.poll_ready(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
3339 match r:
3340 case Tuple{+m, +id}:
3341 remove_entry_id_s(~K, ~V, ~cmp, m, id, g_r)
3342
3343
3344def view_remove_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, V>, MI.view_remove_checked(~K, ~V, ~cmp, m, k, lower, upper, descending, valid)) == True{} : Bool}:
3345 match valid:
3346 case True{}:
3347 view_value_g(~K, ~V, ~cmp, lower, upper, descending, MI.remove(~K, ~V, ~cmp, m, k), remove_g(~K, ~V, ~cmp, m, k, g_m))
3348 case False{}:
3349 g_m
3350
3351def view_remove_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.view_remove_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_remove_checked(~K, ~V, ~cmp, m, k, lower, upper, descending, valid)) : M.View<K, V, cmp> & Maybe<&2, V>}:
3352 match valid:
3353 case True{}:
3354 %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.remove(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove(~K, ~V, ~cmp, m, k)), remove_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_remove_checked(~K, ~V, ~cmp, m, k, lower, upper, descending, True{})) : M.View<K, V, cmp> & Maybe<&2, V>}
3355 view_value_s(~K, ~V, ~cmp, lower, upper, descending, MI.remove(~K, ~V, ~cmp, m, k), remove_g(~K, ~V, ~cmp, m, k, g_m))
3356 case False{}:
3357 {==}
3358
3359
3360def iterator_remove_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_remove(~K, ~V, ~cmp, cursor)) == True{} : Bool}:
3361 match cursor:
3362 case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
3363 iterator_delete_g(~K, ~V, ~cmp, m, next, current, lower, upper, forward, g_cursor)
3364
3365def iterator_remove_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_remove(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_remove(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}:
3366 match cursor:
3367 case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
3368 iterator_delete_s(~K, ~V, ~cmp, m, next, current, lower, upper, forward, g_cursor)
3369
3370
3371def remove_if_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +expected: V, +replacement: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.remove_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, r)) == True{} : Bool}:
3372 match r:
3373 case Tuple{+m, M.Search{+id, +p, +on_left}}:
3374 remove_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))
3375
3376def remove_if_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +expected: V, +replacement: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.remove_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, r)) : M.TreeMap<K, V, cmp> & Bool}:
3377 match r:
3378 case Tuple{+m, M.Search{+id, +p, +on_left}}:
3379 %Equal.sym(M.TreeMap<K, V, cmp> & 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.remove_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, Tuple{m, M.Search{id, p, on_left}})) : M.TreeMap<K, V, cmp> & Bool}
3380 remove_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))
3381
3382
3383def poll_first_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.poll_first_entry(~K, ~V, ~cmp, m)) == True{} : Bool}:
3384 poll_ready_g(~K, ~V, ~cmp, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m))
3385
3386def poll_first_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.poll_first_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.poll_first_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
3387 %Equal.sym(M.TreeMap<K, V, cmp> & 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.poll_ready(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.poll_first_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
3388 poll_ready_s(~K, ~V, ~cmp, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m))
3389
3390
3391def poll_last_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.poll_last_entry(~K, ~V, ~cmp, m)) == True{} : Bool}:
3392 poll_ready_g(~K, ~V, ~cmp, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m))
3393
3394def poll_last_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.poll_last_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.poll_last_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
3395 %Equal.sym(M.TreeMap<K, V, cmp> & 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.poll_ready(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.poll_last_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
3396 poll_ready_s(~K, ~V, ~cmp, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m))
3397
3398
3399def view_remove_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, V>, MI.view_remove(~K, ~V, ~cmp, view, k)) == True{} : Bool}:
3400 match view:
3401 case MI.MV{+m, +lower, +upper, +descending}:
3402 view_remove_checked_g(~K, ~V, ~cmp, m, k, lower, upper, descending, M.in_range(~K, ~V, ~cmp, k, lower, upper), g_view)
3403
3404def view_remove_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_remove(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_remove(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Maybe<&2, V>}:
3405 match view:
3406 case MI.MV{+m, +lower, +upper, +descending}:
3407 view_remove_checked_s(~K, ~V, ~cmp, m, k, lower, upper, descending, M.in_range(~K, ~V, ~cmp, k, lower, upper), g_view)
3408
3409
3410def remove_if_equal_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh<K, V>, +k: K, +expected: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.remove_if_equal(~K, ~V, ~cmp, ~eq, m, k, expected)) == True{} : Bool}:
3411 remove_if_found_g(~K, ~V, ~cmp, ~eq, expected, expected, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))
3412
3413def remove_if_equal_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh<K, V>, +k: K, +expected: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.remove_if_equal(~K, ~V, ~cmp, ~eq, ST.real(~K, ~V, ~cmp, m), k, expected) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_equal(~K, ~V, ~cmp, ~eq, m, k, expected)) : M.TreeMap<K, V, cmp> & Bool}:
3414 %Equal.sym(M.TreeMap<K, V, cmp> & 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.remove_if_found(~K, ~V, ~cmp, ~eq, expected, expected, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_equal(~K, ~V, ~cmp, ~eq, m, k, expected)) : M.TreeMap<K, V, cmp> & Bool}
3415 remove_if_found_s(~K, ~V, ~cmp, ~eq, expected, expected, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))
3416
3417
3418def view_clear_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, st: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_st: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, st) == True{} : Bool}) -> {MI.dgv(K, V, MI.view_clear_loop(~K, ~V, ~cmp, fuel, st)) == True{} : Bool}:
3419 match fuel st:
3420 case 0n Tuple{+px4, None{}}:
3421 iterator_view_g(~K, ~V, ~cmp, px4, g_st)
3422 case 0n Tuple{+px4, Some{+px6}}:
3423 iterator_view_g(~K, ~V, ~cmp, px4, g_st)
3424 case 1n+ +px3 Tuple{+px7, None{}}:
3425 iterator_view_g(~K, ~V, ~cmp, px7, g_st)
3426 case 1n+ +px3 Tuple{+px7, Some{+px9}}:
3427 view_clear_loop_g(~K, ~V, ~cmp, px3, MI.view_clear_next(~K, ~V, ~cmp, MI.iterator_remove(~K, ~V, ~cmp, px7)), view_clear_next_g(~K, ~V, ~cmp, MI.iterator_remove(~K, ~V, ~cmp, px7), iterator_remove_g(~K, ~V, ~cmp, px7, g_st)))
3428
3429def view_clear_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, st: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_st: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, st) == True{} : Bool}) -> {M.view_clear_loop(~K, ~V, ~cmp, fuel, MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, st)) == MI.rv(~K, ~V, ~cmp, MI.view_clear_loop(~K, ~V, ~cmp, fuel, st)) : M.View<K, V, cmp>}:
3430 match fuel st:
3431 case 0n Tuple{+px4, None{}}:
3432 iterator_view_s(~K, ~V, ~cmp, px4, g_st)
3433 case 0n Tuple{+px4, Some{+px6}}:
3434 iterator_view_s(~K, ~V, ~cmp, px4, g_st)
3435 case 1n+ +px3 Tuple{+px7, None{}}:
3436 iterator_view_s(~K, ~V, ~cmp, px7, g_st)
3437 case 1n+ +px3 Tuple{+px7, Some{+px9}}:
3438 %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, V>, M.iterator_remove(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px7)), MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_remove(~K, ~V, ~cmp, px7)), iterator_remove_s(~K, ~V, ~cmp, px7, g_st)) : {M.view_clear_loop(~K, ~V, ~cmp, px3, M.view_clear_next(~K, ~V, ~cmp, _)) == MI.rv(~K, ~V, ~cmp, MI.view_clear_loop(~K, ~V, ~cmp, 1n+ px3, Tuple{px7, Some{px9}})) : M.View<K, V, cmp>}
3439 %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.view_clear_next(~K, ~V, ~cmp, MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_remove(~K, ~V, ~cmp, px7))), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_clear_next(~K, ~V, ~cmp, MI.iterator_remove(~K, ~V, ~cmp, px7))), view_clear_next_s(~K, ~V, ~cmp, MI.iterator_remove(~K, ~V, ~cmp, px7), iterator_remove_g(~K, ~V, ~cmp, px7, g_st))) : {M.view_clear_loop(~K, ~V, ~cmp, px3, _) == MI.rv(~K, ~V, ~cmp, MI.view_clear_loop(~K, ~V, ~cmp, 1n+ px3, Tuple{px7, Some{px9}})) : M.View<K, V, cmp>}
3440 view_clear_loop_s(~K, ~V, ~cmp, px3, MI.view_clear_next(~K, ~V, ~cmp, MI.iterator_remove(~K, ~V, ~cmp, px7)), view_clear_next_g(~K, ~V, ~cmp, MI.iterator_remove(~K, ~V, ~cmp, px7), iterator_remove_g(~K, ~V, ~cmp, px7, g_st)))
3441
3442
3443def view_clear_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgv(K, V, MI.view_clear(~K, ~V, ~cmp, view)) == True{} : Bool}:
3444 match view:
3445 case MI.MV{ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}, +lower, +upper, +descending}:
3446 view_clear_loop_g(~K, ~V, ~cmp, 1n+n, MI.iterator_next(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})), iterator_next_g(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}), view_iterator_g(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view)))
3447
3448def view_clear_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_clear(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == MI.rv(~K, ~V, ~cmp, MI.view_clear(~K, ~V, ~cmp, view)) : M.View<K, V, cmp>}:
3449 match view:
3450 case MI.MV{ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}, +lower, +upper, +descending}:
3451 %Equal.sym(M.Cursor<K, V, cmp>, M.view_iterator(~K, ~V, ~cmp, M.View{ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}), lower, upper, descending}), MI.rc(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})), view_iterator_s(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view)) : {M.view_clear_loop(~K, ~V, ~cmp, 1n+n, M.iterator_next(~K, ~V, ~cmp, _)) == MI.rv(~K, ~V, ~cmp, MI.view_clear(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})) : M.View<K, V, cmp>}
3452 %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}))), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}))), iterator_next_s(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}), view_iterator_g(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view))) : {M.view_clear_loop(~K, ~V, ~cmp, 1n+n, _) == MI.rv(~K, ~V, ~cmp, MI.view_clear(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})) : M.View<K, V, cmp>}
3453 view_clear_loop_s(~K, ~V, ~cmp, 1n+n, MI.iterator_next(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})), iterator_next_g(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}), view_iterator_g(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view)))
3454