import Base import ../../lib/logic.bend as L import ../../lib/nat.bend as N import ../../lib/order.bend as O import ../../../spec/lib/common.bend as SC import ../../../src/containers/balanced_search_tree.bend as M import ./state.bend as ST import ./mirror.bend as MI import ./tree.bend as TR import ./ends.bend as EN import ./path.bend as P import ./plug.bend as PG import ./setters.bend as SE import ./rotm.bend as RM import ./rotn.bend as RN import ./rot.bend as RT import ./rotp.bend as RP import ./nbr.bend as NB import ./dj.bend as DJ import ./spath.bend as SP import ../../lib/nat_list.bend as NL # The insertion fix-up: from a red node z the path leads to, the loop # recolours and rotates; whatever it does and however far its fuel goes, it # ends with a black root over a linked tree of the same ids, entries and free # chain. (source: tools/generators/tm_hand/fix.src) # ---- the end: the root blackened ---- def rb_set(~K: Data, +nl: List<&2, M.Node>, +t: ST.Tr, +r: Nat, +hr: {r == ST.rid(t) : Nat}) -> {ST.root_black(~K, t, SE.setc(K, nl, r, False{})) == True{} : Bool}: match t: case ST.TE{}: {==} case ST.TN{+i, +a, +b}: %Equal.sym(Nat, r, i, hr) : {Bool.not(ST.is_red(K, ST.nd(K, SE.setc(K, nl, _, False{}), i))) == True{} : Bool} %Equal.sym(M.Node, ST.nd(K, SE.setc(K, nl, i, False{}), i), SE.modc(K, ST.nd(K, nl, i), False{}), RN.hitc(K, nl, i, False{})) : {Bool.not(ST.is_red(K, _)) == True{} : Bool} %Equal.sym(Bool, ST.is_red(K, SE.modc(K, ST.nd(K, nl, i), False{})), False{}, SE.red_modc(K, ST.nd(K, nl, i), False{}, {==})) : {Bool.not(_) == True{} : Bool} {==} def inv_setc(~K: Data, ~V: Data, +pl: List<&2, Maybe<&2, V>>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +nl: List<&2, M.Node>, +id: Nat, +v: Bool, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}) -> {ST.ents(~K, ~V, i0, SE.setc(K, nl, id, v), pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, SE.setc(K, nl, id, v), pl) == True{} : Bool} & ({ST.fll(~K, SE.setc(K, nl, id, v), fx) == True{} : Bool} & {SC.length(M.Node, SE.setc(K, nl, id, v)) == l0 : Nat})): (Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, SE.setc(K, nl, id, v), pl), ST.ents(~K, ~V, i0, nl, pl), e0, SE.ents_setc(~K, ~V, i0, nl, pl, id, v), h4), (Equal.trans(Bool, EN.oks(~K, ~V, i0, SE.setc(K, nl, id, v), pl), EN.oks(~K, ~V, i0, nl, pl), True{}, SE.oks_setc(~K, ~V, i0, nl, pl, id, v), h5), (Equal.trans(Bool, ST.fll(~K, SE.setc(K, nl, id, v), fx), ST.fll(~K, nl, fx), True{}, SE.fll_setc(~K, fx, nl, id, v), h6), Equal.trans(Nat, SC.length(M.Node, SE.setc(K, nl, id, v)), SC.length(M.Node, nl), l0, SE.setc_len(K, nl, id, v), h7)))) # a linked tree of the ids: blackening the root finishes def fin(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +root: Nat, +nl: List<&2, M.Node>, +t: ST.Tr, +h1: {ST.rep(~K, t, 0n, nl) == True{} : Bool}, +h2: {root == ST.rid(t) : Nat}, +h3: {ST.ids(t) == i0 : List<&2, Nat>}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.black_root(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: %Equal.sym(ST.Sh, MI.black_root(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}), ST.SH{n, root, lo, hi, free, l, d, SE.setc(K, nl, root, False{}), pl, tg, fl}, SE.set_red_m(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, tg, fl, root, False{})) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {_ == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> (root, (SE.setc(K, nl, root, False{}), (t, ({==}, (Equal.trans(Bool, ST.rep(~K, t, 0n, SE.setc(K, nl, root, False{})), ST.rep(~K, t, 0n, nl), True{}, SE.rep_setc(~K, t, 0n, nl, root, False{}), h1), (h2, (h3, (rb_set(~K, nl, t, root, h2), inv_setc(~K, ~V, pl, fx, i0, e0, l0, nl, root, False{}, h4, h5, h6, h7))))))))) # the loop after a step that stops def stop(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +f: Nat, +root: Nat, +nl: List<&2, M.Node>, +t: ST.Tr, +h1: {ST.rep(~K, t, 0n, nl) == True{} : Bool}, +h2: {root == ST.rid(t) : Nat}, +h3: {ST.ids(t) == i0 : List<&2, Nat>}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, f, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: match f: case 0n: fin(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, root, nl, t, h1, h2, h3, h4, h5, h6, h7) case 1n+g: fin(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, root, nl, t, h1, h2, h3, h4, h5, h6, h7) # ---- from the path invariant ---- def isnil(c: List<&2, P.Fr>) -> Bool: match c: case Nil{}: True{} case Con{f, u}: False{} # a subtree under its parent, the parent's frame: the parent's subtree def up_t(~K: Data, +nl: List<&2, M.Node>, +p: Nat, +s: ST.Tr, +t: ST.Tr, +q: Nat, +hr: {ST.rep(~K, t, p, nl) == True{} : Bool}, +hk: {P.cok1(~K, P.FR{p, True{}, s}, ST.rid(t), q, nl) == True{} : Bool}) -> {ST.rep(~K, ST.TN{p, t, s}, q, nl) == True{} : Bool}: +h0 = L.and_left(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.rid(t), ST.rid(s), q), ST.rep(~K, s, p, nl)), hk) +h12 = L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.rid(t), ST.rid(s), q), ST.rep(~K, s, p, nl)), hk) RT.rep_intro(~K, nl, p, t, s, q, h0, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.rid(t), ST.rid(s), q), ST.rep(~K, s, p, nl), h12), hr, L.and_right(ST.is_node(K, ST.nd(K, nl, p), ST.rid(t), ST.rid(s), q), ST.rep(~K, s, p, nl), h12)) def up_f(~K: Data, +nl: List<&2, M.Node>, +p: Nat, +s: ST.Tr, +t: ST.Tr, +q: Nat, +hr: {ST.rep(~K, t, p, nl) == True{} : Bool}, +hk: {P.cok1(~K, P.FR{p, False{}, s}, ST.rid(t), q, nl) == True{} : Bool}) -> {ST.rep(~K, ST.TN{p, s, t}, q, nl) == True{} : Bool}: +h0 = L.and_left(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.rid(s), ST.rid(t), q), ST.rep(~K, s, p, nl)), hk) +h12 = L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.rid(s), ST.rid(t), q), ST.rep(~K, s, p, nl)), hk) RT.rep_intro(~K, nl, p, s, t, q, h0, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.rid(s), ST.rid(t), q), ST.rep(~K, s, p, nl), h12), L.and_right(ST.is_node(K, ST.nd(K, nl, p), ST.rid(s), ST.rid(t), q), ST.rep(~K, s, p, nl), h12), hr) # the path invariant gives the whole tree def fi_stop(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +f: Nat, +root: Nat, +nl: List<&2, M.Node>, +c: List<&2, P.Fr>, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, P.top(c), nl) == True{} : Bool}, +i2: {P.ctxok(~K, c, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(c)))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(c))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(c, ST.TN{z, zl, zr})) : Nat}, +i6: {Bool.or(ST.root_black(~K, PG.plug(c, ST.TN{z, zl, zr}), nl), isnil(c)) == True{} : Bool}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, f, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: stop(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, f, root, nl, PG.plug(c, ST.TN{z, zl, zr}), PG.rep_plug(~K, nl, c, ST.TN{z, zl, zr}, i1, i2), i5, Equal.trans(List<&2, Nat>, ST.ids(PG.plug(c, ST.TN{z, zl, zr})), SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(c))), i0, PG.ids_plug(c, ST.TN{z, zl, zr}), i4), h4, h5, h6, h7) def rb_rid(~K: Data, +t: ST.Tr, +x: List<&2, M.Node>) -> {ST.root_black(~K, t, x) == Bool.not(ST.is_red(K, ST.nd(K, x, ST.rid(t)))) : Bool}: match t: case ST.TE{}: {==} case ST.TN{+i, a, b}: {==} def red_eq(-K: Data, +x: M.Node) -> {M.node_red(~K, x) == ST.is_red(K, x) : Bool}: match x: case M.Free{f}: {==} case M.N{c, a, b, q, k}: {==} # ---- the root is on the path, away from the subtree ---- # a member of the frames above is a member of the frames def ba_up_c(+w: Nat, +q: Nat, +lft: Bool, +s: ST.Tr, +u: List<&2, P.Fr>, +b: Bool, +hb: {NL.memn(w, P.before(u)) == b : Bool}, +h: {NL.memn(w, SC.append(Nat, P.before(u), P.after(u))) == True{} : Bool}) -> {NL.memn(w, SC.append(Nat, P.before(Con{P.FR{q, lft, s}, u}), P.after(Con{P.FR{q, lft, s}, u}))) == True{} : Bool}: match lft b: case True{} True{}: DJ.mem_l(w, P.before(u), Con{q, SC.append(Nat, ST.ids(s), P.after(u))}, hb) case False{} True{}: DJ.mem_l(w, SC.append(Nat, P.before(u), SC.append(Nat, ST.ids(s), Con{q, Nil{}})), P.after(u), DJ.mem_l(w, P.before(u), SC.append(Nat, ST.ids(s), Con{q, Nil{}}), hb)) case True{} False{}: +ha = L.subst(Bool, z => {Bool.or(z, NL.memn(w, P.after(u))) == True{} : Bool}, NL.memn(w, P.before(u)), False{}, hb, L.subst(Bool, z => {z == True{} : Bool}, NL.memn(w, SC.append(Nat, P.before(u), P.after(u))), Bool.or(NL.memn(w, P.before(u)), NL.memn(w, P.after(u))), NL.memn_app(w, P.before(u), P.after(u)), h)) DJ.mem_r(w, P.before(u), Con{q, SC.append(Nat, ST.ids(s), P.after(u))}, DJ.mem_tl(w, q, SC.append(Nat, ST.ids(s), P.after(u)), DJ.mem_r(w, ST.ids(s), P.after(u), ha))) case False{} False{}: +ha = L.subst(Bool, z => {Bool.or(z, NL.memn(w, P.after(u))) == True{} : Bool}, NL.memn(w, P.before(u)), False{}, hb, L.subst(Bool, z => {z == True{} : Bool}, NL.memn(w, SC.append(Nat, P.before(u), P.after(u))), Bool.or(NL.memn(w, P.before(u)), NL.memn(w, P.after(u))), NL.memn_app(w, P.before(u), P.after(u)), h)) DJ.mem_r(w, SC.append(Nat, P.before(u), SC.append(Nat, ST.ids(s), Con{q, Nil{}})), P.after(u), ha) def q_in(+q: Nat, +lft: Bool, +s: ST.Tr, +u: List<&2, P.Fr>) -> {NL.memn(q, SC.append(Nat, P.before(Con{P.FR{q, lft, s}, u}), P.after(Con{P.FR{q, lft, s}, u}))) == True{} : Bool}: match lft: case True{}: DJ.mem_r(q, P.before(u), Con{q, SC.append(Nat, ST.ids(s), P.after(u))}, DJ.mem_hd(q, SC.append(Nat, ST.ids(s), P.after(u)))) case False{}: DJ.mem_l(q, SC.append(Nat, P.before(u), SC.append(Nat, ST.ids(s), Con{q, Nil{}})), P.after(u), DJ.mem_r(q, P.before(u), SC.append(Nat, ST.ids(s), Con{q, Nil{}}), DJ.mem_r(q, ST.ids(s), Con{q, Nil{}}, DJ.mem_hd(q, Nil{})))) # a nonempty path's plugged root is one of its frames' parents def rid_in(+u: List<&2, P.Fr>, +q: Nat, +lft: Bool, +s: ST.Tr, +t: ST.Tr) -> {NL.memn(ST.rid(PG.plug(Con{P.FR{q, lft, s}, u}, t)), SC.append(Nat, P.before(Con{P.FR{q, lft, s}, u}), P.after(Con{P.FR{q, lft, s}, u}))) == True{} : Bool}: match u lft: case Nil{} True{}: q_in(q, True{}, s, Nil{}) case Nil{} False{}: q_in(q, False{}, s, Nil{}) case Con{P.FR{+q2, +l2, +s2}, +u2} True{}: +ih = rid_in(u2, q2, l2, s2, ST.TN{q, t, s}) ba_up_c(ST.rid(PG.plug(Con{P.FR{q2, l2, s2}, u2}, ST.TN{q, t, s})), q, True{}, s, Con{P.FR{q2, l2, s2}, u2}, NL.memn(ST.rid(PG.plug(Con{P.FR{q2, l2, s2}, u2}, ST.TN{q, t, s})), P.before(Con{P.FR{q2, l2, s2}, u2})), {==}, ih) case Con{P.FR{+q2, +l2, +s2}, +u2} False{}: +ih = rid_in(u2, q2, l2, s2, ST.TN{q, s, t}) ba_up_c(ST.rid(PG.plug(Con{P.FR{q2, l2, s2}, u2}, ST.TN{q, s, t})), q, False{}, s, Con{P.FR{q2, l2, s2}, u2}, NL.memn(ST.rid(PG.plug(Con{P.FR{q2, l2, s2}, u2}, ST.TN{q, s, t})), P.before(Con{P.FR{q2, l2, s2}, u2})), {==}, ih) # three recolourings away from the root keep it black def rb_keep3(~K: Data, +nl: List<&2, M.Node>, +c: List<&2, P.Fr>, +t: ST.Tr, +p: Nat, +u: Nat, +g: Nat, +hn: {NL.nodupn(SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(t), P.after(c)))) == True{} : Bool}, +mp: {NL.memn(p, ST.ids(t)) == True{} : Bool}, +mu: {NL.memn(u, ST.ids(t)) == True{} : Bool}, +mg: {NL.memn(g, ST.ids(t)) == True{} : Bool}, +h: {Bool.or(ST.root_black(~K, PG.plug(c, t), nl), isnil(c)) == True{} : Bool}) -> {Bool.or(ST.root_black(~K, PG.plug(c, t), SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{})), isnil(c)) == True{} : Bool}: match c: case Nil{}: NL.or_true_b(ST.root_black(~K, t, SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}))) case Con{P.FR{+q, +lft, +s}, +w}: +mr = rid_in(w, q, lft, s, t) +np = RP.w_notin(Con{P.FR{q, lft, s}, w}, t, hn, p, mp) +nu = RP.w_notin(Con{P.FR{q, lft, s}, w}, t, hn, u, mu) +ng = RP.w_notin(Con{P.FR{q, lft, s}, w}, t, hn, g, mg) +R = ST.rid(PG.plug(Con{P.FR{q, lft, s}, w}, t)) %Equal.sym(Bool, ST.root_black(~K, PG.plug(Con{P.FR{q, lft, s}, w}, t), SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{})), Bool.not(ST.is_red(K, ST.nd(K, SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}), R))), rb_rid(~K, PG.plug(Con{P.FR{q, lft, s}, w}, t), SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}))) : {Bool.or(_, False{}) == True{} : Bool} %Equal.sym(M.Node, ST.nd(K, SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}), R), ST.nd(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), R), RN.skipc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}, R, DJ.ne_nm(g, R, SC.append(Nat, P.before(Con{P.FR{q, lft, s}, w}), P.after(Con{P.FR{q, lft, s}, w})), ng, mr))) : {Bool.or(Bool.not(ST.is_red(K, _)), False{}) == True{} : Bool} %Equal.sym(M.Node, ST.nd(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), R), ST.nd(K, SE.setc(K, nl, p, False{}), R), RN.skipc(K, SE.setc(K, nl, p, False{}), u, False{}, R, DJ.ne_nm(u, R, SC.append(Nat, P.before(Con{P.FR{q, lft, s}, w}), P.after(Con{P.FR{q, lft, s}, w})), nu, mr))) : {Bool.or(Bool.not(ST.is_red(K, _)), False{}) == True{} : Bool} %Equal.sym(M.Node, ST.nd(K, SE.setc(K, nl, p, False{}), R), ST.nd(K, nl, R), RN.skipc(K, nl, p, False{}, R, DJ.ne_nm(p, R, SC.append(Nat, P.before(Con{P.FR{q, lft, s}, w}), P.after(Con{P.FR{q, lft, s}, w})), np, mr))) : {Bool.or(Bool.not(ST.is_red(K, _)), False{}) == True{} : Bool} %Equal.sym(Bool, Bool.not(ST.is_red(K, ST.nd(K, nl, R))), ST.root_black(~K, PG.plug(Con{P.FR{q, lft, s}, w}, t), nl), Equal.sym(Bool, ST.root_black(~K, PG.plug(Con{P.FR{q, lft, s}, w}, t), nl), Bool.not(ST.is_red(K, ST.nd(K, nl, R))), rb_rid(~K, PG.plug(Con{P.FR{q, lft, s}, w}, t), nl))) : {Bool.or(_, False{}) == True{} : Bool} h # ---- the loop's continuation ---- # recolouring the parent, the uncle black and the grandparent red, then # going on from the grandparent def rc_go(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c2: List<&2, P.Fr>, +g: Nat, +ga: ST.Tr, +gb: ST.Tr, +p: Nat, +u: Nat, +i1: {ST.rep(~K, ST.TN{g, ga, gb}, P.top(c2), nl) == True{} : Bool}, +i2: {P.ctxok(~K, c2, g, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ga, gb}), P.after(c2)))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ga, gb}), P.after(c2))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(c2, ST.TN{g, ga, gb})) : Nat}, +i6: {Bool.or(ST.root_black(~K, PG.plug(c2, ST.TN{g, ga, gb}), nl), isnil(c2)) == True{} : Bool}, +mp: {NL.memn(p, ST.ids(ST.TN{g, ga, gb})) == True{} : Bool}, +mu: {NL.memn(u, ST.ids(ST.TN{g, ga, gb})) == True{} : Bool}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}, kont: @+kr_: Nat -> @+kn_: List<&2, M.Node> -> @+kc_: List<&2, P.Fr> -> @+kz_: Nat -> @+kzl_: ST.Tr -> @+kzr_: ST.Tr -> @+ki1: {ST.rep(~K, ST.TN{kz_, kzl_, kzr_}, P.top(kc_), kn_) == True{} : Bool} -> @+ki2: {P.ctxok(~K, kc_, kz_, kn_) == True{} : Bool} -> @+ki3: {NL.nodupn(SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_)))) == True{} : Bool} -> @+ki4: {SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_))) == i0 : List<&2, Nat>} -> @+ki5: {kr_ == ST.rid(PG.plug(kc_, ST.TN{kz_, kzl_, kzr_})) : Nat} -> @+ki6: {Bool.or(ST.root_black(~K, PG.plug(kc_, ST.TN{kz_, kzl_, kzr_}), kn_), isnil(kc_)) == True{} : Bool} -> @+kh4: {ST.ents(~K, ~V, i0, kn_, pl) == e0 : List<&2, M.Entry>} -> @+kh5: {EN.oks(~K, ~V, i0, kn_, pl) == True{} : Bool} -> @+kh6: {ST.fll(~K, kn_, fx) == True{} : Bool} -> @+kh7: {SC.length(M.Node, kn_) == l0 : Nat} -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (ST.SH{n, kr_, lo, hi, free, l, d, kn_, pl, tg, fl}, M.Fix{kz_, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, p, False{}), u, False{}), g, True{}), M.Fix{g, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: %Equal.sym(ST.Sh, MI.set_red(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, p, False{}), ST.SH{n, root, lo, hi, free, l, d, SE.setc(K, nl, p, False{}), pl, tg, fl}, SE.set_red_m(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, tg, fl, p, False{})) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, _, u, False{}), g, True{}), M.Fix{g, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(ST.Sh, MI.set_red(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, SE.setc(K, nl, p, False{}), pl, tg, fl}, u, False{}), ST.SH{n, root, lo, hi, free, l, d, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), pl, tg, fl}, SE.set_red_m(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, SE.setc(K, nl, p, False{}), pl, tg, fl, u, False{})) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.set_red(~K, ~V, ~cmp, _, g, True{}), M.Fix{g, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(ST.Sh, MI.set_red(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), pl, tg, fl}, g, True{}), ST.SH{n, root, lo, hi, free, l, d, SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}), pl, tg, fl}, SE.set_red_m(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), pl, tg, fl, g, True{})) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (_, M.Fix{g, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> +r1 = Equal.trans(Bool, ST.rep(~K, ST.TN{g, ga, gb}, P.top(c2), SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{})), ST.rep(~K, ST.TN{g, ga, gb}, P.top(c2), SE.setc(K, SE.setc(K, nl, p, False{}), u, False{})), True{}, SE.rep_setc(~K, ST.TN{g, ga, gb}, P.top(c2), SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}), Equal.trans(Bool, ST.rep(~K, ST.TN{g, ga, gb}, P.top(c2), SE.setc(K, SE.setc(K, nl, p, False{}), u, False{})), ST.rep(~K, ST.TN{g, ga, gb}, P.top(c2), SE.setc(K, nl, p, False{})), True{}, SE.rep_setc(~K, ST.TN{g, ga, gb}, P.top(c2), SE.setc(K, nl, p, False{}), u, False{}), Equal.trans(Bool, ST.rep(~K, ST.TN{g, ga, gb}, P.top(c2), SE.setc(K, nl, p, False{})), ST.rep(~K, ST.TN{g, ga, gb}, P.top(c2), nl), True{}, SE.rep_setc(~K, ST.TN{g, ga, gb}, P.top(c2), nl, p, False{}), i1))) +r2 = Equal.trans(Bool, P.ctxok(~K, c2, g, SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{})), P.ctxok(~K, c2, g, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{})), True{}, SE.ctx_setc(~K, c2, g, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}), Equal.trans(Bool, P.ctxok(~K, c2, g, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{})), P.ctxok(~K, c2, g, SE.setc(K, nl, p, False{})), True{}, SE.ctx_setc(~K, c2, g, SE.setc(K, nl, p, False{}), u, False{}), Equal.trans(Bool, P.ctxok(~K, c2, g, SE.setc(K, nl, p, False{})), P.ctxok(~K, c2, g, nl), True{}, SE.ctx_setc(~K, c2, g, nl, p, False{}), i2))) +r6 = rb_keep3(~K, nl, c2, ST.TN{g, ga, gb}, p, u, g, i3, mp, mu, P.mem_root(g, ga, gb), i6) +e4 = Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}), pl), ST.ents(~K, ~V, i0, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), pl), e0, SE.ents_setc(~K, ~V, i0, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), pl, g, True{}), Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), pl), ST.ents(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl), e0, SE.ents_setc(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl, u, False{}), Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl), ST.ents(~K, ~V, i0, nl, pl), e0, SE.ents_setc(~K, ~V, i0, nl, pl, p, False{}), h4))) +e5 = Equal.trans(Bool, EN.oks(~K, ~V, i0, SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}), pl), EN.oks(~K, ~V, i0, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), pl), True{}, SE.oks_setc(~K, ~V, i0, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), pl, g, True{}), Equal.trans(Bool, EN.oks(~K, ~V, i0, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), pl), EN.oks(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl), True{}, SE.oks_setc(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl, u, False{}), Equal.trans(Bool, EN.oks(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl), EN.oks(~K, ~V, i0, nl, pl), True{}, SE.oks_setc(~K, ~V, i0, nl, pl, p, False{}), h5))) +e6 = Equal.trans(Bool, ST.fll(~K, SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}), fx), ST.fll(~K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), fx), True{}, SE.fll_setc(~K, fx, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}), Equal.trans(Bool, ST.fll(~K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), fx), ST.fll(~K, SE.setc(K, nl, p, False{}), fx), True{}, SE.fll_setc(~K, fx, SE.setc(K, nl, p, False{}), u, False{}), Equal.trans(Bool, ST.fll(~K, SE.setc(K, nl, p, False{}), fx), ST.fll(~K, nl, fx), True{}, SE.fll_setc(~K, fx, nl, p, False{}), h6))) +e7 = Equal.trans(Nat, SC.length(M.Node, SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{})), SC.length(M.Node, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{})), l0, SE.setc_len(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}), Equal.trans(Nat, SC.length(M.Node, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{})), SC.length(M.Node, SE.setc(K, nl, p, False{})), l0, SE.setc_len(K, SE.setc(K, nl, p, False{}), u, False{}), Equal.trans(Nat, SC.length(M.Node, SE.setc(K, nl, p, False{})), SC.length(M.Node, nl), l0, SE.setc_len(K, nl, p, False{}), h7))) kont(root, SE.setc(K, SE.setc(K, SE.setc(K, nl, p, False{}), u, False{}), g, True{}), c2, g, ga, gb, r1, r2, i3, i4, i5, r6, e4, e5, e6, e7) # ---- a last rotation, then the end ---- def fin_rr(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c: List<&2, P.Fr>, +x: Nat, +y: Nat, +ta: ST.Tr, +tb: ST.Tr, +tc: ST.Tr, +hr: {ST.rep(~K, ST.TN{x, ST.TN{y, ta, tb}, tc}, P.top(c), nl) == True{} : Bool}, +hok: {P.ctxok(~K, c, x, nl) == True{} : Bool}, +hnd: {NL.nodupn(SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{x, ST.TN{y, ta, tb}, tc}), P.after(c)))) == True{} : Bool}, +hroot: {root == ST.rid(PG.plug(c, ST.TN{x, ST.TN{y, ta, tb}, tc})) : Nat}, +hids: {SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{x, ST.TN{y, ta, tb}, tc}), P.after(c))) == i0 : List<&2, Nat>}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, x), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: %Equal.sym(ST.Sh, MI.rotate_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, x), ST.SH{n, RM.rootq(P.top(c), root, y), lo, hi, free, l, d, RM.rotr_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), pl, tg, fl}, RP.rotr_path_eq(~K, ~V, ~cmp, ~o, n, root, lo, hi, free, l, d, nl, pl, tg, fl, c, x, ta, y, tb, tc, hr, hok, hnd)) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (_, M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> +hr2 = RP.rotr_path_rep(~K, ~cmp, ~o, nl, c, x, ta, y, tb, tc, hr, hok, hnd) +hc2 = RP.rotr_path_ctx(~K, ~cmp, ~o, nl, c, x, ta, y, tb, tc, hr, hok, hnd) +ho = Equal.trans(List<&2, Nat>, ST.ids(PG.plug(c, ST.TN{y, ta, ST.TN{x, tb, tc}})), SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{y, ta, ST.TN{x, tb, tc}}), P.after(c))), i0, PG.ids_plug(c, ST.TN{y, ta, ST.TN{x, tb, tc}}), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{y, ta, ST.TN{x, tb, tc}}), P.after(c))), SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{x, ST.TN{y, ta, tb}, tc}), P.after(c))), i0, RP.wh_eq(c, ST.TN{y, ta, ST.TN{x, tb, tc}}, ST.TN{x, ST.TN{y, ta, tb}, tc}, RP.ids_rr(x, y, ta, tb, tc)), hids)) +hq = RP.root_rot(~K, nl, c, x, y, ST.TN{x, ST.TN{y, ta, tb}, tc}, ST.TN{y, ta, ST.TN{x, tb, tc}}, root, {==}, {==}, hok, hroot) stop(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, RM.rootq(P.top(c), root, y), RM.rotr_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), PG.plug(c, ST.TN{y, ta, ST.TN{x, tb, tc}}), PG.rep_plug(~K, RM.rotr_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), c, ST.TN{y, ta, ST.TN{x, tb, tc}}, hr2, hc2), hq, ho, Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, RM.rotr_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), pl), ST.ents(~K, ~V, i0, nl, pl), e0, RP.rotr_ents(~K, ~V, i0, pl, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), h4), Equal.trans(Bool, EN.oks(~K, ~V, i0, RM.rotr_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), pl), EN.oks(~K, ~V, i0, nl, pl), True{}, RP.rotr_oks(~K, ~V, i0, pl, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), h5), Equal.trans(Bool, ST.fll(~K, RM.rotr_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), fx), ST.fll(~K, nl, fx), True{}, RP.rotr_fll(~K, fx, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), h6), Equal.trans(Nat, SC.length(M.Node, RM.rotr_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c))), SC.length(M.Node, nl), l0, RP.rotr_len(~K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), h7)) def fin_rl(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c: List<&2, P.Fr>, +x: Nat, +y: Nat, +ta: ST.Tr, +tb: ST.Tr, +tc: ST.Tr, +hr: {ST.rep(~K, ST.TN{x, ta, ST.TN{y, tb, tc}}, P.top(c), nl) == True{} : Bool}, +hok: {P.ctxok(~K, c, x, nl) == True{} : Bool}, +hnd: {NL.nodupn(SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{x, ta, ST.TN{y, tb, tc}}), P.after(c)))) == True{} : Bool}, +hroot: {root == ST.rid(PG.plug(c, ST.TN{x, ta, ST.TN{y, tb, tc}})) : Nat}, +hids: {SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{x, ta, ST.TN{y, tb, tc}}), P.after(c))) == i0 : List<&2, Nat>}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, x), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: %Equal.sym(ST.Sh, MI.rotate_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, x), ST.SH{n, RM.rootq(P.top(c), root, y), lo, hi, free, l, d, RM.rotl_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), pl, tg, fl}, RP.rotl_path_eq(~K, ~V, ~cmp, ~o, n, root, lo, hi, free, l, d, nl, pl, tg, fl, c, x, ta, y, tb, tc, hr, hok, hnd)) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (_, M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> +hr2 = RP.rotl_path_rep(~K, ~cmp, ~o, nl, c, x, ta, y, tb, tc, hr, hok, hnd) +hc2 = RP.rotl_path_ctx(~K, ~cmp, ~o, nl, c, x, ta, y, tb, tc, hr, hok, hnd) +ho = Equal.trans(List<&2, Nat>, ST.ids(PG.plug(c, ST.TN{y, ST.TN{x, ta, tb}, tc})), SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{y, ST.TN{x, ta, tb}, tc}), P.after(c))), i0, PG.ids_plug(c, ST.TN{y, ST.TN{x, ta, tb}, tc}), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{y, ST.TN{x, ta, tb}, tc}), P.after(c))), SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{x, ta, ST.TN{y, tb, tc}}), P.after(c))), i0, RP.wh_eq(c, ST.TN{y, ST.TN{x, ta, tb}, tc}, ST.TN{x, ta, ST.TN{y, tb, tc}}, RP.ids_rl(x, ta, y, tb, tc)), hids)) +hq = RP.root_rot(~K, nl, c, x, y, ST.TN{x, ta, ST.TN{y, tb, tc}}, ST.TN{y, ST.TN{x, ta, tb}, tc}, root, {==}, {==}, hok, hroot) stop(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, RM.rootq(P.top(c), root, y), RM.rotl_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), PG.plug(c, ST.TN{y, ST.TN{x, ta, tb}, tc}), PG.rep_plug(~K, RM.rotl_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), c, ST.TN{y, ST.TN{x, ta, tb}, tc}, hr2, hc2), hq, ho, Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, RM.rotl_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), pl), ST.ents(~K, ~V, i0, nl, pl), e0, RP.rotl_ents(~K, ~V, i0, pl, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), h4), Equal.trans(Bool, EN.oks(~K, ~V, i0, RM.rotl_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), pl), EN.oks(~K, ~V, i0, nl, pl), True{}, RP.rotl_oks(~K, ~V, i0, pl, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), h5), Equal.trans(Bool, ST.fll(~K, RM.rotl_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), fx), ST.fll(~K, nl, fx), True{}, RP.rotl_fll(~K, fx, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), h6), Equal.trans(Nat, SC.length(M.Node, RM.rotl_nl(K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c))), SC.length(M.Node, nl), l0, RP.rotl_len(~K, nl, x, y, ST.rid(tb), P.top(c), SP.dir(c)), h7)) # ---- a black uncle: rotations ---- def bl_line(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c2: List<&2, P.Fr>, +p: Nat, +s1: ST.Tr, +g: Nat, +s2: ST.Tr, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, p, nl) == True{} : Bool}, +i2: {P.ctxok(~K, Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}})))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}, ST.TN{z, zl, zr})) : Nat}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, p, False{}), g, True{}), g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: +eqW = Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, s2}), P.after(c2))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), P.ids_l(Con{P.FR{g, True{}, s2}, c2}, p, ST.TN{z, zl, zr}, s1)), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, s2}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, True{}, s2}, c2}))), P.ids_l(c2, g, ST.TN{p, ST.TN{z, zl, zr}, s1}, s2))) %Equal.sym(ST.Sh, MI.set_red(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, p, False{}), ST.SH{n, root, lo, hi, free, l, d, SE.setc(K, nl, p, False{}), pl, tg, fl}, SE.set_red_m(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, tg, fl, p, False{})) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, _, g, True{}), g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(ST.Sh, MI.set_red(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, SE.setc(K, nl, p, False{}), pl, tg, fl}, g, True{}), ST.SH{n, root, lo, hi, free, l, d, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{}), pl, tg, fl}, SE.set_red_m(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, SE.setc(K, nl, p, False{}), pl, tg, fl, g, True{})) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_right(~K, ~V, ~cmp, _, g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> fin_rr(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{}), c2, g, p, ST.TN{z, zl, zr}, s1, s2, Equal.trans(Bool, ST.rep(~K, ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, s2}, P.top(c2), SE.setc(K, SE.setc(K, nl, p, False{}), g, True{})), ST.rep(~K, ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, s2}, P.top(c2), SE.setc(K, nl, p, False{})), True{}, SE.rep_setc(~K, ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, s2}, P.top(c2), SE.setc(K, nl, p, False{}), g, True{}), Equal.trans(Bool, ST.rep(~K, ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, s2}, P.top(c2), SE.setc(K, nl, p, False{})), ST.rep(~K, ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, s2}, P.top(c2), nl), True{}, SE.rep_setc(~K, ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, s2}, P.top(c2), nl, p, False{}), up_t(~K, nl, g, s2, ST.TN{p, ST.TN{z, zl, zr}, s1}, P.top(c2), up_t(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, s2}, c2}, p, nl), i2)), L.and_left(P.cok1(~K, P.FR{g, True{}, s2}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, s2}, c2}, p, nl), i2))))), Equal.trans(Bool, P.ctxok(~K, c2, g, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{})), P.ctxok(~K, c2, g, SE.setc(K, nl, p, False{})), True{}, SE.ctx_setc(~K, c2, g, SE.setc(K, nl, p, False{}), g, True{}), Equal.trans(Bool, P.ctxok(~K, c2, g, SE.setc(K, nl, p, False{})), P.ctxok(~K, c2, g, nl), True{}, SE.ctx_setc(~K, c2, g, nl, p, False{}), L.and_right(P.cok1(~K, P.FR{g, True{}, s2}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, s2}, c2}, p, nl), i2)))), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, s2}), P.after(c2))), eqW, i3), i5, Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, s2}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), i0, Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, s2}), P.after(c2))), eqW), i4), Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{}), pl), ST.ents(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl), e0, SE.ents_setc(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl, g, True{}), Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl), ST.ents(~K, ~V, i0, nl, pl), e0, SE.ents_setc(~K, ~V, i0, nl, pl, p, False{}), h4)), Equal.trans(Bool, EN.oks(~K, ~V, i0, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{}), pl), EN.oks(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl), True{}, SE.oks_setc(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl, g, True{}), Equal.trans(Bool, EN.oks(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl), EN.oks(~K, ~V, i0, nl, pl), True{}, SE.oks_setc(~K, ~V, i0, nl, pl, p, False{}), h5)), Equal.trans(Bool, ST.fll(~K, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{}), fx), ST.fll(~K, SE.setc(K, nl, p, False{}), fx), True{}, SE.fll_setc(~K, fx, SE.setc(K, nl, p, False{}), g, True{}), Equal.trans(Bool, ST.fll(~K, SE.setc(K, nl, p, False{}), fx), ST.fll(~K, nl, fx), True{}, SE.fll_setc(~K, fx, nl, p, False{}), h6)), Equal.trans(Nat, SC.length(M.Node, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{})), SC.length(M.Node, SE.setc(K, nl, p, False{})), l0, SE.setc_len(K, SE.setc(K, nl, p, False{}), g, True{}), Equal.trans(Nat, SC.length(M.Node, SE.setc(K, nl, p, False{})), SC.length(M.Node, nl), l0, SE.setc_len(K, nl, p, False{}), h7))) def bl_tri(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c2: List<&2, P.Fr>, +p: Nat, +s1: ST.Tr, +g: Nat, +s2: ST.Tr, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, p, nl) == True{} : Bool}, +i2: {P.ctxok(~K, Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}})))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}, ST.TN{z, zl, zr})) : Nat}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, p), z, False{}), g, True{}), g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: %Equal.sym(ST.Sh, MI.rotate_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, p), ST.SH{n, RM.rootq(g, root, z), lo, hi, free, l, d, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), pl, tg, fl}, RP.rotl_path_eq(~K, ~V, ~cmp, ~o, n, root, lo, hi, free, l, d, nl, pl, tg, fl, Con{P.FR{g, True{}, s2}, c2}, p, s1, z, zl, zr, up_f(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, s2}, c2}, p, nl), i2)), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, s2}, c2}, p, nl), i2), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), P.ids_r(Con{P.FR{g, True{}, s2}, c2}, p, s1, ST.TN{z, zl, zr})), i3))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, _, z, False{}), g, True{}), g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(ST.Sh, MI.set_red(~K, ~V, ~cmp, ST.SH{n, RM.rootq(g, root, z), lo, hi, free, l, d, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), pl, tg, fl}, z, False{}), ST.SH{n, RM.rootq(g, root, z), lo, hi, free, l, d, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), pl, tg, fl}, SE.set_red_m(~K, ~V, ~cmp, n, RM.rootq(g, root, z), lo, hi, free, l, d, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), pl, tg, fl, z, False{})) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, _, g, True{}), g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(ST.Sh, MI.set_red(~K, ~V, ~cmp, ST.SH{n, RM.rootq(g, root, z), lo, hi, free, l, d, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), pl, tg, fl}, g, True{}), ST.SH{n, RM.rootq(g, root, z), lo, hi, free, l, d, SE.setc(K, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), g, True{}), pl, tg, fl}, SE.set_red_m(~K, ~V, ~cmp, n, RM.rootq(g, root, z), lo, hi, free, l, d, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), pl, tg, fl, g, True{})) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_right(~K, ~V, ~cmp, _, g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> fin_rr(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, RM.rootq(g, root, z), SE.setc(K, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), g, True{}), c2, g, z, ST.TN{p, s1, zl}, zr, s2, Equal.trans(Bool, ST.rep(~K, ST.TN{g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2}, P.top(c2), SE.setc(K, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), g, True{})), ST.rep(~K, ST.TN{g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2}, P.top(c2), SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{})), True{}, SE.rep_setc(~K, ST.TN{g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2}, P.top(c2), SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), g, True{}), Equal.trans(Bool, ST.rep(~K, ST.TN{g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2}, P.top(c2), SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{})), ST.rep(~K, ST.TN{g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2}, P.top(c2), RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{})), True{}, SE.rep_setc(~K, ST.TN{g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2}, P.top(c2), RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), up_t(~K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), g, s2, ST.TN{z, ST.TN{p, s1, zl}, zr}, P.top(c2), RP.rotl_path_rep(~K, ~cmp, ~o, nl, Con{P.FR{g, True{}, s2}, c2}, p, s1, z, zl, zr, up_f(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, s2}, c2}, p, nl), i2)), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, s2}, c2}, p, nl), i2), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), P.ids_r(Con{P.FR{g, True{}, s2}, c2}, p, s1, ST.TN{z, zl, zr})), i3)), L.and_left(P.cok1(~K, P.FR{g, True{}, s2}, z, P.top(c2), RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{})), P.ctxok(~K, c2, g, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{})), RP.rotl_path_ctx(~K, ~cmp, ~o, nl, Con{P.FR{g, True{}, s2}, c2}, p, s1, z, zl, zr, up_f(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, s2}, c2}, p, nl), i2)), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, s2}, c2}, p, nl), i2), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), P.ids_r(Con{P.FR{g, True{}, s2}, c2}, p, s1, ST.TN{z, zl, zr})), i3)))))), Equal.trans(Bool, P.ctxok(~K, c2, g, SE.setc(K, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), g, True{})), P.ctxok(~K, c2, g, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{})), True{}, SE.ctx_setc(~K, c2, g, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), g, True{}), Equal.trans(Bool, P.ctxok(~K, c2, g, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{})), P.ctxok(~K, c2, g, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{})), True{}, SE.ctx_setc(~K, c2, g, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), L.and_right(P.cok1(~K, P.FR{g, True{}, s2}, z, P.top(c2), RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{})), P.ctxok(~K, c2, g, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{})), RP.rotl_path_ctx(~K, ~cmp, ~o, nl, Con{P.FR{g, True{}, s2}, c2}, p, s1, z, zl, zr, up_f(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, s2}, c2}, p, nl), i2)), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, s2}, c2}, p, nl), i2), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), P.ids_r(Con{P.FR{g, True{}, s2}, c2}, p, s1, ST.TN{z, zl, zr})), i3))))), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2}), P.after(c2))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{z, ST.TN{p, s1, zl}, zr}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), P.ids_l(c2, g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{z, ST.TN{p, s1, zl}, zr}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), RP.wh_eq(Con{P.FR{g, True{}, s2}, c2}, ST.TN{z, ST.TN{p, s1, zl}, zr}, ST.TN{p, s1, ST.TN{z, zl, zr}}, RP.ids_rl(p, s1, z, zl, zr)), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), P.ids_r(Con{P.FR{g, True{}, s2}, c2}, p, s1, ST.TN{z, zl, zr})))))), i3), RP.root_rot(~K, nl, Con{P.FR{g, True{}, s2}, c2}, p, z, ST.TN{p, s1, ST.TN{z, zl, zr}}, ST.TN{z, ST.TN{p, s1, zl}, zr}, root, {==}, {==}, L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, s2}, c2}, p, nl), i2), i5), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), i0, Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{z, ST.TN{p, s1, zl}, zr}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), P.ids_l(c2, g, ST.TN{z, ST.TN{p, s1, zl}, zr}, s2), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{z, ST.TN{p, s1, zl}, zr}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), RP.wh_eq(Con{P.FR{g, True{}, s2}, c2}, ST.TN{z, ST.TN{p, s1, zl}, zr}, ST.TN{p, s1, ST.TN{z, zl, zr}}, RP.ids_rl(p, s1, z, zl, zr)), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, True{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, s2}, c2}}))), P.ids_r(Con{P.FR{g, True{}, s2}, c2}, p, s1, ST.TN{z, zl, zr}))))), i4), Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, SE.setc(K, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), g, True{}), pl), ST.ents(~K, ~V, i0, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), pl), e0, SE.ents_setc(~K, ~V, i0, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), pl, g, True{}), Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), pl), ST.ents(~K, ~V, i0, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), pl), e0, SE.ents_setc(~K, ~V, i0, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), pl, z, False{}), Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), pl), ST.ents(~K, ~V, i0, nl, pl), e0, RP.rotl_ents(~K, ~V, i0, pl, nl, p, z, ST.rid(zl), g, True{}), h4))), Equal.trans(Bool, EN.oks(~K, ~V, i0, SE.setc(K, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), g, True{}), pl), EN.oks(~K, ~V, i0, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), pl), True{}, SE.oks_setc(~K, ~V, i0, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), pl, g, True{}), Equal.trans(Bool, EN.oks(~K, ~V, i0, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), pl), EN.oks(~K, ~V, i0, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), pl), True{}, SE.oks_setc(~K, ~V, i0, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), pl, z, False{}), Equal.trans(Bool, EN.oks(~K, ~V, i0, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), pl), EN.oks(~K, ~V, i0, nl, pl), True{}, RP.rotl_oks(~K, ~V, i0, pl, nl, p, z, ST.rid(zl), g, True{}), h5))), Equal.trans(Bool, ST.fll(~K, SE.setc(K, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), g, True{}), fx), ST.fll(~K, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), fx), True{}, SE.fll_setc(~K, fx, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), g, True{}), Equal.trans(Bool, ST.fll(~K, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), fx), ST.fll(~K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), fx), True{}, SE.fll_setc(~K, fx, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), Equal.trans(Bool, ST.fll(~K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), fx), ST.fll(~K, nl, fx), True{}, RP.rotl_fll(~K, fx, nl, p, z, ST.rid(zl), g, True{}), h6))), Equal.trans(Nat, SC.length(M.Node, SE.setc(K, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), g, True{})), SC.length(M.Node, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{})), l0, SE.setc_len(K, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), g, True{}), Equal.trans(Nat, SC.length(M.Node, SE.setc(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{})), SC.length(M.Node, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{})), l0, SE.setc_len(K, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{}), z, False{}), Equal.trans(Nat, SC.length(M.Node, RM.rotl_nl(K, nl, p, z, ST.rid(zl), g, True{})), SC.length(M.Node, nl), l0, RP.rotl_len(~K, nl, p, z, ST.rid(zl), g, True{}), h7)))) def br_line(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c2: List<&2, P.Fr>, +p: Nat, +s1: ST.Tr, +g: Nat, +s2: ST.Tr, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, p, nl) == True{} : Bool}, +i2: {P.ctxok(~K, Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}})))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}, ST.TN{z, zl, zr})) : Nat}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, p, False{}), g, True{}), g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: +eqW = Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}}), P.after(c2))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), P.ids_r(Con{P.FR{g, False{}, s2}, c2}, p, s1, ST.TN{z, zl, zr})), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, False{}, s2}, c2}))), P.ids_r(c2, g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}))) %Equal.sym(ST.Sh, MI.set_red(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, p, False{}), ST.SH{n, root, lo, hi, free, l, d, SE.setc(K, nl, p, False{}), pl, tg, fl}, SE.set_red_m(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, tg, fl, p, False{})) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, _, g, True{}), g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(ST.Sh, MI.set_red(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, SE.setc(K, nl, p, False{}), pl, tg, fl}, g, True{}), ST.SH{n, root, lo, hi, free, l, d, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{}), pl, tg, fl}, SE.set_red_m(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, SE.setc(K, nl, p, False{}), pl, tg, fl, g, True{})) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_left(~K, ~V, ~cmp, _, g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> fin_rl(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{}), c2, g, p, s2, s1, ST.TN{z, zl, zr}, Equal.trans(Bool, ST.rep(~K, ST.TN{g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}}, P.top(c2), SE.setc(K, SE.setc(K, nl, p, False{}), g, True{})), ST.rep(~K, ST.TN{g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}}, P.top(c2), SE.setc(K, nl, p, False{})), True{}, SE.rep_setc(~K, ST.TN{g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}}, P.top(c2), SE.setc(K, nl, p, False{}), g, True{}), Equal.trans(Bool, ST.rep(~K, ST.TN{g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}}, P.top(c2), SE.setc(K, nl, p, False{})), ST.rep(~K, ST.TN{g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}}, P.top(c2), nl), True{}, SE.rep_setc(~K, ST.TN{g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}}, P.top(c2), nl, p, False{}), up_f(~K, nl, g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}, P.top(c2), up_f(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, s2}, c2}, p, nl), i2)), L.and_left(P.cok1(~K, P.FR{g, False{}, s2}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, s2}, c2}, p, nl), i2))))), Equal.trans(Bool, P.ctxok(~K, c2, g, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{})), P.ctxok(~K, c2, g, SE.setc(K, nl, p, False{})), True{}, SE.ctx_setc(~K, c2, g, SE.setc(K, nl, p, False{}), g, True{}), Equal.trans(Bool, P.ctxok(~K, c2, g, SE.setc(K, nl, p, False{})), P.ctxok(~K, c2, g, nl), True{}, SE.ctx_setc(~K, c2, g, nl, p, False{}), L.and_right(P.cok1(~K, P.FR{g, False{}, s2}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, s2}, c2}, p, nl), i2)))), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}}), P.after(c2))), eqW, i3), i5, Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), i0, Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, s2, ST.TN{p, s1, ST.TN{z, zl, zr}}}), P.after(c2))), eqW), i4), Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{}), pl), ST.ents(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl), e0, SE.ents_setc(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl, g, True{}), Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl), ST.ents(~K, ~V, i0, nl, pl), e0, SE.ents_setc(~K, ~V, i0, nl, pl, p, False{}), h4)), Equal.trans(Bool, EN.oks(~K, ~V, i0, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{}), pl), EN.oks(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl), True{}, SE.oks_setc(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl, g, True{}), Equal.trans(Bool, EN.oks(~K, ~V, i0, SE.setc(K, nl, p, False{}), pl), EN.oks(~K, ~V, i0, nl, pl), True{}, SE.oks_setc(~K, ~V, i0, nl, pl, p, False{}), h5)), Equal.trans(Bool, ST.fll(~K, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{}), fx), ST.fll(~K, SE.setc(K, nl, p, False{}), fx), True{}, SE.fll_setc(~K, fx, SE.setc(K, nl, p, False{}), g, True{}), Equal.trans(Bool, ST.fll(~K, SE.setc(K, nl, p, False{}), fx), ST.fll(~K, nl, fx), True{}, SE.fll_setc(~K, fx, nl, p, False{}), h6)), Equal.trans(Nat, SC.length(M.Node, SE.setc(K, SE.setc(K, nl, p, False{}), g, True{})), SC.length(M.Node, SE.setc(K, nl, p, False{})), l0, SE.setc_len(K, SE.setc(K, nl, p, False{}), g, True{}), Equal.trans(Nat, SC.length(M.Node, SE.setc(K, nl, p, False{})), SC.length(M.Node, nl), l0, SE.setc_len(K, nl, p, False{}), h7))) def br_tri(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c2: List<&2, P.Fr>, +p: Nat, +s1: ST.Tr, +g: Nat, +s2: ST.Tr, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, p, nl) == True{} : Bool}, +i2: {P.ctxok(~K, Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}})))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}, ST.TN{z, zl, zr})) : Nat}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, p), z, False{}), g, True{}), g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: %Equal.sym(ST.Sh, MI.rotate_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, p), ST.SH{n, RM.rootq(g, root, z), lo, hi, free, l, d, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), pl, tg, fl}, RP.rotr_path_eq(~K, ~V, ~cmp, ~o, n, root, lo, hi, free, l, d, nl, pl, tg, fl, Con{P.FR{g, False{}, s2}, c2}, p, zl, z, zr, s1, up_t(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, s2}, c2}, p, nl), i2)), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, s2}, c2}, p, nl), i2), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), P.ids_l(Con{P.FR{g, False{}, s2}, c2}, p, ST.TN{z, zl, zr}, s1)), i3))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, _, z, False{}), g, True{}), g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(ST.Sh, MI.set_red(~K, ~V, ~cmp, ST.SH{n, RM.rootq(g, root, z), lo, hi, free, l, d, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), pl, tg, fl}, z, False{}), ST.SH{n, RM.rootq(g, root, z), lo, hi, free, l, d, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), pl, tg, fl}, SE.set_red_m(~K, ~V, ~cmp, n, RM.rootq(g, root, z), lo, hi, free, l, d, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), pl, tg, fl, z, False{})) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, _, g, True{}), g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(ST.Sh, MI.set_red(~K, ~V, ~cmp, ST.SH{n, RM.rootq(g, root, z), lo, hi, free, l, d, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), pl, tg, fl}, g, True{}), ST.SH{n, RM.rootq(g, root, z), lo, hi, free, l, d, SE.setc(K, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), g, True{}), pl, tg, fl}, SE.set_red_m(~K, ~V, ~cmp, n, RM.rootq(g, root, z), lo, hi, free, l, d, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), pl, tg, fl, g, True{})) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (MI.rotate_left(~K, ~V, ~cmp, _, g), M.Fix{0n, False{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> fin_rl(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, RM.rootq(g, root, z), SE.setc(K, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), g, True{}), c2, g, z, s2, zl, ST.TN{p, zr, s1}, Equal.trans(Bool, ST.rep(~K, ST.TN{g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}}, P.top(c2), SE.setc(K, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), g, True{})), ST.rep(~K, ST.TN{g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}}, P.top(c2), SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{})), True{}, SE.rep_setc(~K, ST.TN{g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}}, P.top(c2), SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), g, True{}), Equal.trans(Bool, ST.rep(~K, ST.TN{g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}}, P.top(c2), SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{})), ST.rep(~K, ST.TN{g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}}, P.top(c2), RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{})), True{}, SE.rep_setc(~K, ST.TN{g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}}, P.top(c2), RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), up_f(~K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}, P.top(c2), RP.rotr_path_rep(~K, ~cmp, ~o, nl, Con{P.FR{g, False{}, s2}, c2}, p, zl, z, zr, s1, up_t(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, s2}, c2}, p, nl), i2)), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, s2}, c2}, p, nl), i2), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), P.ids_l(Con{P.FR{g, False{}, s2}, c2}, p, ST.TN{z, zl, zr}, s1)), i3)), L.and_left(P.cok1(~K, P.FR{g, False{}, s2}, z, P.top(c2), RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{})), P.ctxok(~K, c2, g, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{})), RP.rotr_path_ctx(~K, ~cmp, ~o, nl, Con{P.FR{g, False{}, s2}, c2}, p, zl, z, zr, s1, up_t(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, s2}, c2}, p, nl), i2)), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, s2}, c2}, p, nl), i2), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), P.ids_l(Con{P.FR{g, False{}, s2}, c2}, p, ST.TN{z, zl, zr}, s1)), i3)))))), Equal.trans(Bool, P.ctxok(~K, c2, g, SE.setc(K, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), g, True{})), P.ctxok(~K, c2, g, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{})), True{}, SE.ctx_setc(~K, c2, g, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), g, True{}), Equal.trans(Bool, P.ctxok(~K, c2, g, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{})), P.ctxok(~K, c2, g, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{})), True{}, SE.ctx_setc(~K, c2, g, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), L.and_right(P.cok1(~K, P.FR{g, False{}, s2}, z, P.top(c2), RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{})), P.ctxok(~K, c2, g, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{})), RP.rotr_path_ctx(~K, ~cmp, ~o, nl, Con{P.FR{g, False{}, s2}, c2}, p, zl, z, zr, s1, up_t(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, s2}, c2}, p, nl), i2)), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, s2}, c2}, p, nl), i2), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), P.ids_l(Con{P.FR{g, False{}, s2}, c2}, p, ST.TN{z, zl, zr}, s1)), i3))))), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}}), P.after(c2))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{z, zl, ST.TN{p, zr, s1}}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), P.ids_r(c2, g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{z, zl, ST.TN{p, zr, s1}}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), RP.wh_eq(Con{P.FR{g, False{}, s2}, c2}, ST.TN{z, zl, ST.TN{p, zr, s1}}, ST.TN{p, ST.TN{z, zl, zr}, s1}, RP.ids_rr(p, z, zl, zr, s1)), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), P.ids_l(Con{P.FR{g, False{}, s2}, c2}, p, ST.TN{z, zl, zr}, s1)))))), i3), RP.root_rot(~K, nl, Con{P.FR{g, False{}, s2}, c2}, p, z, ST.TN{p, ST.TN{z, zl, zr}, s1}, ST.TN{z, zl, ST.TN{p, zr, s1}}, root, {==}, {==}, L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, s2}, c2}, p, nl), i2), i5), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), i0, Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{z, zl, ST.TN{p, zr, s1}}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), P.ids_r(c2, g, s2, ST.TN{z, zl, ST.TN{p, zr, s1}}), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{z, zl, ST.TN{p, zr, s1}}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), RP.wh_eq(Con{P.FR{g, False{}, s2}, c2}, ST.TN{z, zl, ST.TN{p, zr, s1}}, ST.TN{p, ST.TN{z, zl, zr}, s1}, RP.ids_rr(p, z, zl, zr, s1)), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, False{}, s2}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, s2}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, s2}, c2}}))), P.ids_l(Con{P.FR{g, False{}, s2}, c2}, p, ST.TN{z, zl, zr}, s1))))), i4), Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, SE.setc(K, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), g, True{}), pl), ST.ents(~K, ~V, i0, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), pl), e0, SE.ents_setc(~K, ~V, i0, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), pl, g, True{}), Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), pl), ST.ents(~K, ~V, i0, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), pl), e0, SE.ents_setc(~K, ~V, i0, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), pl, z, False{}), Equal.trans(List<&2, M.Entry>, ST.ents(~K, ~V, i0, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), pl), ST.ents(~K, ~V, i0, nl, pl), e0, RP.rotr_ents(~K, ~V, i0, pl, nl, p, z, ST.rid(zr), g, False{}), h4))), Equal.trans(Bool, EN.oks(~K, ~V, i0, SE.setc(K, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), g, True{}), pl), EN.oks(~K, ~V, i0, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), pl), True{}, SE.oks_setc(~K, ~V, i0, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), pl, g, True{}), Equal.trans(Bool, EN.oks(~K, ~V, i0, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), pl), EN.oks(~K, ~V, i0, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), pl), True{}, SE.oks_setc(~K, ~V, i0, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), pl, z, False{}), Equal.trans(Bool, EN.oks(~K, ~V, i0, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), pl), EN.oks(~K, ~V, i0, nl, pl), True{}, RP.rotr_oks(~K, ~V, i0, pl, nl, p, z, ST.rid(zr), g, False{}), h5))), Equal.trans(Bool, ST.fll(~K, SE.setc(K, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), g, True{}), fx), ST.fll(~K, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), fx), True{}, SE.fll_setc(~K, fx, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), g, True{}), Equal.trans(Bool, ST.fll(~K, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), fx), ST.fll(~K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), fx), True{}, SE.fll_setc(~K, fx, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), Equal.trans(Bool, ST.fll(~K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), fx), ST.fll(~K, nl, fx), True{}, RP.rotr_fll(~K, fx, nl, p, z, ST.rid(zr), g, False{}), h6))), Equal.trans(Nat, SC.length(M.Node, SE.setc(K, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), g, True{})), SC.length(M.Node, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{})), l0, SE.setc_len(K, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), g, True{}), Equal.trans(Nat, SC.length(M.Node, SE.setc(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{})), SC.length(M.Node, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{})), l0, SE.setc_len(K, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{}), z, False{}), Equal.trans(Nat, SC.length(M.Node, RM.rotr_nl(K, nl, p, z, ST.rid(zr), g, False{})), SC.length(M.Node, nl), l0, RP.rotr_len(~K, nl, p, z, ST.rid(zr), g, False{}), h7)))) # ---- the step's reads ---- def eq_pk(+x: Nat, +lft: Bool, +s: Nat, +h: {Bool.not(Nat.is_eq(x, s)) == True{} : Bool}) -> {Nat.is_eq(x, ST.pk(Nat, lft, x, s)) == lft : Bool}: match lft: case True{}: N.is_eq_refl(x) case False{}: NL.not_t_f(Nat.is_eq(x, s), h) def tri_r(+z: Nat, +lft: Bool, +s: Nat, +h: {Bool.not(Nat.is_eq(z, s)) == True{} : Bool}) -> {Nat.is_eq(z, ST.pk(Nat, lft, s, z)) == Bool.not(lft) : Bool}: match lft: case True{}: NL.not_t_f(Nat.is_eq(z, s), h) case False{}: N.is_eq_refl(z) def or_lt(+a: Bool, +b: Bool, +h: {a == True{} : Bool}) -> {Bool.or(a, b) == True{} : Bool}: L.subst(Bool, w => {Bool.or(w, b) == True{} : Bool}, True{}, a, Equal.sym(Bool, a, True{}, h), {==}) def or_f(+a: Bool, +h: {Bool.or(a, False{}) == True{} : Bool}) -> {a == True{} : Bool}: match a: case True{}: {==} case False{}: Empty.absurd({False{} == True{} : Bool}, L.false_true(h)) def u_left_t(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c2: List<&2, P.Fr>, +p: Nat, +s1: ST.Tr, +g: Nat, +u: Nat, +ua: ST.Tr, +ub: ST.Tr, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +un: M.Node, +hun: {ST.is_node(K, un, ST.rid(ua), ST.rid(ub), g) == True{} : Bool}, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, p, nl) == True{} : Bool}, +i2: {P.ctxok(~K, Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}})))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr})) : Nat}, +i6: {Bool.or(ST.root_black(~K, PG.plug(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr}), nl), False{}) == True{} : Bool}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}, kont: @+kr_: Nat -> @+kn_: List<&2, M.Node> -> @+kc_: List<&2, P.Fr> -> @+kz_: Nat -> @+kzl_: ST.Tr -> @+kzr_: ST.Tr -> @+ki1: {ST.rep(~K, ST.TN{kz_, kzl_, kzr_}, P.top(kc_), kn_) == True{} : Bool} -> @+ki2: {P.ctxok(~K, kc_, kz_, kn_) == True{} : Bool} -> @+ki3: {NL.nodupn(SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_)))) == True{} : Bool} -> @+ki4: {SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_))) == i0 : List<&2, Nat>} -> @+ki5: {kr_ == ST.rid(PG.plug(kc_, ST.TN{kz_, kzl_, kzr_})) : Nat} -> @+ki6: {Bool.or(ST.root_black(~K, PG.plug(kc_, ST.TN{kz_, kzl_, kzr_}), kn_), isnil(kc_)) == True{} : Bool} -> @+kh4: {ST.ents(~K, ~V, i0, kn_, pl) == e0 : List<&2, M.Entry>} -> @+kh5: {EN.oks(~K, ~V, i0, kn_, pl) == True{} : Bool} -> @+kh6: {ST.fll(~K, kn_, fx) == True{} : Bool} -> @+kh7: {SC.length(M.Node, kn_) == l0 : Nat} -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (ST.SH{n, kr_, lo, hi, free, l, d, kn_, pl, tg, fl}, M.Fix{kz_, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, u, Bool.not(True{}), un)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: match un: case M.Free{f}: Empty.absurd(Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, u, Bool.not(True{}), M.Free{f})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>, L.false_true(hun)) case M.N{True{}, x1, x2, x3, kk}: +eqW = Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, ST.TN{u, ua, ub}}), P.after(c2))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}))), P.ids_l(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, ST.TN{z, zl, zr}, s1)), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, ST.TN{u, ua, ub}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}))), P.ids_l(c2, g, ST.TN{p, ST.TN{z, zl, zr}, s1}, ST.TN{u, ua, ub}))) rc_go(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, g, ST.TN{p, ST.TN{z, zl, zr}, s1}, ST.TN{u, ua, ub}, p, u, up_t(~K, nl, g, ST.TN{u, ua, ub}, ST.TN{p, ST.TN{z, zl, zr}, s1}, P.top(c2), up_t(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)), L.and_left(P.cok1(~K, P.FR{g, True{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))), L.and_right(P.cok1(~K, P.FR{g, True{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, ST.TN{u, ua, ub}}), P.after(c2))), eqW, i3), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, ST.TN{u, ua, ub}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}))), i0, Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, ST.TN{z, zl, zr}, s1}, ST.TN{u, ua, ub}}), P.after(c2))), eqW), i4), i5, or_lt(ST.root_black(~K, PG.plug(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr}), nl), isnil(c2), or_f(ST.root_black(~K, PG.plug(Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr}), nl), i6)), DJ.mem_l(p, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), Con{g, ST.ids(ST.TN{u, ua, ub})}, P.mem_root(p, ST.TN{z, zl, zr}, s1)), DJ.mem_r(u, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), Con{g, ST.ids(ST.TN{u, ua, ub})}, DJ.mem_tl(u, g, ST.ids(ST.TN{u, ua, ub}), P.mem_root(u, ua, ub))), h4, h5, h6, h7, kont) case M.N{False{}, x1, x2, x3, kk}: bl_line(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, s1, g, ST.TN{u, ua, ub}, z, zl, zr, i1, i2, i3, i4, i5, h4, h5, h6, h7) def u_left_f(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c2: List<&2, P.Fr>, +p: Nat, +s1: ST.Tr, +g: Nat, +u: Nat, +ua: ST.Tr, +ub: ST.Tr, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +un: M.Node, +hun: {ST.is_node(K, un, ST.rid(ua), ST.rid(ub), g) == True{} : Bool}, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, p, nl) == True{} : Bool}, +i2: {P.ctxok(~K, Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}})))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr})) : Nat}, +i6: {Bool.or(ST.root_black(~K, PG.plug(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr}), nl), False{}) == True{} : Bool}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}, kont: @+kr_: Nat -> @+kn_: List<&2, M.Node> -> @+kc_: List<&2, P.Fr> -> @+kz_: Nat -> @+kzl_: ST.Tr -> @+kzr_: ST.Tr -> @+ki1: {ST.rep(~K, ST.TN{kz_, kzl_, kzr_}, P.top(kc_), kn_) == True{} : Bool} -> @+ki2: {P.ctxok(~K, kc_, kz_, kn_) == True{} : Bool} -> @+ki3: {NL.nodupn(SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_)))) == True{} : Bool} -> @+ki4: {SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_))) == i0 : List<&2, Nat>} -> @+ki5: {kr_ == ST.rid(PG.plug(kc_, ST.TN{kz_, kzl_, kzr_})) : Nat} -> @+ki6: {Bool.or(ST.root_black(~K, PG.plug(kc_, ST.TN{kz_, kzl_, kzr_}), kn_), isnil(kc_)) == True{} : Bool} -> @+kh4: {ST.ents(~K, ~V, i0, kn_, pl) == e0 : List<&2, M.Entry>} -> @+kh5: {EN.oks(~K, ~V, i0, kn_, pl) == True{} : Bool} -> @+kh6: {ST.fll(~K, kn_, fx) == True{} : Bool} -> @+kh7: {SC.length(M.Node, kn_) == l0 : Nat} -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (ST.SH{n, kr_, lo, hi, free, l, d, kn_, pl, tg, fl}, M.Fix{kz_, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, u, Bool.not(False{}), un)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: match un: case M.Free{f}: Empty.absurd(Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, u, Bool.not(False{}), M.Free{f})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>, L.false_true(hun)) case M.N{True{}, x1, x2, x3, kk}: +eqW = Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, s1, ST.TN{z, zl, zr}}, ST.TN{u, ua, ub}}), P.after(c2))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}))), P.ids_r(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, s1, ST.TN{z, zl, zr})), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, s1, ST.TN{z, zl, zr}}, ST.TN{u, ua, ub}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}))), P.ids_l(c2, g, ST.TN{p, s1, ST.TN{z, zl, zr}}, ST.TN{u, ua, ub}))) rc_go(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, g, ST.TN{p, s1, ST.TN{z, zl, zr}}, ST.TN{u, ua, ub}, p, u, up_t(~K, nl, g, ST.TN{u, ua, ub}, ST.TN{p, s1, ST.TN{z, zl, zr}}, P.top(c2), up_f(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)), L.and_left(P.cok1(~K, P.FR{g, True{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))), L.and_right(P.cok1(~K, P.FR{g, True{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, s1, ST.TN{z, zl, zr}}, ST.TN{u, ua, ub}}), P.after(c2))), eqW, i3), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, s1, ST.TN{z, zl, zr}}, ST.TN{u, ua, ub}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}))), i0, Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{p, s1, ST.TN{z, zl, zr}}, ST.TN{u, ua, ub}}), P.after(c2))), eqW), i4), i5, or_lt(ST.root_black(~K, PG.plug(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr}), nl), isnil(c2), or_f(ST.root_black(~K, PG.plug(Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr}), nl), i6)), DJ.mem_l(p, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), Con{g, ST.ids(ST.TN{u, ua, ub})}, P.mem_root(p, s1, ST.TN{z, zl, zr})), DJ.mem_r(u, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), Con{g, ST.ids(ST.TN{u, ua, ub})}, DJ.mem_tl(u, g, ST.ids(ST.TN{u, ua, ub}), P.mem_root(u, ua, ub))), h4, h5, h6, h7, kont) case M.N{False{}, x1, x2, x3, kk}: bl_tri(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, s1, g, ST.TN{u, ua, ub}, z, zl, zr, i1, i2, i3, i4, i5, h4, h5, h6, h7) def u_right_t(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c2: List<&2, P.Fr>, +p: Nat, +s1: ST.Tr, +g: Nat, +u: Nat, +ua: ST.Tr, +ub: ST.Tr, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +un: M.Node, +hun: {ST.is_node(K, un, ST.rid(ua), ST.rid(ub), g) == True{} : Bool}, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, p, nl) == True{} : Bool}, +i2: {P.ctxok(~K, Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}})))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr})) : Nat}, +i6: {Bool.or(ST.root_black(~K, PG.plug(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr}), nl), False{}) == True{} : Bool}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}, kont: @+kr_: Nat -> @+kn_: List<&2, M.Node> -> @+kc_: List<&2, P.Fr> -> @+kz_: Nat -> @+kzl_: ST.Tr -> @+kzr_: ST.Tr -> @+ki1: {ST.rep(~K, ST.TN{kz_, kzl_, kzr_}, P.top(kc_), kn_) == True{} : Bool} -> @+ki2: {P.ctxok(~K, kc_, kz_, kn_) == True{} : Bool} -> @+ki3: {NL.nodupn(SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_)))) == True{} : Bool} -> @+ki4: {SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_))) == i0 : List<&2, Nat>} -> @+ki5: {kr_ == ST.rid(PG.plug(kc_, ST.TN{kz_, kzl_, kzr_})) : Nat} -> @+ki6: {Bool.or(ST.root_black(~K, PG.plug(kc_, ST.TN{kz_, kzl_, kzr_}), kn_), isnil(kc_)) == True{} : Bool} -> @+kh4: {ST.ents(~K, ~V, i0, kn_, pl) == e0 : List<&2, M.Entry>} -> @+kh5: {EN.oks(~K, ~V, i0, kn_, pl) == True{} : Bool} -> @+kh6: {ST.fll(~K, kn_, fx) == True{} : Bool} -> @+kh7: {SC.length(M.Node, kn_) == l0 : Nat} -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (ST.SH{n, kr_, lo, hi, free, l, d, kn_, pl, tg, fl}, M.Fix{kz_, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, u, True{}, un)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: match un: case M.Free{f}: Empty.absurd(Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, u, True{}, M.Free{f})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>, L.false_true(hun)) case M.N{True{}, x1, x2, x3, kk}: +eqW = Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{u, ua, ub}, ST.TN{p, ST.TN{z, zl, zr}, s1}}), P.after(c2))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}))), P.ids_l(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, ST.TN{z, zl, zr}, s1)), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{u, ua, ub}, ST.TN{p, ST.TN{z, zl, zr}, s1}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}), SC.append(Nat, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.after(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}))), P.ids_r(c2, g, ST.TN{u, ua, ub}, ST.TN{p, ST.TN{z, zl, zr}, s1}))) rc_go(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, g, ST.TN{u, ua, ub}, ST.TN{p, ST.TN{z, zl, zr}, s1}, p, u, up_f(~K, nl, g, ST.TN{u, ua, ub}, ST.TN{p, ST.TN{z, zl, zr}, s1}, P.top(c2), up_t(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)), L.and_left(P.cok1(~K, P.FR{g, False{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))), L.and_right(P.cok1(~K, P.FR{g, False{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{u, ua, ub}, ST.TN{p, ST.TN{z, zl, zr}, s1}}), P.after(c2))), eqW, i3), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{u, ua, ub}, ST.TN{p, ST.TN{z, zl, zr}, s1}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}))), i0, Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{u, ua, ub}, ST.TN{p, ST.TN{z, zl, zr}, s1}}), P.after(c2))), eqW), i4), i5, or_lt(ST.root_black(~K, PG.plug(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr}), nl), isnil(c2), or_f(ST.root_black(~K, PG.plug(Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr}), nl), i6)), DJ.mem_r(p, ST.ids(ST.TN{u, ua, ub}), Con{g, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1})}, DJ.mem_tl(p, g, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1}), P.mem_root(p, ST.TN{z, zl, zr}, s1))), DJ.mem_l(u, ST.ids(ST.TN{u, ua, ub}), Con{g, ST.ids(ST.TN{p, ST.TN{z, zl, zr}, s1})}, P.mem_root(u, ua, ub)), h4, h5, h6, h7, kont) case M.N{False{}, x1, x2, x3, kk}: br_tri(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, s1, g, ST.TN{u, ua, ub}, z, zl, zr, i1, i2, i3, i4, i5, h4, h5, h6, h7) def u_right_f(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c2: List<&2, P.Fr>, +p: Nat, +s1: ST.Tr, +g: Nat, +u: Nat, +ua: ST.Tr, +ub: ST.Tr, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +un: M.Node, +hun: {ST.is_node(K, un, ST.rid(ua), ST.rid(ub), g) == True{} : Bool}, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, p, nl) == True{} : Bool}, +i2: {P.ctxok(~K, Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}})))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr})) : Nat}, +i6: {Bool.or(ST.root_black(~K, PG.plug(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr}), nl), False{}) == True{} : Bool}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}, kont: @+kr_: Nat -> @+kn_: List<&2, M.Node> -> @+kc_: List<&2, P.Fr> -> @+kz_: Nat -> @+kzl_: ST.Tr -> @+kzr_: ST.Tr -> @+ki1: {ST.rep(~K, ST.TN{kz_, kzl_, kzr_}, P.top(kc_), kn_) == True{} : Bool} -> @+ki2: {P.ctxok(~K, kc_, kz_, kn_) == True{} : Bool} -> @+ki3: {NL.nodupn(SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_)))) == True{} : Bool} -> @+ki4: {SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_))) == i0 : List<&2, Nat>} -> @+ki5: {kr_ == ST.rid(PG.plug(kc_, ST.TN{kz_, kzl_, kzr_})) : Nat} -> @+ki6: {Bool.or(ST.root_black(~K, PG.plug(kc_, ST.TN{kz_, kzl_, kzr_}), kn_), isnil(kc_)) == True{} : Bool} -> @+kh4: {ST.ents(~K, ~V, i0, kn_, pl) == e0 : List<&2, M.Entry>} -> @+kh5: {EN.oks(~K, ~V, i0, kn_, pl) == True{} : Bool} -> @+kh6: {ST.fll(~K, kn_, fx) == True{} : Bool} -> @+kh7: {SC.length(M.Node, kn_) == l0 : Nat} -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (ST.SH{n, kr_, lo, hi, free, l, d, kn_, pl, tg, fl}, M.Fix{kz_, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, u, False{}, un)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: match un: case M.Free{f}: Empty.absurd(Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, u, False{}, M.Free{f})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>, L.false_true(hun)) case M.N{True{}, x1, x2, x3, kk}: +eqW = Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}))), SC.append(Nat, P.before(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{u, ua, ub}, ST.TN{p, s1, ST.TN{z, zl, zr}}}), P.after(c2))), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}))), P.ids_r(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, s1, ST.TN{z, zl, zr})), Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{u, ua, ub}, ST.TN{p, s1, ST.TN{z, zl, zr}}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}), SC.append(Nat, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.after(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}))), P.ids_r(c2, g, ST.TN{u, ua, ub}, ST.TN{p, s1, ST.TN{z, zl, zr}}))) rc_go(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, g, ST.TN{u, ua, ub}, ST.TN{p, s1, ST.TN{z, zl, zr}}, p, u, up_f(~K, nl, g, ST.TN{u, ua, ub}, ST.TN{p, s1, ST.TN{z, zl, zr}}, P.top(c2), up_f(~K, nl, p, s1, ST.TN{z, zl, zr}, g, i1, L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)), L.and_left(P.cok1(~K, P.FR{g, False{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))), L.and_right(P.cok1(~K, P.FR{g, False{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)), L.subst(List<&2, Nat>, zz => {NL.nodupn(zz) == True{} : Bool}, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{u, ua, ub}, ST.TN{p, s1, ST.TN{z, zl, zr}}}), P.after(c2))), eqW, i3), Equal.trans(List<&2, Nat>, SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{u, ua, ub}, ST.TN{p, s1, ST.TN{z, zl, zr}}}), P.after(c2))), SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}))), i0, Equal.sym(List<&2, Nat>, SC.append(Nat, P.before(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}))), SC.append(Nat, P.before(c2), SC.append(Nat, ST.ids(ST.TN{g, ST.TN{u, ua, ub}, ST.TN{p, s1, ST.TN{z, zl, zr}}}), P.after(c2))), eqW), i4), i5, or_lt(ST.root_black(~K, PG.plug(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr}), nl), isnil(c2), or_f(ST.root_black(~K, PG.plug(Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, ST.TN{z, zl, zr}), nl), i6)), DJ.mem_r(p, ST.ids(ST.TN{u, ua, ub}), Con{g, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}})}, DJ.mem_tl(p, g, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}}), P.mem_root(p, s1, ST.TN{z, zl, zr}))), DJ.mem_l(u, ST.ids(ST.TN{u, ua, ub}), Con{g, ST.ids(ST.TN{p, s1, ST.TN{z, zl, zr}})}, P.mem_root(u, ua, ub)), h4, h5, h6, h7, kont) case M.N{False{}, x1, x2, x3, kk}: br_line(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, s1, g, ST.TN{u, ua, ub}, z, zl, zr, i1, i2, i3, i4, i5, h4, h5, h6, h7) # ---- the grandparent and the side ---- def grand(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c2: List<&2, P.Fr>, +p: Nat, +l1: Bool, +s1: ST.Tr, +g: Nat, +l2: Bool, +s2: ST.Tr, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, p, nl) == True{} : Bool}, +i2: {P.ctxok(~K, Con{P.FR{p, l1, s1}, Con{P.FR{g, l2, s2}, c2}}, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(Con{P.FR{p, l1, s1}, Con{P.FR{g, l2, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, l1, s1}, Con{P.FR{g, l2, s2}, c2}})))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(Con{P.FR{p, l1, s1}, Con{P.FR{g, l2, s2}, c2}}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, l1, s1}, Con{P.FR{g, l2, s2}, c2}}))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(Con{P.FR{p, l1, s1}, Con{P.FR{g, l2, s2}, c2}}, ST.TN{z, zl, zr})) : Nat}, +i6: {Bool.or(ST.root_black(~K, PG.plug(Con{P.FR{p, l1, s1}, Con{P.FR{g, l2, s2}, c2}}, ST.TN{z, zl, zr}), nl), False{}) == True{} : Bool}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}, kont: @+kr_: Nat -> @+kn_: List<&2, M.Node> -> @+kc_: List<&2, P.Fr> -> @+kz_: Nat -> @+kzl_: ST.Tr -> @+kzr_: ST.Tr -> @+ki1: {ST.rep(~K, ST.TN{kz_, kzl_, kzr_}, P.top(kc_), kn_) == True{} : Bool} -> @+ki2: {P.ctxok(~K, kc_, kz_, kn_) == True{} : Bool} -> @+ki3: {NL.nodupn(SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_)))) == True{} : Bool} -> @+ki4: {SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_))) == i0 : List<&2, Nat>} -> @+ki5: {kr_ == ST.rid(PG.plug(kc_, ST.TN{kz_, kzl_, kzr_})) : Nat} -> @+ki6: {Bool.or(ST.root_black(~K, PG.plug(kc_, ST.TN{kz_, kzl_, kzr_}), kn_), isnil(kc_)) == True{} : Bool} -> @+kh4: {ST.ents(~K, ~V, i0, kn_, pl) == e0 : List<&2, M.Entry>} -> @+kh5: {EN.oks(~K, ~V, i0, kn_, pl) == True{} : Bool} -> @+kh6: {ST.fll(~K, kn_, fx) == True{} : Bool} -> @+kh7: {SC.length(M.Node, kn_) == l0 : Nat} -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (ST.SH{n, kr_, lo, hi, free, l, d, kn_, pl, tg, fl}, M.Fix{kz_, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_grand(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, ST.nd(K, nl, p))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: match l1 l2 s2: case True{} True{} ST.TE{}: %Equal.sym(Nat, M.node_parent(~K, ST.nd(K, nl, p)), g, NB.parent_eq(~K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TE{}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, _, ST.nd(K, nl, p), ST.nd(K, nl, _), Nat.is_eq(p, M.node_left(~K, ST.nd(K, nl, _))))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, g)), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), RP.f_left(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), ST.pk(Nat, True{}, ST.rid(ST.TE{}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), ST.pk(Nat, True{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), ST.pk(Nat, True{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, True{}, ST.TE{}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TE{}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), Nat.is_eq(p, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(p, ST.pk(Nat, True{}, p, ST.rid(ST.TE{}))), True{}, eq_pk(p, True{}, ST.rid(ST.TE{}), L.and_left(Bool.not(Nat.is_eq(p, ST.rid(ST.TE{}))), P.dist(c2, g), L.and_right(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, True{}, ST.TE{}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TE{}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), _)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_right(~K, ST.nd(K, nl, g)), ST.rid(ST.TE{}), RP.f_right(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), ST.pk(Nat, True{}, ST.rid(ST.TE{}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), ST.pk(Nat, True{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), ST.pk(Nat, True{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, True{}, ST.TE{}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TE{}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, _, Nat.is_eq(z, M.node_right(~K, ST.nd(K, nl, p))), ST.nd(K, nl, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_right(~K, ST.nd(K, nl, p)), ST.pk(Nat, True{}, ST.rid(s1), z), RP.f_right(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TE{}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TE{}), Nat.is_eq(z, _), ST.nd(K, nl, ST.rid(ST.TE{})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(z, ST.pk(Nat, True{}, ST.rid(s1), z)), Bool.not(True{}), tri_r(z, True{}, ST.rid(s1), L.and_left(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, True{}, ST.TE{}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TE{}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3)))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TE{}), _, ST.nd(K, nl, ST.rid(ST.TE{})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> bl_line(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, s1, g, ST.TE{}, z, zl, zr, i1, i2, i3, i4, i5, h4, h5, h6, h7) case True{} True{} ST.TN{+u, +ua, +ub}: %Equal.sym(Nat, M.node_parent(~K, ST.nd(K, nl, p)), g, NB.parent_eq(~K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, _, ST.nd(K, nl, p), ST.nd(K, nl, _), Nat.is_eq(p, M.node_left(~K, ST.nd(K, nl, _))))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, g)), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), RP.f_left(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, True{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), Nat.is_eq(p, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(p, ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub}))), True{}, eq_pk(p, True{}, ST.rid(ST.TN{u, ua, ub}), L.and_left(Bool.not(Nat.is_eq(p, ST.rid(ST.TN{u, ua, ub}))), P.dist(c2, g), L.and_right(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), _)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_right(~K, ST.nd(K, nl, g)), ST.rid(ST.TN{u, ua, ub}), RP.f_right(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, True{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, _, Nat.is_eq(z, M.node_right(~K, ST.nd(K, nl, p))), ST.nd(K, nl, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_right(~K, ST.nd(K, nl, p)), ST.pk(Nat, True{}, ST.rid(s1), z), RP.f_right(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TN{u, ua, ub}), Nat.is_eq(z, _), ST.nd(K, nl, ST.rid(ST.TN{u, ua, ub})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(z, ST.pk(Nat, True{}, ST.rid(s1), z)), Bool.not(True{}), tri_r(z, True{}, ST.rid(s1), L.and_left(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, True{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3)))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TN{u, ua, ub}), _, ST.nd(K, nl, ST.rid(ST.TN{u, ua, ub})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> u_left_t(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, s1, g, u, ua, ub, z, zl, zr, ST.nd(K, nl, u), TR.rep_node(~K, u, ua, ub, g, nl, L.and_right(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, True{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))))), i1, i2, i3, i4, i5, i6, h4, h5, h6, h7, kont) case True{} False{} ST.TE{}: %Equal.sym(Nat, M.node_parent(~K, ST.nd(K, nl, p)), g, NB.parent_eq(~K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TE{}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, _, ST.nd(K, nl, p), ST.nd(K, nl, _), Nat.is_eq(p, M.node_left(~K, ST.nd(K, nl, _))))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, g)), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), RP.f_left(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), ST.pk(Nat, False{}, ST.rid(ST.TE{}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), ST.pk(Nat, False{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), ST.pk(Nat, False{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, False{}, ST.TE{}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TE{}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), Nat.is_eq(p, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(p, ST.pk(Nat, False{}, p, ST.rid(ST.TE{}))), False{}, eq_pk(p, False{}, ST.rid(ST.TE{}), L.and_left(Bool.not(Nat.is_eq(p, ST.rid(ST.TE{}))), P.dist(c2, g), L.and_right(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, False{}, ST.TE{}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TE{}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), _)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, g)), ST.rid(ST.TE{}), RP.f_left(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), ST.pk(Nat, False{}, ST.rid(ST.TE{}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), ST.pk(Nat, False{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), ST.pk(Nat, False{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, False{}, ST.TE{}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TE{}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, _, Nat.is_eq(z, M.node_left(~K, ST.nd(K, nl, p))), ST.nd(K, nl, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, p)), ST.pk(Nat, True{}, z, ST.rid(s1)), RP.f_left(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TE{}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TE{}), Nat.is_eq(z, _), ST.nd(K, nl, ST.rid(ST.TE{})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(z, ST.pk(Nat, True{}, z, ST.rid(s1))), True{}, eq_pk(z, True{}, ST.rid(s1), L.and_left(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, False{}, ST.TE{}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TE{}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3)))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TE{}), _, ST.nd(K, nl, ST.rid(ST.TE{})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> br_tri(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, s1, g, ST.TE{}, z, zl, zr, i1, i2, i3, i4, i5, h4, h5, h6, h7) case True{} False{} ST.TN{+u, +ua, +ub}: %Equal.sym(Nat, M.node_parent(~K, ST.nd(K, nl, p)), g, NB.parent_eq(~K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, _, ST.nd(K, nl, p), ST.nd(K, nl, _), Nat.is_eq(p, M.node_left(~K, ST.nd(K, nl, _))))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, g)), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), RP.f_left(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, False{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), Nat.is_eq(p, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(p, ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub}))), False{}, eq_pk(p, False{}, ST.rid(ST.TN{u, ua, ub}), L.and_left(Bool.not(Nat.is_eq(p, ST.rid(ST.TN{u, ua, ub}))), P.dist(c2, g), L.and_right(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), _)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, g)), ST.rid(ST.TN{u, ua, ub}), RP.f_left(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, False{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, _, Nat.is_eq(z, M.node_left(~K, ST.nd(K, nl, p))), ST.nd(K, nl, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, p)), ST.pk(Nat, True{}, z, ST.rid(s1)), RP.f_left(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, True{}, z, ST.rid(s1)), ST.pk(Nat, True{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TN{u, ua, ub}), Nat.is_eq(z, _), ST.nd(K, nl, ST.rid(ST.TN{u, ua, ub})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(z, ST.pk(Nat, True{}, z, ST.rid(s1))), True{}, eq_pk(z, True{}, ST.rid(s1), L.and_left(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, True{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3)))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TN{u, ua, ub}), _, ST.nd(K, nl, ST.rid(ST.TN{u, ua, ub})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> u_right_t(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, s1, g, u, ua, ub, z, zl, zr, ST.nd(K, nl, u), TR.rep_node(~K, u, ua, ub, g, nl, L.and_right(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, False{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, True{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))))), i1, i2, i3, i4, i5, i6, h4, h5, h6, h7, kont) case False{} True{} ST.TE{}: %Equal.sym(Nat, M.node_parent(~K, ST.nd(K, nl, p)), g, NB.parent_eq(~K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TE{}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, _, ST.nd(K, nl, p), ST.nd(K, nl, _), Nat.is_eq(p, M.node_left(~K, ST.nd(K, nl, _))))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, g)), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), RP.f_left(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), ST.pk(Nat, True{}, ST.rid(ST.TE{}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), ST.pk(Nat, True{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), ST.pk(Nat, True{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, True{}, ST.TE{}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TE{}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), Nat.is_eq(p, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(p, ST.pk(Nat, True{}, p, ST.rid(ST.TE{}))), True{}, eq_pk(p, True{}, ST.rid(ST.TE{}), L.and_left(Bool.not(Nat.is_eq(p, ST.rid(ST.TE{}))), P.dist(c2, g), L.and_right(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, True{}, ST.TE{}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TE{}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), _)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_right(~K, ST.nd(K, nl, g)), ST.rid(ST.TE{}), RP.f_right(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), ST.pk(Nat, True{}, ST.rid(ST.TE{}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), ST.pk(Nat, True{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TE{})), ST.pk(Nat, True{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, True{}, ST.TE{}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TE{}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, _, Nat.is_eq(z, M.node_right(~K, ST.nd(K, nl, p))), ST.nd(K, nl, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_right(~K, ST.nd(K, nl, p)), ST.pk(Nat, False{}, ST.rid(s1), z), RP.f_right(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TE{}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TE{}), Nat.is_eq(z, _), ST.nd(K, nl, ST.rid(ST.TE{})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(z, ST.pk(Nat, False{}, ST.rid(s1), z)), Bool.not(False{}), tri_r(z, False{}, ST.rid(s1), L.and_left(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, True{}, ST.TE{}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TE{}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3)))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TE{}), _, ST.nd(K, nl, ST.rid(ST.TE{})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> bl_tri(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, s1, g, ST.TE{}, z, zl, zr, i1, i2, i3, i4, i5, h4, h5, h6, h7) case False{} True{} ST.TN{+u, +ua, +ub}: %Equal.sym(Nat, M.node_parent(~K, ST.nd(K, nl, p)), g, NB.parent_eq(~K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, _, ST.nd(K, nl, p), ST.nd(K, nl, _), Nat.is_eq(p, M.node_left(~K, ST.nd(K, nl, _))))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, g)), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), RP.f_left(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, True{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), Nat.is_eq(p, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(p, ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub}))), True{}, eq_pk(p, True{}, ST.rid(ST.TN{u, ua, ub}), L.and_left(Bool.not(Nat.is_eq(p, ST.rid(ST.TN{u, ua, ub}))), P.dist(c2, g), L.and_right(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), _)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_right(~K, ST.nd(K, nl, g)), ST.rid(ST.TN{u, ua, ub}), RP.f_right(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, True{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, _, Nat.is_eq(z, M.node_right(~K, ST.nd(K, nl, p))), ST.nd(K, nl, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_right(~K, ST.nd(K, nl, p)), ST.pk(Nat, False{}, ST.rid(s1), z), RP.f_right(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TN{u, ua, ub}), Nat.is_eq(z, _), ST.nd(K, nl, ST.rid(ST.TN{u, ua, ub})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(z, ST.pk(Nat, False{}, ST.rid(s1), z)), Bool.not(False{}), tri_r(z, False{}, ST.rid(s1), L.and_left(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, False{}, s1}, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3)))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_left(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TN{u, ua, ub}), _, ST.nd(K, nl, ST.rid(ST.TN{u, ua, ub})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> u_left_f(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, s1, g, u, ua, ub, z, zl, zr, ST.nd(K, nl, u), TR.rep_node(~K, u, ua, ub, g, nl, L.and_right(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, True{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, True{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, True{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, True{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))))), i1, i2, i3, i4, i5, i6, h4, h5, h6, h7, kont) case False{} False{} ST.TE{}: %Equal.sym(Nat, M.node_parent(~K, ST.nd(K, nl, p)), g, NB.parent_eq(~K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TE{}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, _, ST.nd(K, nl, p), ST.nd(K, nl, _), Nat.is_eq(p, M.node_left(~K, ST.nd(K, nl, _))))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, g)), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), RP.f_left(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), ST.pk(Nat, False{}, ST.rid(ST.TE{}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), ST.pk(Nat, False{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), ST.pk(Nat, False{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, False{}, ST.TE{}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TE{}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), Nat.is_eq(p, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(p, ST.pk(Nat, False{}, p, ST.rid(ST.TE{}))), False{}, eq_pk(p, False{}, ST.rid(ST.TE{}), L.and_left(Bool.not(Nat.is_eq(p, ST.rid(ST.TE{}))), P.dist(c2, g), L.and_right(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, False{}, ST.TE{}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TE{}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), _)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, g)), ST.rid(ST.TE{}), RP.f_left(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), ST.pk(Nat, False{}, ST.rid(ST.TE{}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), ST.pk(Nat, False{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TE{})), ST.pk(Nat, False{}, ST.rid(ST.TE{}), p), P.top(c2)), ST.rep(~K, ST.TE{}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, False{}, ST.TE{}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TE{}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, _, Nat.is_eq(z, M.node_left(~K, ST.nd(K, nl, p))), ST.nd(K, nl, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, p)), ST.pk(Nat, False{}, z, ST.rid(s1)), RP.f_left(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TE{}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TE{}), Nat.is_eq(z, _), ST.nd(K, nl, ST.rid(ST.TE{})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(z, ST.pk(Nat, False{}, z, ST.rid(s1))), False{}, eq_pk(z, False{}, ST.rid(s1), L.and_left(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, False{}, ST.TE{}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TE{}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3)))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TE{}), _, ST.nd(K, nl, ST.rid(ST.TE{})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> br_line(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, s1, g, ST.TE{}, z, zl, zr, i1, i2, i3, i4, i5, h4, h5, h6, h7) case False{} False{} ST.TN{+u, +ua, +ub}: %Equal.sym(Nat, M.node_parent(~K, ST.nd(K, nl, p)), g, NB.parent_eq(~K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, _, ST.nd(K, nl, p), ST.nd(K, nl, _), Nat.is_eq(p, M.node_left(~K, ST.nd(K, nl, _))))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, g)), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), RP.f_left(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, False{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), Nat.is_eq(p, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(p, ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub}))), False{}, eq_pk(p, False{}, ST.rid(ST.TN{u, ua, ub}), L.and_left(Bool.not(Nat.is_eq(p, ST.rid(ST.TN{u, ua, ub}))), P.dist(c2, g), L.and_right(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_side(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.nd(K, nl, p), ST.nd(K, nl, g), _)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, g)), ST.rid(ST.TN{u, ua, ub}), RP.f_left(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2), L.and_left(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, False{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2)))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, _, Nat.is_eq(z, M.node_left(~K, ST.nd(K, nl, p))), ST.nd(K, nl, _))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Nat, M.node_left(~K, ST.nd(K, nl, p)), ST.pk(Nat, False{}, z, ST.rid(s1)), RP.f_left(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g, L.and_left(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl), L.and_right(Nat.is_lt(0n, p), Bool.and(ST.is_node(K, ST.nd(K, nl, p), ST.pk(Nat, False{}, z, ST.rid(s1)), ST.pk(Nat, False{}, ST.rid(s1), z), g), ST.rep(~K, s1, p, nl)), L.and_left(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TN{u, ua, ub}), Nat.is_eq(z, _), ST.nd(K, nl, ST.rid(ST.TN{u, ua, ub})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> %Equal.sym(Bool, Nat.is_eq(z, ST.pk(Nat, False{}, z, ST.rid(s1))), False{}, eq_pk(z, False{}, ST.rid(s1), L.and_left(Bool.not(Nat.is_eq(z, ST.rid(s1))), P.dist(Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p), P.nd_dist(~K, nl, Con{P.FR{p, False{}, s1}, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}}, z, zl, zr, L.and_left(Nat.is_lt(0n, z), Bool.and(ST.is_node(K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p), Bool.and(ST.rep(~K, zl, z, nl), ST.rep(~K, zr, z, nl))), i1), i2, i3)))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_uncle_right(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, g, ST.rid(ST.TN{u, ua, ub}), _, ST.nd(K, nl, ST.rid(ST.TN{u, ua, ub})))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> u_right_f(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, s1, g, u, ua, ub, z, zl, zr, ST.nd(K, nl, u), TR.rep_node(~K, u, ua, ub, g, nl, L.and_right(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl), L.and_right(Nat.is_lt(0n, g), Bool.and(ST.is_node(K, ST.nd(K, nl, g), ST.pk(Nat, False{}, p, ST.rid(ST.TN{u, ua, ub})), ST.pk(Nat, False{}, ST.rid(ST.TN{u, ua, ub}), p), P.top(c2)), ST.rep(~K, ST.TN{u, ua, ub}, g, nl)), L.and_left(P.cok1(~K, P.FR{g, False{}, ST.TN{u, ua, ub}}, p, P.top(c2), nl), P.ctxok(~K, c2, g, nl), L.and_right(P.cok1(~K, P.FR{p, False{}, s1}, z, g, nl), P.ctxok(~K, Con{P.FR{g, False{}, ST.TN{u, ua, ub}}, c2}, p, nl), i2))))), i1, i2, i3, i4, i5, i6, h4, h5, h6, h7, kont) # ---- the parent's colour ---- def rid_p1(+p: Nat, +l1: Bool, +s1: ST.Tr, +t: ST.Tr) -> {ST.rid(PG.plug(Con{P.FR{p, l1, s1}, Nil{}}, t)) == p : Nat}: match l1: case True{}: {==} case False{}: {==} def parent(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +p: Nat, +l1: Bool, +s1: ST.Tr, +c1: List<&2, P.Fr>, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, p, nl) == True{} : Bool}, +i2: {P.ctxok(~K, Con{P.FR{p, l1, s1}, c1}, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(Con{P.FR{p, l1, s1}, c1}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, l1, s1}, c1})))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(Con{P.FR{p, l1, s1}, c1}), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(Con{P.FR{p, l1, s1}, c1}))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(Con{P.FR{p, l1, s1}, c1}, ST.TN{z, zl, zr})) : Nat}, +i6: {Bool.or(ST.root_black(~K, PG.plug(Con{P.FR{p, l1, s1}, c1}, ST.TN{z, zl, zr}), nl), False{}) == True{} : Bool}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}, kont: @+kr_: Nat -> @+kn_: List<&2, M.Node> -> @+kc_: List<&2, P.Fr> -> @+kz_: Nat -> @+kzl_: ST.Tr -> @+kzr_: ST.Tr -> @+ki1: {ST.rep(~K, ST.TN{kz_, kzl_, kzr_}, P.top(kc_), kn_) == True{} : Bool} -> @+ki2: {P.ctxok(~K, kc_, kz_, kn_) == True{} : Bool} -> @+ki3: {NL.nodupn(SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_)))) == True{} : Bool} -> @+ki4: {SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_))) == i0 : List<&2, Nat>} -> @+ki5: {kr_ == ST.rid(PG.plug(kc_, ST.TN{kz_, kzl_, kzr_})) : Nat} -> @+ki6: {Bool.or(ST.root_black(~K, PG.plug(kc_, ST.TN{kz_, kzl_, kzr_}), kn_), isnil(kc_)) == True{} : Bool} -> @+kh4: {ST.ents(~K, ~V, i0, kn_, pl) == e0 : List<&2, M.Entry>} -> @+kh5: {EN.oks(~K, ~V, i0, kn_, pl) == True{} : Bool} -> @+kh6: {ST.fll(~K, kn_, fx) == True{} : Bool} -> @+kh7: {SC.length(M.Node, kn_) == l0 : Nat} -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (ST.SH{n, kr_, lo, hi, free, l, d, kn_, pl, tg, fl}, M.Fix{kz_, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>, +b: Bool, +hb: {M.node_red(~K, ST.nd(K, nl, p)) == b : Bool}) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_parent(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, ST.nd(K, nl, p), b)) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: match c1 b: case +c1 False{}: fi_stop(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, Con{P.FR{p, l1, s1}, c1}, z, zl, zr, i1, i2, i3, i4, i5, i6, h4, h5, h6, h7) case Nil{} True{}: +er = rid_p1(p, l1, s1, ST.TN{z, zl, zr}) +e1 = Equal.trans(Bool, ST.root_black(~K, PG.plug(Con{P.FR{p, l1, s1}, Nil{}}, ST.TN{z, zl, zr}), nl), Bool.not(ST.is_red(K, ST.nd(K, nl, ST.rid(PG.plug(Con{P.FR{p, l1, s1}, Nil{}}, ST.TN{z, zl, zr}))))), Bool.not(ST.is_red(K, ST.nd(K, nl, p))), rb_rid(~K, PG.plug(Con{P.FR{p, l1, s1}, Nil{}}, ST.TN{z, zl, zr}), nl), L.subst(Nat, w => {Bool.not(ST.is_red(K, ST.nd(K, nl, ST.rid(PG.plug(Con{P.FR{p, l1, s1}, Nil{}}, ST.TN{z, zl, zr}))))) == Bool.not(ST.is_red(K, ST.nd(K, nl, w))) : Bool}, ST.rid(PG.plug(Con{P.FR{p, l1, s1}, Nil{}}, ST.TN{z, zl, zr})), p, er, {==})) +e2 = Equal.trans(Bool, ST.is_red(K, ST.nd(K, nl, p)), M.node_red(~K, ST.nd(K, nl, p)), True{}, Equal.sym(Bool, M.node_red(~K, ST.nd(K, nl, p)), ST.is_red(K, ST.nd(K, nl, p)), red_eq(K, ST.nd(K, nl, p))), hb) +e3 = L.subst(Bool, w => {ST.root_black(~K, PG.plug(Con{P.FR{p, l1, s1}, Nil{}}, ST.TN{z, zl, zr}), nl) == Bool.not(w) : Bool}, ST.is_red(K, ST.nd(K, nl, p)), True{}, e2, e1) Empty.absurd(Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_parent(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, p, ST.nd(K, nl, p), True{})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>, L.false_true(L.subst(Bool, w => {Bool.or(w, False{}) == True{} : Bool}, ST.root_black(~K, PG.plug(Con{P.FR{p, l1, s1}, Nil{}}, ST.TN{z, zl, zr}), nl), False{}, e3, i6))) case Con{P.FR{+g, +l2, +s2}, +c2} True{}: grand(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, c2, p, l1, s1, g, l2, s2, z, zl, zr, i1, i2, i3, i4, i5, i6, h4, h5, h6, h7, kont) # ---- a step, and the loop ---- def step(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c: List<&2, P.Fr>, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, P.top(c), nl) == True{} : Bool}, +i2: {P.ctxok(~K, c, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(c)))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(c))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(c, ST.TN{z, zl, zr})) : Nat}, +i6: {Bool.or(ST.root_black(~K, PG.plug(c, ST.TN{z, zl, zr}), nl), isnil(c)) == True{} : Bool}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}, kont: @+kr_: Nat -> @+kn_: List<&2, M.Node> -> @+kc_: List<&2, P.Fr> -> @+kz_: Nat -> @+kzl_: ST.Tr -> @+kzr_: ST.Tr -> @+ki1: {ST.rep(~K, ST.TN{kz_, kzl_, kzr_}, P.top(kc_), kn_) == True{} : Bool} -> @+ki2: {P.ctxok(~K, kc_, kz_, kn_) == True{} : Bool} -> @+ki3: {NL.nodupn(SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_)))) == True{} : Bool} -> @+ki4: {SC.append(Nat, P.before(kc_), SC.append(Nat, ST.ids(ST.TN{kz_, kzl_, kzr_}), P.after(kc_))) == i0 : List<&2, Nat>} -> @+ki5: {kr_ == ST.rid(PG.plug(kc_, ST.TN{kz_, kzl_, kzr_})) : Nat} -> @+ki6: {Bool.or(ST.root_black(~K, PG.plug(kc_, ST.TN{kz_, kzl_, kzr_}), kn_), isnil(kc_)) == True{} : Bool} -> @+kh4: {ST.ents(~K, ~V, i0, kn_, pl) == e0 : List<&2, M.Entry>} -> @+kh5: {EN.oks(~K, ~V, i0, kn_, pl) == True{} : Bool} -> @+kh6: {ST.fll(~K, kn_, fx) == True{} : Bool} -> @+kh7: {SC.length(M.Node, kn_) == l0 : Nat} -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (ST.SH{n, kr_, lo, hi, free, l, d, kn_, pl, tg, fl}, M.Fix{kz_, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, 1n+gf, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, M.Fix{z, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: match c: case Nil{}: %Equal.sym(Nat, M.node_parent(~K, ST.nd(K, nl, z)), 0n, NB.parent_eq(~K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), 0n, TR.rep_node(~K, z, zl, zr, 0n, nl, i1))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_parent(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, _, ST.nd(K, nl, _), M.node_red(~K, ST.nd(K, nl, _)))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> fi_stop(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, Nil{}, z, zl, zr, i1, i2, i3, i4, i5, i6, h4, h5, h6, h7) case Con{P.FR{+p, +l1, +s1}, +c1}: %Equal.sym(Nat, M.node_parent(~K, ST.nd(K, nl, z)), p, NB.parent_eq(~K, ST.nd(K, nl, z), ST.rid(zl), ST.rid(zr), p, TR.rep_node(~K, z, zl, zr, p, nl, i1))) : Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, MI.insert_parent(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, z, _, ST.nd(K, nl, _), M.node_red(~K, ST.nd(K, nl, _)))) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>> parent(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, gf, root, nl, p, l1, s1, c1, z, zl, zr, i1, i2, i3, i4, i5, i6, h4, h5, h6, h7, kont, M.node_red(~K, ST.nd(K, nl, p)), {==}) # from a red node the path leads to, the loop ends with the ghost tree's # properties, whatever its fuel def loop(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~o: O.Order(~K, ~cmp), +n: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +pl: List<&2, Maybe<&2, V>>, +tg: ST.Tr, +fl: List<&2, Nat>, +fx: List<&2, Nat>, +i0: List<&2, Nat>, +e0: List<&2, M.Entry>, +l0: Nat, +gf: Nat, +root: Nat, +nl: List<&2, M.Node>, +c: List<&2, P.Fr>, +z: Nat, +zl: ST.Tr, +zr: ST.Tr, +i1: {ST.rep(~K, ST.TN{z, zl, zr}, P.top(c), nl) == True{} : Bool}, +i2: {P.ctxok(~K, c, z, nl) == True{} : Bool}, +i3: {NL.nodupn(SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(c)))) == True{} : Bool}, +i4: {SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(c))) == i0 : List<&2, Nat>}, +i5: {root == ST.rid(PG.plug(c, ST.TN{z, zl, zr})) : Nat}, +i6: {Bool.or(ST.root_black(~K, PG.plug(c, ST.TN{z, zl, zr}), nl), isnil(c)) == True{} : Bool}, +h4: {ST.ents(~K, ~V, i0, nl, pl) == e0 : List<&2, M.Entry>}, +h5: {EN.oks(~K, ~V, i0, nl, pl) == True{} : Bool}, +h6: {ST.fll(~K, nl, fx) == True{} : Bool}, +h7: {SC.length(M.Node, nl) == l0 : Nat}) -> Sigma<&1, &1, Nat, fr_ => Sigma<&1, &1, List<&2, M.Node>, fn_ => Sigma<&1, &1, ST.Tr, ft_ => {MI.insert_fix_loop(~K, ~V, ~cmp, gf, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, tg, fl}, M.Fix{z, True{}})) == ST.SH{n, fr_, lo, hi, free, l, d, fn_, pl, tg, fl} : ST.Sh} & {ST.rep(~K, ft_, 0n, fn_) == True{} : Bool} & ({fr_ == ST.rid(ft_) : Nat} & ({ST.ids(ft_) == i0 : List<&2, Nat>} & ({ST.root_black(~K, ft_, fn_) == True{} : Bool} & {ST.ents(~K, ~V, i0, fn_, pl) == e0 : List<&2, M.Entry>} & ({EN.oks(~K, ~V, i0, fn_, pl) == True{} : Bool} & ({ST.fll(~K, fn_, fx) == True{} : Bool} & {SC.length(M.Node, fn_) == l0 : Nat})))))>>>: match gf: case 0n: fin(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, root, nl, PG.plug(c, ST.TN{z, zl, zr}), PG.rep_plug(~K, nl, c, ST.TN{z, zl, zr}, i1, i2), i5, Equal.trans(List<&2, Nat>, ST.ids(PG.plug(c, ST.TN{z, zl, zr})), SC.append(Nat, P.before(c), SC.append(Nat, ST.ids(ST.TN{z, zl, zr}), P.after(c))), i0, PG.ids_plug(c, ST.TN{z, zl, zr}), i4), h4, h5, h6, h7) case 1n+g: step(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, g, root, nl, c, z, zl, zr, i1, i2, i3, i4, i5, i6, h4, h5, h6, h7, kr_ => kn_ => kc_ => kz_ => kzl_ => kzr_ => ki1 => ki2 => ki3 => ki4 => ki5 => ki6 => kh4 => kh5 => kh6 => kh7 => loop(~K, ~V, ~cmp, ~o, n, lo, hi, free, l, d, pl, tg, fl, fx, i0, e0, l0, g, kr_, kn_, kc_, kz_, kzl_, kzr_, ki1, ki2, ki3, ki4, ki5, ki6, kh4, kh5, kh6, kh7))