diff --git a/BusyBeaver.lean b/BusyBeaver.lean index 476f8e6a..dc4214c7 100644 --- a/BusyBeaver.lean +++ b/BusyBeaver.lean @@ -130,6 +130,7 @@ public import BusyBeaver.BB6.Halt.M_1RB0RD_1LC0RA_HHH1RD_1RA1LE_1RC0LF_1LE0LB public import BusyBeaver.BB6.Halt.M_1RB0RD_1LC1RE_1LA0LD_0RE0RF_1LC1RA_0LEHHH public import BusyBeaver.BB6.Halt.M_1RB0RD_1RC0LC_1RE1RA_0LD1LA_0LF0LD_0REHHH public import BusyBeaver.BB6.Halt.M_1RB0RE_1RC0RA_0LD0LB_0LA1LE_1LC1LF_0LAHHH +public import BusyBeaver.BB6.Halt.M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH public import BusyBeaver.BB6.Halt.M_1RB0RF_0RC1RD_0LDHHH_1LE1RA_1LA0LF_0RD0RC public import BusyBeaver.BB6.Halt.M_1RB0RF_1LC1RE_1LD0LC_0LE0RE_1RA1LD_1RBHHH public import BusyBeaver.BB6.Halt.M_1RB0RF_1RC0RB_1LD1RA_1LE0LD_1RB0LA_0LDHHH @@ -157,6 +158,7 @@ public import BusyBeaver.BB6.NonHalt.M_1RB0LC_1LA0RE_0RD1LF_1LC1LB_0LD0RB_0LAHHH public import BusyBeaver.BB6.NonHalt.M_1RB0LC_1LC0RB_0LE0LD_1LCHHH_0RA1LF_1LA1LF public import BusyBeaver.BB6.NonHalt.M_1RB0LC_1LC0RE_1LA1LD_1LA1LB_0RF1RA_HHH0RE public import BusyBeaver.BB6.NonHalt.M_1RB0LC_1LC0RE_1LA1LD_1LA1LF_0RB1RA_1LCHHH +public import BusyBeaver.BB6.NonHalt.M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA public import BusyBeaver.BB6.NonHalt.M_1RB0LD_1LC1RB_0LA0LD_1LE0RB_1RF0RE_HHH0RD public import BusyBeaver.BB6.NonHalt.M_1RB0LD_1RC0RA_1RD1RF_1LA0LE_1RE1LD_0RBHHH public import BusyBeaver.BB6.NonHalt.M_1RB0LD_1RC0RE_1LD0RE_1LA0LA_1RB1RF_1RBHHH @@ -166,6 +168,7 @@ public import BusyBeaver.BB6.NonHalt.M_1RB0LE_1LC1RD_1LA0LC_1RA1RE_0RF0RB_1LCHHH public import BusyBeaver.BB6.NonHalt.M_1RB0LE_1RC0LF_0LD0RC_1RA1LD_1LB0LE_HHH0RE public import BusyBeaver.BB6.NonHalt.M_1RB0LE_1RC0RC_1LD0RB_1LA0LE_1LD1LF_1LDHHH public import BusyBeaver.BB6.NonHalt.M_1RB0LE_1RC1LA_1LD1RE_1LB0LD_1RF0RC_1RBHHH +public import BusyBeaver.BB6.NonHalt.M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF public import BusyBeaver.BB6.NonHalt.M_1RB0LF_0RCHHH_1RD0RA_1LE0RC_0LA0LE_1LE1LB public import BusyBeaver.BB6.NonHalt.M_1RB0RA_0LC0LA_1RF1LD_1LE0LD_1LC1LF_HHH1RA public import BusyBeaver.BB6.NonHalt.M_1RB0RA_0RC0LD_1LA1RF_1LE1LD_1LB1RE_HHH1RA @@ -181,9 +184,11 @@ public import BusyBeaver.BB6.NonHalt.M_1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LBHHH public import BusyBeaver.BB6.NonHalt.M_1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LCHHH public import BusyBeaver.BB6.NonHalt.M_1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LDHHH public import BusyBeaver.BB6.NonHalt.M_1RB0RA_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RBHHH +public import BusyBeaver.BB6.NonHalt.M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH public import BusyBeaver.BB6.NonHalt.M_1RB0RA_1RC0LC_0LD1RF_1RA1LE_1LD0LB_0REHHH public import BusyBeaver.BB6.NonHalt.M_1RB0RA_1RC0LE_1LD0RA_HHH1LE_0RE0LF_1LB1LC public import BusyBeaver.BB6.NonHalt.M_1RB0RA_1RC0RC_1LD0LE_1RA1LC_1LC1LF_0LCHHH +public import BusyBeaver.BB6.NonHalt.M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE public import BusyBeaver.BB6.NonHalt.M_1RB0RA_1RC0RD_1LD1LE_1LF0LC_0LDHHH_1RA1LD public import BusyBeaver.BB6.NonHalt.M_1RB0RA_1RC0RE_1RDHHH_1LE1LD_1LF0LD_1RA1LE public import BusyBeaver.BB6.NonHalt.M_1RB0RB_1LC0LE_1RD1LB_1RA0RD_1LB1LF_0LAHHH @@ -194,6 +199,7 @@ public import BusyBeaver.BB6.NonHalt.M_1RB0RB_1RC1LC_0LD1RA_1LF1LE_0LA1LC_1LBHHH public import BusyBeaver.BB6.NonHalt.M_1RB0RC_1LC0LD_1RA1RC_1RA1LE_0LB1RE_HHH1RA public import BusyBeaver.BB6.NonHalt.M_1RB0RC_1LC1LF_1LD0LB_1RE1LC_1RA0RE_0LCHHH public import BusyBeaver.BB6.NonHalt.M_1RB0RC_1LC1RA_0RF0LD_1LE0RB_1LB0LD_HHH1RD +public import BusyBeaver.BB6.NonHalt.M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB public import BusyBeaver.BB6.NonHalt.M_1RB0RC_1LC1RD_1RA1LE_1LA0RD_0LE1RF_1LBHHH public import BusyBeaver.BB6.NonHalt.M_1RB0RD_0LC0RA_1LA1LC_1RE0LF_0RA1RF_1LBHHH public import BusyBeaver.BB6.NonHalt.M_1RB0RD_0LC1RA_0RA1LB_1RE1LB_1LF1LB_HHH1LE @@ -217,12 +223,14 @@ public import BusyBeaver.BB6.NonHalt.M_1RB0RE_1RC0RB_0RD0RF_0LEHHH_1LF1LE_1LA0LE public import BusyBeaver.BB6.NonHalt.M_1RB0RE_1RC1LF_0LD0RE_HHH1LE_1RA0LB_1LB0LC public import BusyBeaver.BB6.NonHalt.M_1RB0RE_1RC1RE_1LD1RA_1LA0LD_0RA0LF_1LDHHH public import BusyBeaver.BB6.NonHalt.M_1RB0RE_1RCHHH_0LD1LE_0RE1LD_1RF0LC_0RA1RE +public import BusyBeaver.BB6.NonHalt.M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD public import BusyBeaver.BB6.NonHalt.M_1RB0RF_1LC0LF_1LD0LC_0LE0LA_1LFHHH_1RA1RF public import BusyBeaver.BB6.NonHalt.M_1RB0RF_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RBHHH public import BusyBeaver.BB6.NonHalt.M_1RB0RF_1LC1RA_1LD0LC_0LE0LA_0RFHHH_1RA1RF public import BusyBeaver.BB6.NonHalt.M_1RB0RF_1LC1RA_1LD0LC_0LE0LA_1RFHHH_1RA1RE public import BusyBeaver.BB6.NonHalt.M_1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LFHHH_1RA1RB public import BusyBeaver.BB6.NonHalt.M_1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LFHHH_1RA1RF +public import BusyBeaver.BB6.NonHalt.M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH public import BusyBeaver.BB6.NonHalt.M_1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RAHHH_0RA0LB public import BusyBeaver.BB6.NonHalt.M_1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RAHHH_0RE0LB public import BusyBeaver.BB6.NonHalt.M_1RB0RF_1RC1RF_1LD0RE_HHH0LE_1LA0LE_0RA0LC @@ -247,9 +255,11 @@ public import BusyBeaver.BB6.NonHalt.M_1RB1LD_1RC0RB_1LD0RD_1LA0LE_1LD1LF_1LAHHH public import BusyBeaver.BB6.NonHalt.M_1RB1LE_1LC0RF_1LA0RD_1LC1RC_1LB0LB_HHH1RD public import BusyBeaver.BB6.NonHalt.M_1RB1LE_1LC1RD_0LA1LA_HHH1RE_1LF0LA_0LC0RF public import BusyBeaver.BB6.NonHalt.M_1RB1LF_0RC0RB_0LD1LA_1LC0LE_0LAHHH_1LA1LF +public import BusyBeaver.BB6.NonHalt.M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE public import BusyBeaver.BB6.NonHalt.M_1RB1LF_1LC1RB_1RE1LD_1LB0LC_1LA0RE_1LDHHH public import BusyBeaver.BB6.NonHalt.M_1RB1LF_1RC0RB_1RD0RF_1REHHH_1LF1LA_1LA0LE public import BusyBeaver.BB6.NonHalt.M_1RB1LF_1RC0RB_1RD0RF_1REHHH_1LF1LE_1LA0LE +public import BusyBeaver.BB6.NonHalt.M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD public import BusyBeaver.BB6.NonHalt.M_1RB1RA_1LC1LE_0LD0LB_0RA0RF_0LC0RA_1RDHHH public import BusyBeaver.BB6.NonHalt.M_1RB1RA_1LC1LE_1RF1LD_1RE0LD_0LB0RA_HHH0RC public import BusyBeaver.BB6.NonHalt.M_1RB1RA_1LC1RE_0LD0LD_0LE1LF_1LA0RA_HHH1LC @@ -283,6 +293,7 @@ public import BusyBeaver.BB6.NonHalt.M_1RBHHH_0RC0LD_1RD1RC_1LB0LE_1LF0RA_0LD1LA public import BusyBeaver.BB6.NonHalt.M_1RBHHH_0RC0RA_1RD1RC_1LE1LF_0LB0LD_0LE0RC public import BusyBeaver.BB6.NonHalt.M_1RBHHH_0RC1LF_0RD1RB_1LE1RC_0LB0LE_0LE0LA public import BusyBeaver.BB6.NonHalt.M_1RBHHH_0RC1LF_1LC1LD_1RE0RA_0RD1RF_0LD0LF +public import BusyBeaver.BB6.NonHalt.M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD public import BusyBeaver.BB6.NonHalt.M_1RBHHH_1LC0LF_1RD1LB_1RE0RD_1LB0RB_1LB0LA public import BusyBeaver.BB6.NonHalt.M_1RBHHH_1LC0RC_0LD0LC_1RE1RA_0RD1LF_0LE0LF public import BusyBeaver.BB6.NonHalt.M_1RBHHH_1LC1LB_1LD0LB_1RE1LC_1RF0RE_0RA0RC diff --git a/BusyBeaver/BB6/Halt/M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH.lean b/BusyBeaver/BB6/Halt/M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH.lean new file mode 100644 index 00000000..91388e19 --- /dev/null +++ b/BusyBeaver/BB6/Halt/M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH.lean @@ -0,0 +1,3493 @@ +/- +Copyright (c) 2026 Google LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +-/ +module + +import BusyBeaver.Basic +public import BusyBeaver.Bridge +import BusyBeaver.Calculi.Longitudinal + +open Mathlib Relation Nat Turing BusyBeaver SixState + +namespace BusyBeaver.M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH + +@[expose] public section + +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH" + +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB + +end + +abbrev target_tm : Machine (Fin 2) (Fin 6) := target + +namespace Solution + +open BusyBeaver.Longitudinal +open BusyBeaver.Longitudinal.BoundedConfig (all0_spec segRLs_c_spec) + +abbrev tm : Machine (Fin 2) (Fin 6) := flipTM target_tm + +abbrev U : List (Fin 2) := [1, 0, 0] +abbrev Z : List (Fin 2) := [0, 0, 0] +abbrev O : List (Fin 2) := [1, 0, 1] +abbrev P : List (Fin 2) := [0, 0, 1] + +abbrev h : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6)) := [((C, [0]), (C, [1]))] +abbrev g : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6)) := [((E, [0, 0]), (C, [1]))] +abbrev j : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6)) := [((D, [0, 0]), (C, [1]))] +abbrev e : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6)) := [((E, [0, 0, 0]), (C, [1]))] +abbrev q : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6)) := [((D, [0]), (C, [1]))] +abbrev qb : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6)) := [((D, [0]), (B, [1]))] + +theorem H0 : SegRLs tm h j [0] [] := segRLs_c_spec tm (T := 100) (by decide) +theorem H1 : SegRLs tm h [] [1] [0] := segRLs_c_spec tm (T := 100) (by decide) +theorem J1 : SegRLs tm j e [1] [] := segRLs_c_spec tm (T := 100) (by decide) +theorem QB00 : SegRLs tm qb [] [0, 0] [0, 1] := segRLs_c_spec tm (T := 100) (by decide) +theorem Q01 : SegRLs tm q h [0, 1] [0, 1] := segRLs_c_spec tm (T := 100) (by decide) +theorem QU : SegRLs tm q q U U := segRLs_c_spec tm (T := 100) (by decide) +theorem QUB : SegRLs tm q qb U O := segRLs_c_spec tm (T := 100) (by decide) +theorem QO : SegRLs tm q [] O U := segRLs_c_spec tm (T := 100) (by decide) +theorem Q110 : SegRLs tm q h [1, 1, 0] U := segRLs_c_spec tm (T := 100) (by decide) +theorem GU : SegRLs tm g j U U := segRLs_c_spec tm (T := 100) (by decide) +theorem JU : SegRLs tm j (q ++ j) U U := segRLs_c_spec tm (T := 100) (by decide) +theorem JO : SegRLs tm j j O U := segRLs_c_spec tm (T := 100) (by decide) +theorem J110 : SegRLs tm j (h ++ j) [1, 1, 0] U := segRLs_c_spec tm (T := 100) (by decide) + +macro "tm_step" : tactic => + `(tactic| ( + first + | refine ReachesPlus.head (by + try simp only [Cfg.headRight, Cfg.headLeft, init, Tape.mk₁, Tape.mk₂, Tape.mk', + List.cons_append, List.nil_append, List.append_nil, + ListBlank.mk_nil, ListBlank.append, ListBlank.head_cons, ListBlank.tail_cons, + ListBlank.head_default, ListBlank.head_default_fin, ListBlank.tail_default, + ListBlank.cons_default_default, ListBlank.cons_zero_default, flipStmt, flipDir] + rfl) ?_ + | refine ReachesStar.head (by + try simp only [Cfg.headRight, Cfg.headLeft, init, Tape.mk₁, Tape.mk₂, Tape.mk', + List.cons_append, List.nil_append, List.append_nil, + ListBlank.mk_nil, ListBlank.append, ListBlank.head_cons, ListBlank.tail_cons, + ListBlank.head_default, ListBlank.head_default_fin, ListBlank.tail_default, + ListBlank.cons_default_default, ListBlank.cons_zero_default, flipStmt, flipDir] + rfl) ?_ + try simp only [Tape.write, Tape.move, ListBlank.head_cons, ListBlank.tail_cons, + ListBlank.head_default, ListBlank.head_default_fin, ListBlank.tail_default, + ListBlank.cons_default_default, ListBlank.cons_zero_default, flipStmt, flipDir])) + +macro "tm_steps" : tactic => + `(tactic| repeat (first | bb_refl | tm_step)) + +theorem G11 (l r : ListBlank (Fin 2)) : + HaltsFrom tm (toDHCfg ((E, [0, 0]), .right) l ([1, 1] +> r)) := by + refine ⟨([1, 0, 0] +> l) {{F}}> ([1] +> r), ?_, ?_⟩ + · dsimp [toDHCfg]; tm_steps + · bb_halt + +theorem L11 (l r : ListBlank (Fin 2)) : + HaltsFrom tm (toDHCfg ((E, [0, 0, 0]), .right) l ([1, 1] +> r)) := by + refine ⟨([1, 0, 0, 0] +> l) {{F}}> ([1] +> r), ?_, ?_⟩ + · dsimp [toDHCfg]; tm_steps + · bb_halt + +theorem Q111 (l r : ListBlank (Fin 2)) : + HaltsFrom tm (toDHCfg ((D, [0]), .right) l ([1, 1, 1] +> r)) := by + refine ⟨([1, 0, 0] +> l) {{F}}> ([1] +> r), ?_, ?_⟩ + · dsimp [toDHCfg]; tm_steps + · bb_halt + +theorem Qrun (a : ℕ) : SegRLs tm q q (U ^ a) (U ^ a) := by + induction a with + | zero => exact SegRLs.empty tm q + | succ a ih => exact QU.concat ih + +theorem Qrun01 (a : ℕ) : SegRLs tm q h (U ^ a ++ [0, 1]) (U ^ a ++ [0, 1]) := + (Qrun a).concat Q01 + +theorem T01 (a : ℕ) : SegRLs tm j (h ^ (1 + a)) (U ^ a ++ [0, 1]) (U ^ (1 + a)) := by + induction a with + | zero => exact segRLs_c_spec tm (T := 100) (by decide) + | succ a ih => + have h_pow : h ^ (1 + (a + 1)) = h ++ h ^ (1 + a) := by + have hk : 1 + (a + 1) = (1 + a) + 1 := by omega + rw [hk, pow_succ_list] + have h_u1 : U ^ (a + 1) ++ [0, 1] = U ++ (U ^ a ++ [0, 1]) := by + rw [pow_succ_list, List.append_assoc] + have h_u2 : U ^ (1 + (a + 1)) = U ++ U ^ (1 + a) := by + have hk : 1 + (a + 1) = (1 + a) + 1 := by omega + rw [hk, pow_succ_list] + rw [h_pow, h_u1, h_u2] + exact JU.concat ((Qrun01 a).trans ih) + +theorem QrunO (a : ℕ) : SegRLs tm q [] (U ^ a ++ O) (U ^ (1 + a)) := by + have hk : 1 + a = a + 1 := by omega + rw [hk, pow_succ_list'] + exact (Qrun a).concat QO + +theorem Qrun00 (a : ℕ) : SegRLs tm q [] (U ^ (1 + a) ++ [0, 0]) (U ^ a ++ O ++ [0, 1]) := by + have hk : 1 + a = a + 1 := by omega + rw [hk, pow_succ_list', List.append_assoc, List.append_assoc] + exact (Qrun a).concat (QUB.concat QB00) + +inductive Result (X : Type) where + | failed + | stopped + | returned (x : X) +deriving DecidableEq + +def map_result {X Y : Type} (f : X → Y) : Result X → Result Y + | .failed => .failed + | .stopped => .stopped + | .returned x => .returned (f x) + +def then_result {X Y : Type} (o : Result X) (f : X → Result Y) : Result Y := + match o with + | .failed => .failed + | .stopped => .stopped + | .returned x => f x + +def Spec {X : Type} (den : X → ListBlank (Fin 2)) + (hs : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))) + (r : ListBlank (Fin 2)) (o : Result X) : Prop := + match o with + | .failed => True + | .stopped => SideRLsHalt tm hs r + | .returned x => SideRLs tm hs r (den x) + +theorem rule_spec {X : Type} (den : X → ListBlank (Fin 2)) + {hs hs' : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))} + {w v : List (Fin 2)} {r : ListBlank (Fin 2)} {o : Result X} + (hR : SegRLs tm hs hs' w v) (hS : Spec den hs' r o) : + Spec (fun x => v +> den x) hs (w +> r) o := by + cases o with + | failed => trivial + | stopped => exact hR.sideRLsHalt_concat hS + | returned x => exact hR.sideRLs_concat hS + +theorem lift_rule {X Y : Type} (dx : X → ListBlank (Fin 2)) (dy : Y → ListBlank (Fin 2)) + {hs hs' : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))} + {w v : List (Fin 2)} {r : ListBlank (Fin 2)} {o : Result X} {f : X → Y} + (hR : SegRLs tm hs hs' w v) (hF : ∀ x, dy (f x) = v +> dx x) + (hS : Spec dx hs' r o) : + Spec dy hs (w +> r) (map_result f o) := by + cases o with + | failed => trivial + | stopped => exact hR.sideRLsHalt_concat hS + | returned x => + dsimp [Spec, map_result] + rw [hF x] + exact hR.sideRLs_concat hS + +theorem bind_spec {X Y : Type} (dx : X → ListBlank (Fin 2)) (dy : Y → ListBlank (Fin 2)) + {hs hs' : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))} + {r : ListBlank (Fin 2)} {o : Result X} {f : X → Result Y} + (hS : Spec dx hs r o) (hF : ∀ x, Spec dy hs' (dx x) (f x)) : + Spec dy (hs ++ hs') r (then_result o f) := by + cases o with + | failed => trivial + | stopped => exact SideRLsHalt.app_left hS + | returned x => + have hfx := hF x + dsimp [then_result] + cases hfx_eq : f x with + | failed => trivial + | stopped => + rw [hfx_eq] at hfx + exact SideRLsHalt.app_right hS hfx + | returned y => + rw [hfx_eq] at hfx + exact hS.trans hfx + +theorem after_spec {X : Type} (den : X → ListBlank (Fin 2)) + {hs hs' : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))} + {r s : ListBlank (Fin 2)} {o : Result X} + (hSide : SideRLs tm hs r s) (hS : Spec den hs' s o) : + Spec den (hs ++ hs') r o := by + cases o with + | failed => trivial + | stopped => exact SideRLsHalt.app_right hSide hS + | returned x => exact hSide.trans hS + +theorem TO {X : Type} (den : X → ListBlank (Fin 2)) (a : ℕ) (r : ListBlank (Fin 2)) (o : Result X) + (hS : Spec den j (U ^ a +> r) o) : + Spec (fun x => U +> den x) j (U ^ a +> (O +> r)) o := by + rcases a with _ | a + · dsimp only [pow_zero_list, append_nil] at hS ⊢ + exact rule_spec den JO hS + · rw [pow_succ_list U a, append_assoc, ← append_assoc (U ^ a) O r] + have hQ : SideRLs tm q ((U ^ a ++ O) +> r) (U ^ (1 + a) +> r) := + (QrunO a).sideRLs_concat (.nil r) + have ha : 1 + a = a + 1 := by omega + rw [ha] at hQ + exact rule_spec den JU (after_spec den hQ hS) + +theorem T00 {X : Type} (den : X → ListBlank (Fin 2)) (a : ℕ) (r : ListBlank (Fin 2)) (o : Result X) + (hS : Spec den (h ^ (1 + a)) r o) : + Spec (fun x => U ^ (3 + a) +> den x) j (U ^ (2 + a) +> ([0, 0] +> r)) o := by + have hT := rule_spec den (T01 a) hS + rw [append_assoc] at hT + have hT' := TO (fun x => U ^ (1 + a) +> den x) a ([0, 1] +> r) o hT + have hQ : SideRLs tm q ((U ^ (1 + a) ++ [0, 0]) +> r) ((U ^ a ++ O ++ [0, 1]) +> r) := + (Qrun00 a).sideRLs_concat (.nil r) + have h_in : U ^ (2 + a) +> ([0, 0] +> r) = U +> ((U ^ (1 + a) ++ [0, 0]) +> r) := by + have h2 : 2 + a = (1 + a) + 1 := by omega + rw [h2, pow_succ_list, append_assoc, append_assoc] + rw [h_in] + have h_mid : (U ^ a ++ O ++ [0, 1]) +> r = U ^ a +> (O +> ([0, 1] +> r)) := by + rw [List.append_assoc, append_assoc, append_assoc] + rw [h_mid] at hQ + have h_res := rule_spec (fun x => U +> (U ^ (1 + a) +> den x)) JU (after_spec _ hQ hT') + have h_fn : (fun x => U +> (U +> (U ^ (1 + a) +> den x))) = (fun x => U ^ (3 + a) +> den x) := by + funext x + have h3 : 3 + a = ((1 + a) + 1) + 1 := by omega + rw [h3, pow_succ_list, pow_succ_list, append_assoc, append_assoc] + rwa [h_fn] at h_res + +theorem T00zero : SegRLs tm j [] [0, 0] O := segRLs_c_spec tm (T := 100) (by decide) +theorem T00one : SegRLs tm j [] (U ++ [0, 0]) (U ++ P) := segRLs_c_spec tm (T := 100) (by decide) + +theorem Qrun110 (a : ℕ) : SegRLs tm q h (U ^ a ++ [1, 1, 0]) (U ^ (1 + a)) := by + have hk : 1 + a = a + 1 := by omega + rw [hk, pow_succ_list'] + exact (Qrun a).concat Q110 + +theorem T110_return {X : Type} (den : X → ListBlank (Fin 2)) (a : ℕ) + (r s : ListBlank (Fin 2)) (o : Result X) + (hH : SideRLs tm h r s) (hT : Spec den j (U ^ a +> s) o) : + Spec (fun x => U +> den x) j (U ^ a +> ([1, 1, 0] +> r)) o := by + rcases a with _ | a + · dsimp only [pow_zero_list, append_nil] at hT ⊢ + exact rule_spec den J110 (after_spec den hH hT) + · rw [pow_succ_list U a, append_assoc, ← append_assoc (U ^ a) [1, 1, 0] r] + have hQ : SideRLs tm q ((U ^ a ++ [1, 1, 0]) +> r) (U ^ (1 + a) +> s) := + (Qrun110 a).sideRLs_concat hH + have ha : 1 + a = a + 1 := by omega + rw [ha] at hQ + exact rule_spec den JU (after_spec den hQ hT) + +theorem T110_halt (a : ℕ) (r : ListBlank (Fin 2)) (hH : SideRLsHalt tm h r) : + SideRLsHalt tm j (U ^ a +> ([1, 1, 0] +> r)) := by + rcases a with _ | a + · dsimp only [pow_zero_list, append_nil] + exact J110.sideRLsHalt_concat (SideRLsHalt.app_left hH) + · rw [pow_succ_list U a, append_assoc, ← append_assoc (U ^ a) [1, 1, 0] r] + exact JU.sideRLsHalt_concat (SideRLsHalt.app_left ((Qrun110 a).sideRLsHalt_concat hH)) + +theorem T111 (a : ℕ) (r : ListBlank (Fin 2)) : + SideRLsHalt tm j (U ^ a +> ([1, 1, 1] +> r)) := by + rcases a with _ | a + · change SideRLsHalt tm j ([1] +> ([1, 1] +> r)) + exact J1.sideRLsHalt_concat (.here (E, [0, 0, 0]) (C, [1]) [] ([1, 1] +> r) (fun l => L11 l r)) + · rw [pow_succ_list U a, append_assoc] + refine JU.sideRLsHalt_concat (SideRLsHalt.app_left ?_) + exact (Qrun a).sideRLsHalt_concat (.here (D, [0]) (C, [1]) [] ([1, 1, 1] +> r) (fun l => + Q111 l r)) + +def digit (p : ℕ) : List (Fin 2) := + match p with + | 0 => U + | 1 => Z + | 2 => O + | _ => P + +theorem digit_cycle (p : ℕ) (hp : p < 4) : + SegRLs tm (h ^ 4) h (digit p) (digit p) := by + rcases p with _ | _ | _ | _ | p + · exact segRLs_c_spec tm (T := 100) (by decide) + · exact segRLs_c_spec tm (T := 100) (by decide) + · exact segRLs_c_spec tm (T := 100) (by decide) + · exact segRLs_c_spec tm (T := 100) (by decide) + · omega + +theorem digit_short (p n : ℕ) (hp : p < 4) (hn : n < 4) : + SegRLs tm (h ^ n) (h ^ ((p + n) / 4)) (digit p) (digit ((p + n) % 4)) := by + rcases p with _ | _ | _ | _ | p <;> try omega + all_goals + rcases n with _ | _ | _ | _ | n <;> try omega + all_goals exact segRLs_c_spec tm (T := 100) (by decide) + +theorem digit_count (p n : ℕ) (hp : p < 4) : + SegRLs tm (h ^ n) (h ^ ((p + n) / 4)) (digit p) (digit ((p + n) % 4)) := by + have hs := digit_short p (n % 4) hp (by omega) + have hc := digit_cycle ((p + n % 4) % 4) (by omega) + have h_am := SegRLs.addmul (x := n / 4) hs hc + have h1 : (n / 4) * 4 + n % 4 = n := by omega + have h2 : (n / 4) + (p + n % 4) / 4 = (p + n) / 4 := by omega + have h3 : (p + n % 4) % 4 = (p + n) % 4 := by omega + rwa [h1, h2, h3] at h_am + +def bits (w : List (Fin 2)) : ListBlank (Fin 2) := w +> default + +theorem zero_cons_default' : (0 : Fin 2) >> (default : ListBlank (Fin 2)) = default := + all0_spec (a := [0]) (by decide) + + +/-! ## Pure-Kernel Arithmetic Tape Encoding & Fused Multi-Width SWAR Evaluator (v3) -/ + +private theorem land_pow2_sub1 (m k : Nat) : Nat.land m (2 ^ k - 1) = m % 2 ^ k := by + change m &&& (2 ^ k - 1) = m % 2 ^ k + exact Nat.and_two_pow_sub_one_eq_mod m k + +private theorem land_1 (m : Nat) : Nat.land m 1 = m % 2 := land_pow2_sub1 m 1 +private theorem land_3 (m : Nat) : Nat.land m 3 = m % 4 := land_pow2_sub1 m 2 +private theorem land_7 (m : Nat) : Nat.land m 7 = m % 8 := land_pow2_sub1 m 3 +private theorem land_15 (m : Nat) : Nat.land m 15 = m % 16 := land_pow2_sub1 m 4 +private theorem land_63 (m : Nat) : Nat.land m 63 = m % 64 := land_pow2_sub1 m 6 +private theorem land_255 (m : Nat) : Nat.land m 255 = m % 256 := land_pow2_sub1 m 8 +private theorem land_4095 (m : Nat) : Nat.land m 4095 = m % 4096 := land_pow2_sub1 m 12 +private theorem land_16777215 (m : Nat) : Nat.land m 16777215 = m % 16777216 := land_pow2_sub1 m 24 +private theorem land_68719476735 (m : Nat) : Nat.land m 68719476735 = m % 68719476736 := + land_pow2_sub1 m 36 +private theorem land_281474976710655 (m : Nat) : Nat.land m 281474976710655 = m % 281474976710656 := + land_pow2_sub1 m 48 + +private theorem land_mask_mod (m k mask : Nat) (hm : (2 ^ k - 1) &&& mask = mask) : + Nat.land m mask = Nat.land (m % 2 ^ k) mask := by + change m &&& mask = (m % 2 ^ k) &&& mask + calc m &&& mask + _ = m &&& ((2 ^ k - 1) &&& mask) := by rw [hm] + _ = (m &&& (2 ^ k - 1)) &&& mask := (Nat.and_assoc m (2 ^ k - 1) mask).symm + _ = (m % 2 ^ k) &&& mask := by rw [Nat.and_two_pow_sub_one_eq_mod] + +private theorem land_2 (m : Nat) : Nat.land m 2 = Nat.land (m % 4) 2 := land_mask_mod m 2 2 rfl +private theorem land_2_8 (m : Nat) : Nat.land m 2 = Nat.land (m % 8) 2 := land_mask_mod m 3 2 rfl +private theorem land_18 (m : Nat) : Nat.land m 18 = Nat.land (m % 64) 18 := land_mask_mod m 6 18 rfl +private theorem land_1170 (m : Nat) : Nat.land m 1170 = Nat.land (m % 4096) 1170 := + land_mask_mod m 12 1170 rfl + +private theorem shr_eq (m k : Nat) : Nat.shiftRight m k = m / 2 ^ k := Nat.shiftRight_eq_div_pow m k +private theorem shl_eq (m k : Nat) : Nat.shiftLeft m k = 2 ^ k * m := by + change m <<< k = 2 ^ k * m + rw [Nat.shiftLeft_eq, Nat.mul_comm] + +private theorem shr_1 (m : Nat) : Nat.shiftRight m 1 = m / 2 := shr_eq m 1 +private theorem shr_2 (m : Nat) : Nat.shiftRight m 2 = m / 4 := shr_eq m 2 +private theorem shr_3 (m : Nat) : Nat.shiftRight m 3 = m / 8 := shr_eq m 3 +private theorem shr_4 (m : Nat) : Nat.shiftRight m 4 = m / 16 := shr_eq m 4 +private theorem shr_6 (m : Nat) : Nat.shiftRight m 6 = m / 64 := shr_eq m 6 +private theorem shr_8 (m : Nat) : Nat.shiftRight m 8 = m / 256 := shr_eq m 8 +private theorem shr_12 (m : Nat) : Nat.shiftRight m 12 = m / 4096 := shr_eq m 12 +private theorem shr_16 (m : Nat) : Nat.shiftRight m 16 = m / 65536 := shr_eq m 16 +private theorem shr_24 (m : Nat) : Nat.shiftRight m 24 = m / 16777216 := shr_eq m 24 +private theorem shr_36 (m : Nat) : Nat.shiftRight m 36 = m / 68719476736 := shr_eq m 36 + +private theorem shl_2 (m : Nat) : Nat.shiftLeft m 2 = 4 * m := shl_eq m 2 +private theorem shl_3 (m : Nat) : Nat.shiftLeft m 3 = 8 * m := shl_eq m 3 +private theorem shl_5 (m : Nat) : Nat.shiftLeft m 5 = 32 * m := shl_eq m 5 +private theorem shl_6 (m : Nat) : Nat.shiftLeft m 6 = 64 * m := shl_eq m 6 +private theorem shl_8 (m : Nat) : Nat.shiftLeft m 8 = 256 * m := shl_eq m 8 +private theorem shl_12 (m : Nat) : Nat.shiftLeft m 12 = 4096 * m := shl_eq m 12 +private theorem shl_16 (m : Nat) : Nat.shiftLeft m 16 = 65536 * m := shl_eq m 16 +private theorem shl_24 (m : Nat) : Nat.shiftLeft m 24 = 16777216 * m := shl_eq m 24 +private theorem shl_36 (m : Nat) : Nat.shiftLeft m 36 = 68719476736 * m := shl_eq m 36 + +def b2f (b : Nat) : Fin 2 := if Nat.beq b 1 then 1 else 0 + +def toBitsAux : Nat → Nat → List (Fin 2) + | 0, _ => [] + | k + 1, m => b2f (Nat.mod m 2) :: toBitsAux k (Nat.div m 2) + +def bitsM (m : Nat) : ListBlank (Fin 2) := bits (toBitsAux m m) + +theorem toBitsAux_zero (k : Nat) : bits (toBitsAux k 0) = default := by + induction k with + | zero => rfl + | succ k ih => + change (0 : Fin 2) >> bits (toBitsAux k 0) = default + rw [ih] + exact zero_cons_default' + +theorem bits_toBitsAux_ge (m : Nat) : ∀ k, m ≤ k → bits (toBitsAux k m) = bitsM m := by + induction m using Nat.strongRecOn with + | ind m ih => + intro k hmk + rcases m with _ | m' + · rw [toBitsAux_zero k]; exact (toBitsAux_zero 0).symm + · rcases k with _ | k' + · omega + · unfold bitsM + change b2f ((m' + 1) % 2) >> bits (toBitsAux k' ((m' + 1) / 2)) = + b2f ((m' + 1) % 2) >> bits (toBitsAux m' ((m' + 1) / 2)) + rw [ih ((m' + 1) / 2) (by omega) k' (by omega), + ih ((m' + 1) / 2) (by omega) m' (by omega)] + +theorem bitsM_zero : bitsM 0 = default := rfl + +theorem bitsM_unfold (m : Nat) : + bitsM m = b2f (m % 2) >> bitsM (m / 2) := by + rcases m with _ | m' + · change (default : ListBlank (Fin 2)) = (0 : Fin 2) >> (default : ListBlank (Fin 2)) + exact zero_cons_default'.symm + · change b2f ((m' + 1) % 2) >> bits (toBitsAux m' ((m' + 1) / 2)) = + b2f ((m' + 1) % 2) >> bitsM ((m' + 1) / 2) + rw [bits_toBitsAux_ge ((m' + 1) / 2) m' (by omega)] + +theorem bitsM_bit0 (r : Nat) : bitsM (2 * r) = (0 : Fin 2) >> bitsM r := by + rw [bitsM_unfold (2 * r)] + have h1 : (2 * r) % 2 = 0 := by omega + have h2 : (2 * r) / 2 = r := by omega + rw [h1, h2]; rfl + +theorem bitsM_bit1 (r : Nat) : bitsM (1 + 2 * r) = (1 : Fin 2) >> bitsM r := by + rw [bitsM_unfold (1 + 2 * r)] + have h1 : (1 + 2 * r) % 2 = 1 := by omega + have h2 : (1 + 2 * r) / 2 = r := by omega + rw [h1, h2]; rfl + +theorem bitsM_00 (y : Nat) : bitsM (4 * y) = ([0, 0] : List (Fin 2)) +> bitsM y := by + have h : 4 * y = 2 * (2 * y) := by omega + rw [h, bitsM_bit0, bitsM_bit0]; rfl + +theorem bitsM_10 (y : Nat) : bitsM (1 + 4 * y) = ([1, 0] : List (Fin 2)) +> bitsM y := by + have h : 1 + 4 * y = 1 + 2 * (2 * y) := by omega + rw [h, bitsM_bit1, bitsM_bit0]; rfl + +theorem bitsM_01 (y : Nat) : bitsM (2 + 4 * y) = ([0, 1] : List (Fin 2)) +> bitsM y := by + have h : 2 + 4 * y = 2 * (1 + 2 * y) := by omega + rw [h, bitsM_bit0, bitsM_bit1]; rfl + +theorem bitsM_11 (y : Nat) : bitsM (3 + 4 * y) = ([1, 1] : List (Fin 2)) +> bitsM y := by + have h : 3 + 4 * y = 1 + 2 * (1 + 2 * y) := by omega + rw [h, bitsM_bit1, bitsM_bit1]; rfl + +abbrev W6 : List (Fin 2) := [0, 1, 1] + +theorem bitsM_Z (z : Nat) : bitsM (8 * z) = Z +> bitsM z := by + have h : 8 * z = 2 * (4 * z) := by omega + rw [h, bitsM_bit0, bitsM_00]; rfl + +theorem bitsM_U (z : Nat) : bitsM (1 + 8 * z) = U +> bitsM z := by + have h : 1 + 8 * z = 1 + 2 * (4 * z) := by omega + rw [h, bitsM_bit1, bitsM_00]; rfl + +theorem bitsM_110 (z : Nat) : bitsM (3 + 8 * z) = ([1, 1, 0] : List (Fin 2)) +> bitsM z := by + have h : 3 + 8 * z = 3 + 4 * (2 * z) := by omega + rw [h, bitsM_11, bitsM_bit0]; rfl + +theorem bitsM_P (z : Nat) : bitsM (4 + 8 * z) = P +> bitsM z := by + have h : 4 + 8 * z = 4 * (1 + 2 * z) := by omega + rw [h, bitsM_00, bitsM_bit1]; rfl + +theorem bitsM_O (z : Nat) : bitsM (5 + 8 * z) = O +> bitsM z := by + have h : 5 + 8 * z = 1 + 4 * (1 + 2 * z) := by omega + rw [h, bitsM_10, bitsM_bit1]; rfl + +theorem bitsM_W6 (z : Nat) : bitsM (6 + 8 * z) = W6 +> bitsM z := by + have h : 6 + 8 * z = 2 + 4 * (1 + 2 * z) := by omega + rw [h, bitsM_01, bitsM_bit1]; rfl + +theorem bitsM_111 (z : Nat) : bitsM (7 + 8 * z) = ([1, 1, 1] : List (Fin 2)) +> bitsM z := by + have h : 7 + 8 * z = 3 + 4 * (1 + 2 * z) := by omega + rw [h, bitsM_11, bitsM_bit1]; rfl + +theorem bitsM_0000 (w : Nat) : bitsM (16 * w) = ([0, 0, 0, 0] : List (Fin 2)) +> bitsM w := by + have h : 16 * w = 4 * (4 * w) := by omega + rw [h, bitsM_00, bitsM_00]; rfl + +theorem bitsM_0100 (w : Nat) : bitsM (2 + 16 * w) = ([0, 1, 0, 0] : List (Fin 2)) +> bitsM w := by + have h : 2 + 16 * w = 2 + 4 * (4 * w) := by omega + rw [h, bitsM_01, bitsM_00]; rfl + +theorem bitsM_0001 (w : Nat) : bitsM (8 + 16 * w) = ([0, 0, 0, 1] : List (Fin 2)) +> bitsM w := by + have h : 8 + 16 * w = 4 * (2 + 4 * w) := by omega + rw [h, bitsM_00, bitsM_01]; rfl + +theorem bitsM_0101 (w : Nat) : bitsM (10 + 16 * w) = ([0, 1, 0, 1] : List (Fin 2)) +> bitsM w := by + have h : 10 + 16 * w = 2 + 4 * (2 + 4 * w) := by omega + rw [h, bitsM_01, bitsM_01]; rfl + +theorem bitsM_17_32 (r : Nat) : bitsM (17 + 32 * r) = ([1, 0, 0, 0, 1] : List (Fin 2)) +> bitsM r := + by + have h : 17 + 32 * r = 1 + 2 * (8 + 16 * r) := by omega + rw [h, bitsM_bit1, bitsM_0001]; rfl + +theorem bitsM_21_32 (r : Nat) : bitsM (21 + 32 * r) = ([1, 0, 1, 0, 1] : List (Fin 2)) +> bitsM r := + by + have h : 21 + 32 * r = 5 + 8 * (2 + 4 * r) := by omega + rw [h, bitsM_O, bitsM_01]; rfl + +theorem bitsM_33_64 (r : Nat) : bitsM (33 + 64 * r) = ([1, 0, 0, 0, 0, + 1] : List (Fin 2)) +> bitsM r := by + have h : 33 + 64 * r = 1 + 4 * (8 + 16 * r) := by omega + rw [h, bitsM_10, bitsM_0001]; rfl + +theorem bitsM_41_64 (r : Nat) : bitsM (41 + 64 * r) = ([1, 0, 0, 1, 0, + 1] : List (Fin 2)) +> bitsM r := by + have h : 41 + 64 * r = 1 + 8 * (5 + 8 * r) := by omega + rw [h, bitsM_U, bitsM_O]; rfl + +theorem bitsM_P2 (q : Nat) : bitsM (36 + 64 * q) = P ^ 2 +> bitsM q := by + have h : 36 + 64 * q = 4 + 8 * (4 + 8 * q) := by omega + rw [h, bitsM_P, bitsM_P]; rfl + +theorem bitsM_P4 (q : Nat) : bitsM (2340 + 4096 * q) = P ^ 4 +> bitsM q := by + have h : 2340 + 4096 * q = 4 + 8 * (4 + 8 * (4 + 8 * (4 + 8 * q))) := by omega + rw [h, bitsM_P, bitsM_P, bitsM_P, bitsM_P]; rfl + +theorem bitsM_P16 (q : Nat) : + bitsM (160842843834660 + 281474976710656 * q) = P ^ 16 +> bitsM q := by + have h : 160842843834660 + 281474976710656 * q = + 2340 + 4096 * (2340 + 4096 * (2340 + 4096 * (2340 + 4096 * q))) := by ring + rw [h, bitsM_P4, bitsM_P4, bitsM_P4, bitsM_P4] + simp only [← append_assoc, ← pow_add_list] + +theorem bitsM_O4 (q : Nat) : bitsM (2925 + 4096 * q) = O ^ 4 +> bitsM q := by + have h : 2925 + 4096 * q = 5 + 8 * (5 + 8 * (5 + 8 * (5 + 8 * q))) := by omega + rw [h, bitsM_O, bitsM_O, bitsM_O, bitsM_O]; rfl + +theorem bitsM_W6_2 (q : Nat) : bitsM (54 + 64 * q) = W6 ^ 2 +> bitsM q := by + have h : 54 + 64 * q = 6 + 8 * (6 + 8 * q) := by omega + rw [h, bitsM_W6, bitsM_W6]; rfl + +theorem bitsM_W6_4 (q : Nat) : bitsM (3510 + 4096 * q) = W6 ^ 4 +> bitsM q := by + have h : 3510 + 4096 * q = 6 + 8 * (6 + 8 * (6 + 8 * (6 + 8 * q))) := by omega + rw [h, bitsM_W6, bitsM_W6, bitsM_W6, bitsM_W6]; rfl + +theorem bitsM_W6_16 (q : Nat) : + bitsM (241264265751990 + 281474976710656 * q) = W6 ^ 16 +> bitsM q := by + have h : 241264265751990 + 281474976710656 * q = + 3510 + 4096 * (3510 + 4096 * (3510 + 4096 * (3510 + 4096 * q))) := by ring + rw [h, bitsM_W6_4, bitsM_W6_4, bitsM_W6_4, bitsM_W6_4] + simp only [← append_assoc, ← pow_add_list] + +theorem bitsM_U4 (q : Nat) : bitsM (585 + 4096 * q) = U ^ 4 +> bitsM q := by + have h : 585 + 4096 * q = 1 + 8 * (1 + 8 * (1 + 8 * (1 + 8 * q))) := by omega + rw [h, bitsM_U, bitsM_U, bitsM_U, bitsM_U]; rfl + +theorem bitsM_U16 (q : Nat) : + bitsM (40210710958665 + 281474976710656 * q) = U ^ 16 +> bitsM q := by + have h : 40210710958665 + 281474976710656 * q = + 585 + 4096 * (585 + 4096 * (585 + 4096 * (585 + 4096 * q))) := by ring + rw [h, bitsM_U4, bitsM_U4, bitsM_U4, bitsM_U4] + simp only [← append_assoc, ← pow_add_list] + +private theorem bitsM_eq_of_eq (x : Nat) {y : Nat} {rhs : ListBlank (Fin 2)} (hxy : x = + y) (hy : bitsM y = rhs) : + bitsM x = rhs := hxy ▸ hy + +/-! ## Evaluator Definitions (Fused `retUH` + Small `Bool.rec` Helpers + SWAR) -/ + +inductive ResP where + | failed + | stopped + | ret (a m : Nat) + +inductive ResL where + | failed + | stopped + | retU (k r : Nat) + | retUH (k c z : Nat) + +inductive ModeM where + | G + | L + | H (n : Nat) + +noncomputable def retM (x : Nat) : Result Nat := + Nat.rec .failed (fun v _ => .returned v) (Nat.succ x) + +noncomputable def retLU (k r : Nat) : ResL := + Nat.rec .failed (fun vk _ => + Nat.rec .failed (fun vr _ => .retU vk vr) (Nat.succ r)) (Nat.succ k) + +noncomputable def retLUH (k c z : Nat) : ResL := + Nat.rec .failed (fun vk _ => + Nat.rec .failed (fun vc _ => + Nat.rec .failed (fun vz _ => .retUH vk vc vz) (Nat.succ z)) (Nat.succ c)) (Nat.succ k) + +noncomputable def retP (a m : Nat) : ResP := + Nat.rec .failed (fun va _ => + Nat.rec .failed (fun vm _ => .ret va vm) (Nat.succ m)) (Nat.succ a) + +noncomputable def callM (rec : ModeM → Nat → Result Nat) (md : ModeM) (m : Nat) : Result Nat := + Nat.rec .failed (fun vm _ => rec md vm) (Nat.succ m) + +noncomputable def callH (rec : ModeM → Nat → Result Nat) (n m : Nat) : Result Nat := + Nat.rec .failed (fun vn _ => + Nat.rec .failed (fun vm _ => rec (.H vn) vm) (Nat.succ m)) (Nat.succ n) + +noncomputable def mapRetM (o : Result Nat) (k : Nat → Result Nat) : Result Nat := + Result.rec .failed .stopped k o + +noncomputable def mapRetL (o : Result Nat) (k : Nat → ResL) : ResL := + Result.rec .failed .stopped k o + +noncomputable def prependU_pos (k r : Nat) : Nat := + let sh := Nat.mul 3 k + let p8 := Nat.shiftLeft 1 sh + Nat.add (Nat.div (Nat.sub p8 1) 7) (Nat.shiftLeft r sh) + +noncomputable def prependU (k r : Nat) : Nat := + Bool.rec (prependU_pos k r) r (Nat.beq k 0) + +def enc1 (rem : Nat) : Nat := + Nat.lor (Nat.xor (Nat.land rem 1) 1) (Nat.shiftLeft (Nat.land rem 2) 1) + +def dec1 (d3 : Nat) : Nat := + Nat.add (Nat.sub 1 (Nat.land d3 1)) (Nat.mul 2 (Nat.shiftRight d3 2)) + +def dec2 (lo6 : Nat) : Nat := + let x := Nat.xor lo6 9 + let y := Nat.lor (Nat.land x 9) (Nat.land (Nat.shiftRight x 1) 18) + Nat.lor (Nat.land y 3) (Nat.land (Nat.shiftRight y 1) 12) + +def enc2 (b4 : Nat) : Nat := + let u := Nat.lor (Nat.land b4 3) (Nat.shiftLeft (Nat.land b4 12) 1) + Nat.lor (Nat.xor (Nat.land u 9) 9) (Nat.shiftLeft (Nat.land u 18) 1) + +def dec4 (lo12 : Nat) : Nat := + let x := Nat.xor lo12 585 + let y := Nat.lor (Nat.land x 585) (Nat.land (Nat.shiftRight x 1) 1170) + Nat.lor + (Nat.lor (Nat.land y 3) (Nat.land (Nat.shiftRight y 1) 12)) + (Nat.lor (Nat.land (Nat.shiftRight y 2) 48) (Nat.land (Nat.shiftRight y 3) 192)) + +def enc4 (b8 : Nat) : Nat := + let u := Nat.lor + (Nat.lor (Nat.land b8 3) (Nat.shiftLeft (Nat.land b8 12) 1)) + (Nat.lor (Nat.shiftLeft (Nat.land b8 48) 2) (Nat.shiftLeft (Nat.land b8 192) 3)) + Nat.lor (Nat.xor (Nat.land u 585) 585) (Nat.shiftLeft (Nat.land u 1170) 1) + +def dec12_3x4 (lo36 : Nat) : Nat := + Nat.add (dec4 (Nat.land lo36 4095)) + (Nat.add (Nat.shiftLeft (dec4 (Nat.land (Nat.shiftRight lo36 12) 4095)) 8) + (Nat.shiftLeft (dec4 (Nat.land (Nat.shiftRight lo36 24) 4095)) 16)) + +def enc12_3x4 (b24 : Nat) : Nat := + Nat.add (enc4 (Nat.land b24 255)) + (Nat.add (Nat.shiftLeft (enc4 (Nat.land (Nat.shiftRight b24 8) 255)) 12) + (Nat.shiftLeft (enc4 (Nat.land (Nat.shiftRight b24 16) 255)) 24)) + +noncomputable def prependDigitsK_12 (rec : Nat → Nat → Nat → Nat) (k n r2 : Nat) : Nat := + let d12 := enc12_3x4 (Nat.land n 16777215) + let qn := Nat.shiftRight n 24 + let k2 := Nat.sub k 12 + Bool.rec + (Nat.add d12 (Nat.shiftLeft (rec k2 qn r2) 36)) + (Nat.add d12 (Nat.shiftLeft (prependU k2 r2) 36)) + (Nat.beq qn 0) + +noncomputable def prependDigitsK_4 (rec : Nat → Nat → Nat → Nat) (k n r2 : Nat) : Nat := + let d4 := enc4 (Nat.land n 255) + let qn := Nat.shiftRight n 8 + let k2 := Nat.sub k 4 + Bool.rec + (Nat.add d4 (Nat.shiftLeft (rec k2 qn r2) 12)) + (Nat.add d4 (Nat.shiftLeft (prependU k2 r2) 12)) + (Nat.beq qn 0) + +noncomputable def prependDigitsK_2 (rec : Nat → Nat → Nat → Nat) (k n r2 : Nat) : Nat := + let d2 := enc2 (Nat.land n 15) + let qn := Nat.shiftRight n 4 + let k2 := Nat.sub k 2 + Bool.rec + (Nat.add d2 (Nat.shiftLeft (rec k2 qn r2) 6)) + (Nat.add d2 (Nat.shiftLeft (prependU k2 r2) 6)) + (Nat.beq qn 0) + +noncomputable def prependDigitsK_step (rec : Nat → Nat → Nat → Nat) (k n r2 : Nat) : Nat := + Bool.rec + (Bool.rec + (Bool.rec + (Bool.rec + (Bool.rec + (Nat.add (enc1 (Nat.land n 3)) (Nat.shiftLeft r2 3)) + (prependDigitsK_2 rec k n r2) + (Nat.ble 2 k)) + (prependDigitsK_4 rec k n r2) + (Nat.ble 4 k)) + (prependDigitsK_12 rec k n r2) + (Nat.ble 12 k)) + (prependU k r2) + (Nat.beq n 0)) + r2 + (Nat.beq k 0) + +noncomputable def prependDigitsK_aux (fuel : Nat) : Nat → Nat → Nat → Nat := + Nat.rec (motive := fun _ => Nat → Nat → Nat → Nat) + (fun k _ r2 => prependU k r2) (fun _ => prependDigitsK_step) fuel + +noncomputable def prependDigitsK (k n r2 : Nat) : Nat := + prependDigitsK_aux k k n r2 + +def carryK (k n : Nat) : Nat := + Nat.shiftRight n (Nat.mul 2 k) + +noncomputable def ok12_hi (m0 : Nat) : Bool := + Bool.rec false + (Nat.beq (Nat.land (Nat.shiftRight m0 24) 1170) 0) + (Nat.beq (Nat.land (Nat.shiftRight m0 12) 1170) 0) + +noncomputable def sweepP_hit {α : Type} (rec : Nat → Nat → α) (k m : Nat) : α := + Bool.rec + (Bool.rec + (rec (Nat.add k 1) (Nat.shiftRight m 3)) + (rec (Nat.add k 4) (Nat.shiftRight m 12)) + (Nat.beq (Nat.land m 4095) 2340)) + (rec (Nat.add k 16) (Nat.shiftRight m 48)) + (Nat.beq (Nat.land m 281474976710655) 160842843834660) + +noncomputable def sweepP_step {α : Type} (cont : Nat → Nat → α) + (rec : Nat → Nat → α) (k m : Nat) : α := + Bool.rec (cont k m) (sweepP_hit rec k m) (Nat.beq (Nat.land m 7) 4) + +noncomputable def sweepP {α : Type} (fuel : Nat) (cont : Nat → Nat → α) : Nat → Nat → α := + Nat.rec cont (fun _ => sweepP_step cont) fuel + +noncomputable def sweep6_hit {α : Type} (rec : Nat → Nat → α) (k m : Nat) : α := + Bool.rec + (Bool.rec + (Bool.rec + (rec (Nat.add k 1) (Nat.shiftRight m 3)) + (rec (Nat.add k 2) (Nat.shiftRight m 6)) + (Nat.beq (Nat.land m 63) 54)) + (rec (Nat.add k 4) (Nat.shiftRight m 12)) + (Nat.beq (Nat.land m 4095) 3510)) + (rec (Nat.add k 16) (Nat.shiftRight m 48)) + (Nat.beq (Nat.land m 281474976710655) 241264265751990) + +noncomputable def sweep6_step {α : Type} (cont : Nat → Nat → α) + (rec : Nat → Nat → α) (k m : Nat) : α := + Bool.rec (cont k m) (sweep6_hit rec k m) (Nat.beq (Nat.land m 7) 6) + +noncomputable def sweep6 {α : Type} (fuel : Nat) (cont : Nat → Nat → α) : Nat → Nat → α := + Nat.rec cont (fun _ => sweep6_step cont) fuel + +noncomputable def sweepLP_p {α : Type} (rec : Nat → Nat → Nat → α) (kp ku m : Nat) : α := + Bool.rec + (Bool.rec + (Bool.rec + (rec (Nat.add kp 1) ku (Nat.shiftRight m 3)) + (rec (Nat.add kp 2) ku (Nat.shiftRight m 6)) + (Nat.beq (Nat.land m 63) 36)) + (rec (Nat.add kp 4) ku (Nat.shiftRight m 12)) + (Nat.beq (Nat.land m 4095) 2340)) + (rec (Nat.add kp 16) ku (Nat.shiftRight m 48)) + (Nat.beq (Nat.land m 281474976710655) 160842843834660) + +noncomputable def sweepLP_w6 {α : Type} (rec : Nat → Nat → Nat → α) (kp ku m : Nat) : α := + Bool.rec + (Bool.rec + (Bool.rec + (rec kp (Nat.add ku 1) (Nat.shiftRight m 3)) + (rec kp (Nat.add ku 2) (Nat.shiftRight m 6)) + (Nat.beq (Nat.land m 63) 54)) + (rec kp (Nat.add ku 4) (Nat.shiftRight m 12)) + (Nat.beq (Nat.land m 4095) 3510)) + (rec kp (Nat.add ku 16) (Nat.shiftRight m 48)) + (Nat.beq (Nat.land m 281474976710655) 241264265751990) + +noncomputable def sweepLP_step {α : Type} (cont : Nat → Nat → Nat → α) + (rec : Nat → Nat → Nat → α) (kp ku m : Nat) : α := + let d3 := Nat.land m 7 + Bool.rec + (Bool.rec (cont kp ku m) (sweepLP_w6 rec kp ku m) (Nat.beq d3 6)) + (sweepLP_p rec kp ku m) + (Nat.beq d3 4) + +noncomputable def sweepLP {α : Type} (fuel : Nat) (cont : Nat → Nat → Nat → α) : Nat → Nat → Nat → + α := + Nat.rec cont (fun _ => sweepLP_step cont) fuel + +noncomputable def sweepO_hit {α : Type} (rec : Nat → Nat → α) (k m : Nat) : α := + Bool.rec + (rec (Nat.add k 1) (Nat.shiftRight m 3)) + (rec (Nat.add k 4) (Nat.shiftRight m 12)) + (Nat.beq (Nat.land m 4095) 2925) + +noncomputable def sweepO_step {α : Type} (cont : Nat → Nat → α) + (rec : Nat → Nat → α) (k m : Nat) : α := + Bool.rec (cont k m) (sweepO_hit rec k m) (Nat.beq (Nat.land m 7) 5) + +noncomputable def sweepO {α : Type} (fuel : Nat) (cont : Nat → Nat → α) : Nat → Nat → α := + Nat.rec cont (fun _ => sweepO_step cont) fuel + +noncomputable def collectM_hit {α : Type} (rec : Nat → Nat → α) (acc m : Nat) : α := + Bool.rec + (Bool.rec + (rec (Nat.add acc 1) (Nat.shiftRight m 3)) + (rec (Nat.add acc 4) (Nat.shiftRight m 12)) + (Nat.beq (Nat.land m 4095) 585)) + (rec (Nat.add acc 16) (Nat.shiftRight m 48)) + (Nat.beq (Nat.land m 281474976710655) 40210710958665) + +noncomputable def collectM_step {α : Type} (cont : Nat → Nat → α) + (rec : Nat → Nat → α) (acc m : Nat) : α := + Bool.rec (cont acc m) (collectM_hit rec acc m) (Nat.beq (Nat.land m 7) 1) + +noncomputable def collectM {α : Type} (fuel : Nat) (cont : Nat → Nat → α) : Nat → Nat → α := + Nat.rec cont (fun _ => collectM_step cont) fuel + +noncomputable def evalG_b00 (rec : ModeM → Nat → Result Nat) (k m : Nat) : Result Nat := + let b23 := Nat.land (Nat.shiftRight m 2) 3 + Bool.rec + (Bool.rec + (retM (prependU k (Nat.add 21 (Nat.shiftLeft (Nat.shiftRight m 4) 5)))) + (mapRetM (callH rec 1 (Nat.shiftRight m 4)) + (fun r => retM (prependU k (Nat.add 17 (Nat.shiftLeft r 5))))) + (Nat.beq b23 2)) + (mapRetM (callM rec .G (Nat.shiftRight m 3)) + (fun r => retM (prependU k (Nat.add 1 (Nat.shiftLeft r 3))))) + (Nat.beq (Nat.land b23 1) 1) + +noncomputable def evalG_k (rec : ModeM → Nat → Result Nat) (k m : Nat) : Result Nat := + let b01 := Nat.land m 3 + Bool.rec + (Bool.rec + (Bool.rec + (evalG_b00 rec k m) + (retM (prependU k (Nat.add 1 (Nat.shiftLeft (Nat.shiftRight m 2) 3)))) + (Nat.beq b01 2)) + (mapRetM (callH rec 1 (Nat.shiftRight m 2)) + (fun r => retM (prependU k (Nat.add 1 (Nat.shiftLeft r 3))))) + (Nat.beq b01 1)) + .stopped + (Nat.beq b01 3) + +noncomputable def evalG (rec : ModeM → Nat → Result Nat) (m0 : Nat) : Result Nat := + Bool.rec + (evalG_k rec 0 m0) + (sweepP 64 (evalG_k rec) 1 (Nat.shiftRight m0 3)) + (Nat.beq (Nat.land m0 7) 4) + +noncomputable def evalJ_k (rec : ModeM → Nat → Result Nat) (k m : Nat) : Result Nat := + Bool.rec + (Bool.rec + (retM (prependU k (Nat.add 5 (Nat.shiftLeft (Nat.shiftRight m 2) 3)))) + (mapRetM (callH rec 1 (Nat.shiftRight m 2)) + (fun r => retM (prependU k (Nat.add 1 (Nat.shiftLeft r 3))))) + (Nat.beq (Nat.land m 2) 2)) + (mapRetM (callM rec .L (Nat.shiftRight m 1)) + (fun out0 => retM (prependU k out0))) + (Nat.beq (Nat.land m 1) 1) + +noncomputable def evalJ (rec : ModeM → Nat → Result Nat) (m0 : Nat) : Result Nat := + Bool.rec + (evalJ_k rec 0 m0) + (sweepO 64 (evalJ_k rec) 1 (Nat.shiftRight m0 3)) + (Nat.beq (Nat.land m0 7) 5) + +noncomputable def evalL_u_p_md0 (kp ku ms : Nat) : ResL := + let kout := Nat.add ku (Nat.add kp 3) + let z := Nat.shiftRight ms 4 + Bool.rec + (retLUH kout (Nat.add kp 3) z) + (retLUH kout (Nat.add kp 1) z) + (Nat.beq (Nat.land ms 15) 0) + +noncomputable def evalL_u_p_md2 (kp ku ms : Nat) : ResL := + let z := Nat.shiftRight ms 4 + Bool.rec + (retLUH (Nat.add ku (Nat.add kp 3)) (Nat.add kp 2) z) + (Bool.rec + (retLUH (Nat.add ku (Nat.add kp 3)) kp z) + (retLU (Nat.add ku 1) (Nat.add 33 (Nat.shiftLeft z 6))) + (Nat.beq kp 0)) + (Nat.beq (Nat.land ms 15) 2) + +noncomputable def evalL_u_p_gen (rec : ModeM → Nat → Result Nat) (kp ku ms : Nat) : ResL := + mapRetL (evalG rec ms) + (fun r => mapRetL (evalJ rec (prependU kp r)) + (fun r2 => retLU (Nat.add ku 1) r2)) + +noncomputable def evalL_u_p (rec : ModeM → Nat → Result Nat) (kp ku ms : Nat) : ResL := + let md3 := Nat.land ms 7 + Bool.rec + (Bool.rec (evalL_u_p_gen rec kp ku ms) (evalL_u_p_md2 kp ku ms) (Nat.beq md3 2)) + (evalL_u_p_md0 kp ku ms) + (Nat.beq md3 0) + +noncomputable def evalL_u_k_non4 (rec : ModeM → Nat → Result Nat) (ku0 m : Nat) : ResL := + let b01 := Nat.land m 3 + Bool.rec + (Bool.rec + (Bool.rec + (Bool.rec + (retLU ku0 (Nat.add 33 (Nat.shiftLeft (Nat.shiftRight m 4) 6))) + (retLUH (Nat.add ku0 2) 2 (Nat.shiftRight m 4)) + (Nat.beq (Nat.land m 15) 8)) + (Bool.rec + (mapRetL (evalJ rec (Nat.shiftRight m 2)) + (fun r2 => retLU (Nat.add ku0 1) r2)) + (retLU ku0 (Nat.add 41 (Nat.shiftLeft (Nat.shiftRight m 4) 6))) + (Nat.beq (Nat.land m 15) 2)) + (Nat.beq b01 2)) + (mapRetL (callH rec 1 (Nat.shiftRight m 2)) + (fun r => mapRetL (evalJ rec r) + (fun r2 => retLU (Nat.add ku0 1) r2))) + (Nat.beq b01 1)) + .stopped + (Nat.beq b01 3) + +noncomputable def evalL_u_k (rec : ModeM → Nat → Result Nat) (ku0 m : Nat) : ResL := + Bool.rec + (evalL_u_k_non4 rec ku0 m) + (sweepLP 64 (evalL_u_p rec) 0 ku0 (Nat.shiftRight m 3)) + (Nat.beq (Nat.land m 7) 4) + +noncomputable def evalL_u (rec : ModeM → Nat → Result Nat) (m0 : Nat) : ResL := + Bool.rec + (evalL_u_k rec 0 m0) + (sweep6 64 (evalL_u_k rec) 1 (Nat.shiftRight m0 3)) + (Nat.beq (Nat.land m0 7) 6) + +noncomputable def evalL (rec : ModeM → Nat → Result Nat) (m0 : Nat) : Result Nat := + ResL.rec .failed .stopped + (fun k x => retM (prependU k x)) + (fun k c z => + Bool.rec + (mapRetM (callH rec c z) (fun r => retM (prependU k r))) + (retM (prependU k z)) + (Nat.beq c 0)) + (evalL_u rec m0) + +noncomputable def finishUH (rec : ModeM → Nat → Result Nat) (k c n z : Nat) : Result Nat := + let ctot := Nat.add c (carryK k n) + Bool.rec + (mapRetM (callH rec ctot z) (fun r2 => retM (prependDigitsK k n r2))) + (retM (prependDigitsK k n z)) + (Nat.beq ctot 0) + +noncomputable def evalHL_fast2 (rec : ModeM → Nat → Result Nat) (base n z2 : Nat) : Result Nat := + let s2 := Nat.add base n + let dig2 := enc2 (Nat.land s2 15) + let qn2 := Nat.shiftRight s2 4 + Bool.rec + (mapRetM (callH rec qn2 z2) (fun r2 => retM (Nat.add dig2 (Nat.shiftLeft r2 6)))) + (retM (Nat.add dig2 (Nat.shiftLeft z2 6))) + (Nat.beq qn2 0) + +noncomputable def evalHL_gen (rec : ModeM → Nat → Result Nat) (n y : Nat) : Result Nat := + ResL.rec .failed .stopped + (fun k x => finishUH rec k 0 n x) + (fun k c z => finishUH rec k c n z) + (evalL_u rec y) + +noncomputable def evalHL (rec : ModeM → Nat → Result Nat) (n y : Nat) : Result Nat := + let d4 := Nat.land y 15 + Bool.rec + (Bool.rec + (evalHL_gen rec n y) + (evalHL_fast2 rec 12 n (Nat.shiftRight y 4)) + (Nat.beq d4 0)) + (evalHL_fast2 rec 8 n (Nat.shiftRight y 4)) + (Nat.beq d4 2) + +noncomputable def evalH_inv (rec : ModeM → Nat → Result Nat) (n m0 : Nat) : Result Nat := + Bool.rec + (evalHL rec (Nat.sub n 1) (Nat.shiftRight m0 2)) + (Bool.rec + (evalHL rec (Nat.sub n 2) (Nat.shiftRight m0 2)) + (retM (Nat.add 2 (Nat.shiftLeft (Nat.shiftRight m0 2) 2))) + (Nat.beq n 1)) + (Nat.beq (Nat.land m0 1) 1) + +noncomputable def evalH_w1 (rec : ModeM → Nat → Result Nat) (s z : Nat) : Result Nat := + let dig := enc1 (Nat.land s 3) + mapRetM (evalH_inv rec (Nat.shiftRight s 2) z) + (fun r2 => retM (Nat.add dig (Nat.shiftLeft r2 3))) + +noncomputable def evalH_w2 (rec : ModeM → Nat → Result Nat) (n m0 : Nat) : Result Nat := + let s2 := Nat.add (dec2 (Nat.land m0 63)) n + let dig2 := enc2 (Nat.land s2 15) + let qn2 := Nat.shiftRight s2 4 + let z2 := Nat.shiftRight m0 6 + Bool.rec + (Bool.rec + (mapRetM (evalH_inv rec qn2 z2) (fun r2 => retM (Nat.add dig2 (Nat.shiftLeft r2 6)))) + (mapRetM (callH rec qn2 z2) (fun r2 => retM (Nat.add dig2 (Nat.shiftLeft r2 6)))) + (Nat.beq (Nat.land z2 2) 0)) + (retM (Nat.add dig2 (Nat.shiftLeft z2 6))) + (Nat.beq qn2 0) + +noncomputable def evalH_w4 (rec : ModeM → Nat → Result Nat) (n m0 : Nat) : Result Nat := + let s4 := Nat.add (dec4 (Nat.land m0 4095)) n + let dig4 := enc4 (Nat.land s4 255) + let qn4 := Nat.shiftRight s4 8 + let z4 := Nat.shiftRight m0 12 + Bool.rec + (mapRetM (callH rec qn4 z4) (fun r2 => retM (Nat.add dig4 (Nat.shiftLeft r2 12)))) + (retM (Nat.add dig4 (Nat.shiftLeft z4 12))) + (Nat.beq qn4 0) + +noncomputable def evalH_w12 (rec : ModeM → Nat → Result Nat) (n m0 : Nat) : Result Nat := + let s12 := Nat.add (dec12_3x4 (Nat.land m0 68719476735)) n + let dig12 := enc12_3x4 (Nat.land s12 16777215) + let qn12 := Nat.shiftRight s12 24 + let z12 := Nat.shiftRight m0 36 + Bool.rec + (mapRetM (callH rec qn12 z12) (fun r2 => retM (Nat.add dig12 (Nat.shiftLeft r2 36)))) + (retM (Nat.add dig12 (Nat.shiftLeft z12 36))) + (Nat.beq qn12 0) + +noncomputable def evalH_wide (rec : ModeM → Nat → Result Nat) (n m0 : Nat) : Result Nat := + Bool.rec + (evalH_w1 rec (Nat.add (dec1 (Nat.land m0 7)) n) (Nat.shiftRight m0 3)) + (Bool.rec + (evalH_w2 rec n m0) + (Bool.rec + (evalH_w4 rec n m0) + (evalH_w12 rec n m0) + (Bool.rec false (ok12_hi m0) (Nat.ble 256 n))) + (Nat.beq (Nat.land m0 1170) 0)) + (Nat.beq (Nat.land m0 18) 0) + +noncomputable def evalH_valid (rec : ModeM → Nat → Result Nat) (n m0 : Nat) : Result Nat := + let s := Nat.add (dec1 (Nat.land m0 7)) n + Bool.rec + (evalH_wide rec n m0) + (retM (Nat.add (enc1 s) (Nat.shiftLeft (Nat.shiftRight m0 3) 3))) + (Nat.ble s 3) + +noncomputable def evalH (rec : ModeM → Nat → Result Nat) (n m0 : Nat) : Result Nat := + Bool.rec + (Bool.rec (evalH_inv rec n m0) (evalH_valid rec n m0) (Nat.beq (Nat.land m0 2) 0)) + (retM m0) + (Nat.beq n 0) + +noncomputable def evalT_step (rec : ModeM → Nat → + Result Nat) (md : ModeM) (m0 : Nat) : Result Nat := + ModeM.rec (evalG rec m0) (evalL rec m0) (fun n => evalH rec n m0) md + +noncomputable def evalT (fuel : Nat) : ModeM → Nat → Result Nat := + Nat.rec (fun _ _ => .failed) (fun _ => evalT_step) fuel + +noncomputable def mapRetP (o : ResP) (k : Nat → Nat → ResP) : ResP := + ResP.rec .failed .stopped k o + +noncomputable def evalToP (o : Result Nat) (k : Nat → ResP) : ResP := + Result.rec .failed .stopped k o + +noncomputable def tcallT_even (ev : ModeM → Nat → Result Nat) (a ko m1 : Nat) : ResP := + let y := Nat.shiftRight m1 2 + Bool.rec + (evalToP (evalH ev (Nat.add a 1) y) + (fun s => retP (Nat.add ko (Nat.add a 1)) s)) + (Bool.rec + (Bool.rec + (evalToP (evalH ev (Nat.sub a 1) y) + (fun s => retP (Nat.add ko (Nat.add a 1)) s)) + (retP (Nat.add ko 1) (Nat.add 4 (Nat.shiftLeft y 3))) + (Nat.beq a 1)) + (retP ko (Nat.add 5 (Nat.shiftLeft y 3))) + (Nat.beq a 0)) + (Nat.beq (Nat.land m1 3) 0) + +noncomputable def tcallT_odd (ev : ModeM → Nat → Result Nat) (rec : Nat → Nat → + ResP) (a ko m1 : Nat) : ResP := + let d3 := Nat.land m1 7 + let z := Nat.shiftRight m1 3 + Bool.rec + (Bool.rec + (Bool.rec + .stopped + (evalToP (evalH ev 1 z) + (fun r => mapRetP (rec a r) + (fun pa pm => retP (Nat.add (Nat.add ko 1) pa) pm))) + (Nat.beq d3 3)) + (mapRetP (rec a z) + (fun pa pm => retP (Nat.add (Nat.add ko 1) pa) pm)) + (Nat.beq d3 5)) + (collectM 64 (fun ku zm => mapRetP (rec (Nat.add a ku) zm) (fun pa pm => + retP (Nat.add ko pa) pm)) 1 z) + (Nat.beq d3 1) + +noncomputable def tcallT_k (ev : ModeM → Nat → Result Nat) (rec : Nat → Nat → + ResP) (a ko m1 : Nat) : ResP := + Bool.rec + (tcallT_odd ev rec a ko m1) + (tcallT_even ev a ko m1) + (Nat.beq (Nat.land m1 1) 0) + +noncomputable def tcallT_step (ev : ModeM → Nat → Result Nat) (rec : Nat → Nat → + ResP) (a m : Nat) : ResP := + Bool.rec + (tcallT_k ev rec a 0 m) + (sweepO 64 (tcallT_k ev rec a) 1 (Nat.shiftRight m 3)) + (Nat.beq (Nat.land m 7) 5) + +noncomputable def tcallT (fuel : Nat) (ev : ModeM → Nat → Result Nat) : Nat → Nat → ResP := + Nat.rec (fun _ _ => .failed) (fun _ => tcallT_step ev) fuel + +noncomputable def roundT_col1 (pa ca cm : Nat) : ResP := + retP (Nat.add (Nat.add 1 pa) ca) cm + +noncomputable def roundT_finish (pa pm : Nat) : ResP := + Bool.rec + (retP (Nat.add 1 pa) pm) + (collectM 64 (roundT_col1 pa) 1 (Nat.shiftRight pm 3)) + (Nat.beq (Nat.land pm 7) 1) + +noncomputable def roundT_tcall (tfuel : Nat) (ev : ModeM → Nat → Result Nat) (a m : Nat) : ResP := + mapRetP (tcallT tfuel ev (Nat.sub a 1) m) roundT_finish + +noncomputable def roundT_fast00 (ev : ModeM → Nat → Result Nat) (a m : Nat) : ResP := + evalToP (evalH ev (Nat.sub a 2) (Nat.shiftRight m 2)) (roundT_finish a) + +noncomputable def roundT_a0 (ev : ModeM → Nat → Result Nat) (m : Nat) : ResP := + evalToP (evalG ev m) (fun r => collectM 64 retP 0 r) + +noncomputable def roundT (tfuel : Nat) (ev : ModeM → Nat → Result Nat) (a m : Nat) : ResP := + Bool.rec + (Bool.rec (roundT_tcall tfuel ev a m) (roundT_fast00 ev a m) (Nat.beq (Nat.land m 3) 0)) + (Bool.rec (roundT_tcall tfuel ev a m) (roundT_a0 ev m) (Nat.beq a 0)) + (Nat.ble a 2) + +noncomputable def runT_step (tfuel : Nat) (ev : ModeM → Nat → Result Nat) (rec : Nat → Nat → + ResP) (a m : Nat) : ResP := + mapRetP (roundT tfuel ev a m) rec + +noncomputable def runT (fuel tfuel efuel : Nat) : Nat → Nat → ResP := + Nat.rec (motive := fun _ => Nat → Nat → ResP) retP (fun _ => runT_step tfuel (evalT efuel)) fuel + +noncomputable def runT_chk (fuel a m ta tm_exp : Nat) : Bool := + ResP.rec false false + (fun a' m' => Bool.rec false (Nat.beq m' tm_exp) (Nat.beq a' ta)) + (runT fuel 64 256 a m) + +noncomputable def runT_halt (fuel a m : Nat) : Bool := + ResP.rec false true (fun _ _ => false) (runT fuel 64 256 a m) + +/-! ## Soundness Proofs for `prependU`, `prependDigitsK`, Multi-Width SWAR, and Sweeps -/ + +private theorem retM_eq (x : Nat) : retM x = .returned x := rfl +private theorem retLU_eq (k r : Nat) : retLU k r = .retU k r := rfl +private theorem retLUH_eq (k c z : Nat) : retLUH k c z = .retUH k c z := rfl +private theorem retP_eq (a m : Nat) : retP a m = .ret a m := rfl +private theorem callM_eq (rec : ModeM → Nat → Result Nat) (md : ModeM) (m : Nat) : + callM rec md m = rec md m := rfl +private theorem callH_eq (rec : ModeM → Nat → Result Nat) (n m : Nat) : + callH rec n m = rec (.H n) m := rfl + +private def prependU_raw (k r : Nat) : Nat := (8 ^ k - 1) / 7 + 8 ^ k * r + +private theorem pow2_3k (k : Nat) : 2 ^ (3 * k) = 8 ^ k := by + rw [Nat.pow_mul] + +private theorem prependU_eq_raw (k r : Nat) : prependU k r = prependU_raw k r := by + rcases k with _ | k + · simp [prependU, prependU_raw] + · change (Nat.shiftLeft 1 (3 * (k + 1)) - 1) / 7 + Nat.shiftLeft r (3 * (k + 1)) = + (8 ^ (k + 1) - 1) / 7 + 8 ^ (k + 1) * r + rw [shl_eq, shl_eq, pow2_3k, Nat.mul_one] + +private theorem pow8_mod7 (k : Nat) : 8 ^ k % 7 = 1 ∧ 1 ≤ 8 ^ k := by + induction k with + | zero => decide + | succ k ih => + rw [Nat.pow_succ] + omega + +private theorem prependU_raw_succ (k r : Nat) : + prependU_raw (k + 1) r = 1 + 8 * prependU_raw k r := by + unfold prependU_raw + rw [Nat.pow_succ] + obtain ⟨hm, hp⟩ := pow8_mod7 k + have hmul : (8 ^ k * 8) * r = 8 * (8 ^ k * r) := by ring + rw [hmul] + omega + +theorem bitsM_prependU (k r : Nat) : bitsM (prependU k r) = U ^ k +> bitsM r := by + rw [prependU_eq_raw] + induction k with + | zero => simp [prependU_raw] + | succ k ih => + rw [prependU_raw_succ, bitsM_U, ih, pow_succ_list, append_assoc] + +theorem bitsM_enc1 (p z : Nat) (hp : p < 4) : + bitsM (enc1 p + 8 * z) = digit p +> bitsM z := by + rcases p with _ | _ | _ | _ | p <;> try omega + · exact bitsM_U z + · change bitsM (0 + 8 * z) = Z +> bitsM z + rw [Nat.zero_add]; exact bitsM_Z z + · exact bitsM_O z + · exact bitsM_P z + +theorem dec1_lt4 (d3 : Nat) (hd : d3 < 8) (hm : Nat.land d3 2 = 0) : + dec1 d3 < 4 ∧ enc1 (dec1 d3) = d3 := by + rcases d3 with _ | _ | _ | _ | _ | _ | _ | _ | d3 <;> try omega + all_goals + revert hm + decide + +def digits2 (v : Nat) : List (Fin 2) := digit (v % 4) ++ digit (v / 4) +def digits4 (v : Nat) : List (Fin 2) := digits2 (v % 16) ++ digits2 (v / 16) +def digits12 (v : Nat) : List (Fin 2) := + digits4 (v % 256) ++ (digits4 ((v / 256) % 256) ++ digits4 (v / 65536)) + +private theorem enc2_fin : ∀ v : Fin 16, enc2 v.val = enc1 (v.val % 4) + 8 * enc1 (v.val / 4) := by + decide +kernel + +private theorem dec2_fin : ∀ x : Fin 64, + Nat.land x.val 18 = 0 → dec2 x.val < 16 ∧ enc2 (dec2 x.val) = x.val := by + decide +kernel + +private theorem enc4_fin : ∀ v : Fin 256, enc4 v.val = enc2 (v.val % 16) + 64 * enc2 (v.val / 16) := + by + decide +kernel + +private theorem dec4_fin : ∀ hi : Fin 64, ∀ lo : Fin 64, + Nat.land (64 * hi.val + lo.val) 1170 = 0 → + dec4 (64 * hi.val + lo.val) < 256 ∧ enc4 (dec4 (64 * hi.val + lo.val)) = 64 * hi.val + lo.val := + by + decide +kernel + +theorem bitsM_enc2 (v z : Nat) (hv : v < 16) : + bitsM (enc2 v + 64 * z) = digits2 v +> bitsM z := by + have hf := enc2_fin ⟨v, hv⟩ + dsimp only at hf + have heq : enc2 v + 64 * z = enc1 (v % 4) + 8 * (enc1 (v / 4) + 8 * z) := by omega + unfold digits2 + rw [heq, bitsM_enc1 (v % 4) _ (by omega), bitsM_enc1 (v / 4) z (by omega), append_assoc] + +theorem bitsM_dec2 (m0 : Nat) (hm : Nat.land m0 18 = 0) : + dec2 (m0 % 64) < 16 ∧ bitsM m0 = digits2 (dec2 (m0 % 64)) +> bitsM (m0 / 64) := by + have hm' : Nat.land (m0 % 64) 18 = 0 := by rw [← land_18]; exact hm + obtain ⟨hlt, henc⟩ := dec2_fin ⟨m0 % 64, by omega⟩ hm' + dsimp only at hlt henc + refine ⟨hlt, ?_⟩ + exact bitsM_eq_of_eq m0 (by omega) (bitsM_enc2 (dec2 (m0 % 64)) (m0 / 64) hlt) + +theorem bitsM_enc4 (v z : Nat) (hv : v < 256) : + bitsM (enc4 v + 4096 * z) = digits4 v +> bitsM z := by + have hf := enc4_fin ⟨v, hv⟩ + dsimp only at hf + have heq : enc4 v + 4096 * z = enc2 (v % 16) + 64 * (enc2 (v / 16) + 64 * z) := by omega + unfold digits4 + rw [heq, bitsM_enc2 (v % 16) _ (by omega), bitsM_enc2 (v / 16) z (by omega), append_assoc] + +theorem bitsM_dec4 (m0 : Nat) (hm : Nat.land m0 1170 = 0) : + dec4 (m0 % 4096) < 256 ∧ bitsM m0 = digits4 (dec4 (m0 % 4096)) +> bitsM (m0 / 4096) := by + have hsplit : 64 * ((m0 % 4096) / 64) + (m0 % 4096) % 64 = m0 % 4096 := by omega + have hm' : Nat.land (64 * ((m0 % 4096) / 64) + (m0 % 4096) % 64) 1170 = 0 := by + rw [hsplit, ← land_1170]; exact hm + obtain ⟨hlt, henc⟩ := dec4_fin ⟨(m0 % 4096) / 64, by omega⟩ ⟨(m0 % 4096) % 64, by omega⟩ hm' + dsimp only at hlt henc + rw [hsplit] at hlt henc + refine ⟨hlt, ?_⟩ + exact bitsM_eq_of_eq m0 (by omega) (bitsM_enc4 (dec4 (m0 % 4096)) (m0 / 4096) hlt) + +theorem bitsM_enc12 (v z : Nat) (hv : v < 16777216) : + bitsM (enc12_3x4 v + 68719476736 * z) = digits12 v +> bitsM z := by + unfold enc12_3x4 digits12 + simp only [Nat.add_eq, shr_8, shr_16, shl_12, shl_24, land_255] + have htop : (v / 65536) % 256 = v / 65536 := Nat.mod_eq_of_lt (by omega) + rw [htop] + have heq2 : enc4 (v % 256) + (4096 * enc4 ((v / 256) % 256) + 16777216 * enc4 (v / 65536)) + + 68719476736 * z = + enc4 (v % 256) + 4096 * (enc4 ((v / 256) % 256) + 4096 * (enc4 (v / 65536) + 4096 * z)) := by + ring + rw [heq2, + bitsM_enc4 (v % 256) _ (by omega), + bitsM_enc4 ((v / 256) % 256) _ (by omega), + bitsM_enc4 (v / 65536) z (by omega), + append_assoc, append_assoc] + +theorem ok12_hi_elim {m0 : Nat} (hok : ok12_hi m0 = true) : + Nat.land (m0 / 4096) 1170 = 0 ∧ + Nat.land (m0 / 16777216) 1170 = 0 := by + unfold ok12_hi at hok + simp only [shr_12, shr_24] at hok + cases h1 : Nat.beq (Nat.land (m0 / 4096) 1170) 0 with + | false => rw [h1] at hok; cases hok + | true => + rw [h1] at hok; dsimp only at hok + exact ⟨Nat.eq_of_beq_eq_true h1, Nat.eq_of_beq_eq_true hok⟩ + +theorem bitsM_dec12 (m0 : Nat) (hm0 : Nat.land m0 1170 = 0) (hok : ok12_hi m0 = true) : + dec12_3x4 (Nat.land m0 68719476735) < 16777216 ∧ + bitsM m0 = digits12 (dec12_3x4 (Nat.land m0 68719476735)) +> bitsM (m0 / 68719476736) := by + obtain ⟨hm1, hm2⟩ := ok12_hi_elim hok + obtain ⟨hv0, hb0⟩ := bitsM_dec4 m0 hm0 + obtain ⟨hv1, hb1⟩ := bitsM_dec4 (m0 / 4096) hm1 + obtain ⟨hv2, hb2⟩ := bitsM_dec4 (m0 / 16777216) hm2 + have hd : dec12_3x4 (Nat.land m0 68719476735) = + dec4 (m0 % 4096) + 256 * dec4 ((m0 / 4096) % 4096) + 65536 * dec4 ((m0 / 16777216) % 4096) := + by + unfold dec12_3x4 + simp only [Nat.add_eq, shr_12, shr_24, shl_8, shl_16, land_68719476735, land_4095] + have e0 : (m0 % 68719476736) % 4096 = m0 % 4096 := by omega + have e1 : ((m0 % 68719476736) / 4096) % 4096 = (m0 / 4096) % 4096 := by omega + have e2 : ((m0 % 68719476736) / 16777216) % 4096 = (m0 / 16777216) % 4096 := by omega + rw [e0, e1, e2]; omega + refine ⟨by omega, ?_⟩ + rw [hd] + unfold digits12 + have f0 : (dec4 (m0 % 4096) + 256 * dec4 ((m0 / 4096) % 4096) + 65536 * dec4 ((m0 / 16777216) % + 4096)) % 256 = + dec4 (m0 % 4096) := by omega + have f1 : ((dec4 (m0 % 4096) + 256 * dec4 ((m0 / 4096) % 4096) + 65536 * dec4 ((m0 / 16777216) % + 4096)) / 256) % 256 = + dec4 ((m0 / 4096) % 4096) := by omega + have f2 : (dec4 (m0 % 4096) + 256 * dec4 ((m0 / 4096) % 4096) + 65536 * dec4 ((m0 / 16777216) % + 4096)) / 65536 = + dec4 ((m0 / 16777216) % 4096) := by omega + have g1 : (m0 / 4096) / 4096 = m0 / 16777216 := by omega + have g2 : (m0 / 16777216) / 4096 = m0 / 68719476736 := by omega + rw [f0, f1, f2, hb0, hb1, g1, hb2, g2, append_assoc, append_assoc] + +theorem digits2_count (v n : ℕ) (hv : v < 16) : + SegRLs tm (h ^ n) (h ^ ((v + n) / 16)) (digits2 v) (digits2 ((v + n) % 16)) := by + unfold digits2 + have h0 := digit_count (v % 4) n (by omega) + have h1 := digit_count (v / 4) ((v % 4 + n) / 4) (by omega) + have hc := h0.concat h1 + have e1 : (v / 4 + (v % 4 + n) / 4) / 4 = (v + n) / 16 := by omega + have e2 : (v % 4 + n) % 4 = ((v + n) % 16) % 4 := by omega + have e3 : (v / 4 + (v % 4 + n) / 4) % 4 = ((v + n) % 16) / 4 := by omega + rwa [e1, e2, e3] at hc + +theorem digits4_count (v n : ℕ) (hv : v < 256) : + SegRLs tm (h ^ n) (h ^ ((v + n) / 256)) (digits4 v) (digits4 ((v + n) % 256)) := by + unfold digits4 + have h0 := digits2_count (v % 16) n (by omega) + have h1 := digits2_count (v / 16) ((v % 16 + n) / 16) (by omega) + have hc := h0.concat h1 + have e1 : (v / 16 + (v % 16 + n) / 16) / 16 = (v + n) / 256 := by omega + have e2 : (v % 16 + n) % 16 = ((v + n) % 256) % 16 := by omega + have e3 : (v / 16 + (v % 16 + n) / 16) % 16 = ((v + n) % 256) / 16 := by omega + rwa [e1, e2, e3] at hc + +theorem digits12_count (v n : ℕ) (hv : v < 16777216) : + SegRLs tm (h ^ n) (h ^ ((v + n) / 16777216)) (digits12 v) (digits12 ((v + n) % 16777216)) := by + unfold digits12 + have h0 := digits4_count (v % 256) n (by omega) + have h1 := digits4_count ((v / 256) % 256) ((v % 256 + n) / 256) (by omega) + have h2 := digits4_count (v / 65536) (((v / 256) % 256 + (v % 256 + n) / 256) / 256) (by omega) + have hc := h0.concat (h1.concat h2) + have e1 : (v / 65536 + ((v / 256) % 256 + (v % 256 + n) / 256) / 256) / 256 = + (v + n) / 16777216 := by omega + have e2 : (v % 256 + n) % 256 = ((v + n) % 16777216) % 256 := by omega + have e3 : ((v / 256) % 256 + (v % 256 + n) / 256) % 256 = (((v + n) % 16777216) / 256) % 256 := by + omega + have e4 : (v / 65536 + ((v / 256) % 256 + (v % 256 + n) / 256) / 256) % 256 = + ((v + n) % 16777216) / 65536 := by omega + rwa [e1, e2, e3, e4] at hc + +private theorem carryK_eq (k n : Nat) : carryK k n = n / 2 ^ (2 * k) := by + unfold carryK + rw [Nat.mul_eq, shr_eq] + +private theorem div_pow_step (n d k : Nat) (hdk : d ≤ k) : + (n / 2 ^ (2 * d)) / 2 ^ (2 * (k - d)) = n / 2 ^ (2 * k) := by + rw [Nat.div_div_eq_div_mul, ← Nat.pow_add] + have he : 2 * d + 2 * (k - d) = 2 * k := by omega + rw [he] + +private theorem prependDigitsK_aux_spec (fuel k n : Nat) (hfk : k ≤ fuel) : + ∃ v : List (Fin 2), + SegRLs tm (h ^ n) (h ^ (n / 2 ^ (2 * k))) (U ^ k) v ∧ + ∀ r2, bitsM (prependDigitsK_aux fuel k n r2) = v +> bitsM r2 := by + induction fuel generalizing k n with + | zero => + have hk0 : k = 0 := by omega + subst hk0 + refine ⟨[], ?_, fun r2 => by simp [prependDigitsK_aux, prependU]⟩ + simpa using SegRLs.empty tm (h ^ n) + | succ fuel ih => + change ∃ v, SegRLs tm (h ^ n) (h ^ (n / 2 ^ (2 * k))) (U ^ k) v ∧ + ∀ r2, bitsM (prependDigitsK_step (prependDigitsK_aux fuel) k n r2) = v +> bitsM r2 + unfold prependDigitsK_step + rcases k with _ | k0 + · refine ⟨[], ?_, fun r2 => rfl⟩ + simpa using SegRLs.empty tm (h ^ n) + · have hk0_f : Nat.beq (k0 + 1) 0 = false := rfl + simp only [hk0_f] + rcases n with _ | n0 + · simp only [Nat.beq, Nat.zero_div] + exact ⟨U ^ (k0 + 1), .nil (U ^ (k0 + 1)), fun r2 => bitsM_prependU (k0 + 1) r2⟩ + · have hn0_f : Nat.beq (n0 + 1) 0 = false := rfl + simp only [hn0_f] + set k := k0 + 1 + set n := n0 + 1 + cases hk12 : Nat.ble 12 k with + | true => + dsimp only [prependDigitsK_12] + have hle12 := Nat.ble_eq.mp hk12 + simp only [Nat.add_eq, Nat.sub_eq, shr_24, shl_36, land_16777215] + have hu12 : U ^ k = digits12 0 ++ U ^ (k - 12) := by + have hk : k = 12 + (k - 12) := by omega + conv_lhs => rw [hk, pow_add_list] + rfl + have hdc12 := digits12_count 0 n (by decide) + rw [Nat.zero_add] at hdc12 + have hdiv := div_pow_step n 12 k hle12 + change (n / 16777216) / 2 ^ (2 * (k - 12)) = n / 2 ^ (2 * k) at hdiv + cases hqn : Nat.beq (n / 16777216) 0 with + | true => + have hq0 := Nat.eq_of_beq_eq_true hqn + have htot0 : n / 2 ^ (2 * k) = 0 := by rw [← hdiv, hq0, Nat.zero_div] + rw [hq0] at hdc12 + refine ⟨digits12 (n % 16777216) ++ U ^ (k - 12), ?_, fun r2 => ?_⟩ + · rw [hu12, htot0] + exact hdc12.concat (.nil (U ^ (k - 12))) + · dsimp only + rw [bitsM_enc12 (n % 16777216) _ (by omega), bitsM_prependU, append_assoc] + | false => + obtain ⟨v2, hseg2, hb2⟩ := ih (k - 12) (n / 16777216) (by omega) + refine ⟨digits12 (n % 16777216) ++ v2, ?_, fun r2 => ?_⟩ + · rw [hu12, ← hdiv] + exact hdc12.concat hseg2 + · dsimp only + rw [bitsM_enc12 (n % 16777216) _ (by omega), hb2, append_assoc] + | false => + dsimp only + cases hk4 : Nat.ble 4 k with + | true => + dsimp only [prependDigitsK_4] + have hle4 := Nat.ble_eq.mp hk4 + simp only [Nat.add_eq, Nat.sub_eq, shr_8, shl_12, land_255] + have hu4 : U ^ k = digits4 0 ++ U ^ (k - 4) := by + have hk : k = 4 + (k - 4) := by omega + conv_lhs => rw [hk, pow_add_list] + rfl + have hdc4 := digits4_count 0 n (by decide) + rw [Nat.zero_add] at hdc4 + have hdiv := div_pow_step n 4 k hle4 + change (n / 256) / 2 ^ (2 * (k - 4)) = n / 2 ^ (2 * k) at hdiv + cases hqn : Nat.beq (n / 256) 0 with + | true => + have hq0 := Nat.eq_of_beq_eq_true hqn + have htot0 : n / 2 ^ (2 * k) = 0 := by rw [← hdiv, hq0, Nat.zero_div] + rw [hq0] at hdc4 + refine ⟨digits4 (n % 256) ++ U ^ (k - 4), ?_, fun r2 => ?_⟩ + · rw [hu4, htot0] + exact hdc4.concat (.nil (U ^ (k - 4))) + · dsimp only + rw [bitsM_enc4 (n % 256) _ (by omega), bitsM_prependU, append_assoc] + | false => + obtain ⟨v2, hseg2, hb2⟩ := ih (k - 4) (n / 256) (by omega) + refine ⟨digits4 (n % 256) ++ v2, ?_, fun r2 => ?_⟩ + · rw [hu4, ← hdiv] + exact hdc4.concat hseg2 + · dsimp only + rw [bitsM_enc4 (n % 256) _ (by omega), hb2, append_assoc] + | false => + dsimp only + cases hk2 : Nat.ble 2 k with + | true => + dsimp only [prependDigitsK_2] + have hle2 := Nat.ble_eq.mp hk2 + simp only [Nat.add_eq, Nat.sub_eq, shr_4, shl_6, land_15] + have hu2 : U ^ k = digits2 0 ++ U ^ (k - 2) := by + have hk : k = 2 + (k - 2) := by omega + conv_lhs => rw [hk, pow_add_list] + rfl + have hdc2 := digits2_count 0 n (by decide) + rw [Nat.zero_add] at hdc2 + have hdiv := div_pow_step n 2 k hle2 + change (n / 16) / 2 ^ (2 * (k - 2)) = n / 2 ^ (2 * k) at hdiv + cases hqn : Nat.beq (n / 16) 0 with + | true => + have hq0 := Nat.eq_of_beq_eq_true hqn + have htot0 : n / 2 ^ (2 * k) = 0 := by rw [← hdiv, hq0, Nat.zero_div] + rw [hq0] at hdc2 + refine ⟨digits2 (n % 16) ++ U ^ (k - 2), ?_, fun r2 => ?_⟩ + · rw [hu2, htot0] + exact hdc2.concat (.nil (U ^ (k - 2))) + · dsimp only + rw [bitsM_enc2 (n % 16) _ (by omega), bitsM_prependU, append_assoc] + | false => + obtain ⟨v2, hseg2, hb2⟩ := ih (k - 2) (n / 16) (by omega) + refine ⟨digits2 (n % 16) ++ v2, ?_, fun r2 => ?_⟩ + · rw [hu2, ← hdiv] + exact hdc2.concat hseg2 + · dsimp only + rw [bitsM_enc2 (n % 16) _ (by omega), hb2, append_assoc] + | false => + dsimp only + have hk1 : k = 1 := by + rcases (by omega : k = 1 ∨ 2 ≤ k) with h1 | h2 + · exact h1 + · rw [Nat.ble_eq.mpr h2] at hk2; cases hk2 + simp only [Nat.add_eq, shl_3, land_3] + refine ⟨digit (n % 4), ?_, fun r2 => bitsM_enc1 (n % 4) r2 (by omega)⟩ + rw [hk1, pow_one_list] + have hdc1 := digit_count 0 n (by decide) + rw [Nat.zero_add] at hdc1 + exact hdc1 + +theorem digitsK_spec (k n : Nat) : + ∃ v : List (Fin 2), + SegRLs tm (h ^ n) (h ^ (carryK k n)) (U ^ k) v ∧ + ∀ r2, bitsM (prependDigitsK k n r2) = v +> bitsM r2 := by + rw [carryK_eq] + exact prependDigitsK_aux_spec k k n (Nat.le_refl k) + +theorem GP : SegRLs tm g g P U := segRLs_c_spec tm (T := 100) (by decide) +theorem G01 : SegRLs tm g [] [0, 1] U := segRLs_c_spec tm (T := 100) (by decide) +theorem G10 : SegRLs tm g h [1, 0] U := segRLs_c_spec tm (T := 100) (by decide) +theorem G0000 : SegRLs tm g [] [0, 0, 0, 0] [1, 0, 1, 0, 1] := segRLs_c_spec tm (T := + 100) (by decide) +theorem G0001 : SegRLs tm g h [0, 0, 0, 1] [1, 0, 0, 0, 1] := segRLs_c_spec tm (T := + 100) (by decide) + +theorem J00 : SegRLs tm j [] [0, 0] O := segRLs_c_spec tm (T := 100) (by decide) +theorem J01 : SegRLs tm j h [0, 1] U := segRLs_c_spec tm (T := 100) (by decide) + +theorem L01 : SegRLs tm e j [0, 1] U := segRLs_c_spec tm (T := 100) (by decide) +theorem L011 : SegRLs tm e e W6 U := segRLs_c_spec tm (T := 100) (by decide) +theorem L10 : SegRLs tm e (h ++ j) [1, 0] U := segRLs_c_spec tm (T := 100) (by decide) +theorem LP : SegRLs tm e (g ++ j) P U := segRLs_c_spec tm (T := 100) (by decide) +theorem L0000 : SegRLs tm e [] [0, 0, 0, 0] [1, 0, 0, 0, 0, 1] := segRLs_c_spec tm (T := + 100) (by decide) +theorem L0100 : SegRLs tm e [] [0, 1, 0, 0] [1, 0, 0, 1, 0, 1] := segRLs_c_spec tm (T := + 100) (by decide) +theorem L0001 : SegRLs tm e (h ^ 2) [0, 0, 0, 1] (U ++ U) := segRLs_c_spec tm (T := 100) (by decide) + +theorem H01rest (n : ℕ) : SegRLs tm (h ++ h ^ n) (e ++ h ^ n) [0, 1] [] := + (H0.concat J1).trans (SegRLs.empty tm (h ^ n)) + +theorem GP_run (k : ℕ) : SegRLs tm g g (P ^ k) (U ^ k) := by + induction k with + | zero => exact SegRLs.empty tm g + | succ k ih => exact GP.concat ih + +theorem JO_run (k : ℕ) : SegRLs tm j j (O ^ k) (U ^ k) := by + induction k with + | zero => exact SegRLs.empty tm j + | succ k ih => exact JO.concat ih + +theorem L011_run (k : ℕ) : SegRLs tm e e (W6 ^ k) (U ^ k) := by + induction k with + | zero => exact SegRLs.empty tm e + | succ k ih => exact L011.concat ih + +theorem U_pow_append_1 (k : ℕ) : U ^ k ++ ([1] : List (Fin 2)) = ([1] : List (Fin 2)) ++ P ^ k := by + induction k with + | zero => rfl + | succ k ih => + rw [pow_succ_list U k, List.append_assoc, ih, pow_succ_list P k] + rfl + +theorem GJP_011 {X : Type} (den : X → + ListBlank (Fin 2)) (kp : ℕ) (r : ListBlank (Fin 2)) (o : Result X) + (hS : Spec den (g ++ j) (P ^ kp +> r) o) : + Spec (fun x => U +> den x) (g ++ j) (P ^ kp +> (W6 +> r)) o := by + have hG0 : SideRLs tm g ((P ^ kp ++ [0, 1]) +> (([1] : List (Fin 2)) +> r)) + ((U ^ kp ++ U) +> (([1] : List (Fin 2)) +> r)) := + ((GP_run kp).concat G01).sideRLs_concat (.nil (([1] : List (Fin 2)) +> r)) + have hin : (P ^ kp ++ [0, 1]) +> (([1] : List (Fin 2)) +> r) = P ^ kp +> (W6 +> r) := by + rw [append_assoc]; rfl + have hout : (U ^ kp ++ U) +> (([1] : List (Fin 2)) +> r) = + ([1, 0, 0, 1] : List (Fin 2)) +> (P ^ kp +> r) := by + rw [← pow_succ_list' U kp, ← append_assoc (U ^ (kp + 1)) [1] r, + U_pow_append_1 (kp + 1), pow_succ_list P kp, ← List.append_assoc [1] P (P ^ kp), + append_assoc] + rfl + rw [hin, hout] at hG0 + have hJP : SegRLs tm j (g ++ j) [1, 0, 0, 1] U := J1.concat LP + exact after_spec (fun x => U +> den x) hG0 (rule_spec den hJP hS) + +theorem GJP_011_seg {hs' : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))} + {w v : List (Fin 2)} (kp : ℕ) + (hS : SegRLs tm (g ++ j) hs' (P ^ kp ++ w) v) : + SegRLs tm (g ++ j) hs' (P ^ kp ++ (W6 ++ w)) (U ++ v) := by + have hG0 : SegRLs tm g [] ((P ^ kp ++ [0, 1]) ++ ([1] ++ w)) ((U ^ kp ++ U) ++ ([1] ++ w)) := + ((GP_run kp).concat G01).concat (.nil ([1] ++ w)) + have hin : (P ^ kp ++ [0, 1]) ++ ([1] ++ w) = P ^ kp ++ (W6 ++ w) := by + simp only [List.append_assoc]; rfl + have hout : (U ^ kp ++ U) ++ ([1] ++ w) = ([1, 0, 0, 1] : List (Fin 2)) ++ (P ^ kp ++ w) := by + rw [← pow_succ_list' U kp, ← List.append_assoc (U ^ (kp + 1)) [1] w, + U_pow_append_1 (kp + 1), pow_succ_list P kp] + simp only [List.append_assoc]; rfl + rw [hin, hout] at hG0 + have hJP : SegRLs tm j (g ++ j) [1, 0, 0, 1] U := J1.concat LP + exact hG0.trans (hJP.concat hS) + +theorem TO_seg {hs' : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))} + {w v : List (Fin 2)} (a : ℕ) + (hS : SegRLs tm j hs' (U ^ a ++ w) v) : + SegRLs tm j hs' (U ^ a ++ (O ++ w)) (U ++ v) := by + rcases a with _ | a + · exact JO.concat hS + · have hQ : SegRLs tm q [] ((U ^ a ++ O) ++ w) (U ^ (a + 1) ++ w) := by + have h1 := (QrunO a).concat (.nil w) + have ha : 1 + a = a + 1 := by omega + rwa [ha] at h1 + have hmid := JU.concat (hQ.trans hS) + have hin : U ++ ((U ^ a ++ O) ++ w) = U ^ (a + 1) ++ (O ++ w) := by + rw [pow_succ_list U a]; simp only [List.append_assoc] + rwa [hin] at hmid + +theorem T00_seg (a : ℕ) : + SegRLs tm j (h ^ (1 + a)) (U ^ (2 + a) ++ [0, 0]) (U ^ (3 + a)) := by + have hQ : SegRLs tm q [] (U ^ (1 + a) ++ [0, 0]) (U ^ a ++ (O ++ [0, 1])) := by + simpa only [List.append_assoc] using Qrun00 a + have hJ : SegRLs tm j (h ^ (1 + a)) (U ^ a ++ (O ++ [0, 1])) (U ++ U ^ (1 + a)) := + TO_seg a (T01 a) + have hmid := JU.concat (hQ.trans hJ) + have hin : U ++ (U ^ (1 + a) ++ [0, 0]) = U ^ (2 + a) ++ [0, 0] := by + have h2 : 2 + a = (1 + a) + 1 := by omega + rw [h2, pow_succ_list U (1 + a), List.append_assoc] + have hout : U ++ (U ++ U ^ (1 + a)) = U ^ (3 + a) := by + have h3 : 3 + a = ((1 + a) + 1) + 1 := by omega + rw [h3, pow_succ_list U ((1 + a) + 1), pow_succ_list U (1 + a)] + rwa [hin, hout] at hmid + +private theorem spec_of_eq {X : Type} {den : X → ListBlank (Fin 2)} + {hs : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))} + {r : ListBlank (Fin 2)} {o1 o2 : Result X} + (hS : Spec den hs r o1) (heq : o1 = o2) : Spec den hs r o2 := + heq ▸ hS + +theorem sweepP_inv {α : Type} (P_ok : ListBlank (Fin 2) → α → Prop) + (cont : Nat → Nat → α) + (hcont : ∀ k m, P_ok (P ^ k +> bitsM m) (cont k m)) + (fuel k m : Nat) : + P_ok (P ^ k +> bitsM m) (sweepP fuel cont k m) := by + induction fuel generalizing k m with + | zero => exact hcont k m + | succ fuel ih => + change P_ok (P ^ k +> bitsM m) (sweepP_step cont (sweepP fuel cont) k m) + unfold sweepP_step sweepP_hit + simp only [Nat.add_eq, shr_eq, land_7, land_4095, land_281474976710655] + cases hd3 : Nat.beq (m % 8) 4 with + | false => exact hcont k m + | true => + dsimp only + have hm1 := Nat.eq_of_beq_eq_true hd3 + cases hd16 : Nat.beq (m % 281474976710656) 160842843834660 with + | true => + dsimp only + have hm16 := Nat.eq_of_beq_eq_true hd16 + have heq : P ^ k +> bitsM m = P ^ (k + 16) +> bitsM (m / 281474976710656) := by + rw [bitsM_eq_of_eq m (by omega) (bitsM_P16 (m / 281474976710656)), ← append_assoc, + ← pow_add_list] + rw [heq] + exact ih (k + 16) (m / 281474976710656) + | false => + dsimp only + cases hd4 : Nat.beq (m % 4096) 2340 with + | true => + dsimp only + have hm4 := Nat.eq_of_beq_eq_true hd4 + have heq : P ^ k +> bitsM m = P ^ (k + 4) +> bitsM (m / 4096) := by + rw [bitsM_eq_of_eq m (by omega) (bitsM_P4 (m / 4096)), ← append_assoc, ← pow_add_list] + rw [heq] + exact ih (k + 4) (m / 4096) + | false => + dsimp only + have heq : P ^ k +> bitsM m = P ^ (k + 1) +> bitsM (m / 8) := by + rw [bitsM_eq_of_eq m (by omega) (bitsM_P (m / 8)), ← append_assoc, ← pow_succ_list'] + rw [heq] + exact ih (k + 1) (m / 8) + +theorem sweepO_inv {α : Type} (P_ok : ListBlank (Fin 2) → α → Prop) + (cont : Nat → Nat → α) + (hcont : ∀ k m, P_ok (O ^ k +> bitsM m) (cont k m)) + (fuel k m : Nat) : + P_ok (O ^ k +> bitsM m) (sweepO fuel cont k m) := by + induction fuel generalizing k m with + | zero => exact hcont k m + | succ fuel ih => + change P_ok (O ^ k +> bitsM m) (sweepO_step cont (sweepO fuel cont) k m) + unfold sweepO_step sweepO_hit + simp only [Nat.add_eq, shr_eq, land_7, land_4095] + cases hd3 : Nat.beq (m % 8) 5 with + | false => exact hcont k m + | true => + dsimp only + have hm1 := Nat.eq_of_beq_eq_true hd3 + cases hd4 : Nat.beq (m % 4096) 2925 with + | true => + dsimp only + have hm4 := Nat.eq_of_beq_eq_true hd4 + have heq : O ^ k +> bitsM m = O ^ (k + 4) +> bitsM (m / 4096) := by + rw [bitsM_eq_of_eq m (by omega) (bitsM_O4 (m / 4096)), ← append_assoc, ← pow_add_list] + rw [heq] + exact ih (k + 4) (m / 4096) + | false => + dsimp only + have heq : O ^ k +> bitsM m = O ^ (k + 1) +> bitsM (m / 8) := by + rw [bitsM_eq_of_eq m (by omega) (bitsM_O (m / 8)), ← append_assoc, ← pow_succ_list'] + rw [heq] + exact ih (k + 1) (m / 8) + +theorem sweep6_inv {α : Type} (P_ok : ListBlank (Fin 2) → α → Prop) + (cont : Nat → Nat → α) + (hcont : ∀ k m, P_ok (W6 ^ k +> bitsM m) (cont k m)) + (fuel k m : Nat) : + P_ok (W6 ^ k +> bitsM m) (sweep6 fuel cont k m) := by + induction fuel generalizing k m with + | zero => exact hcont k m + | succ fuel ih => + change P_ok (W6 ^ k +> bitsM m) (sweep6_step cont (sweep6 fuel cont) k m) + unfold sweep6_step sweep6_hit + simp only [Nat.add_eq, shr_eq, land_7, land_63, land_4095, land_281474976710655] + cases hd3 : Nat.beq (m % 8) 6 with + | false => exact hcont k m + | true => + dsimp only + have hm1 := Nat.eq_of_beq_eq_true hd3 + cases hd16 : Nat.beq (m % 281474976710656) 241264265751990 with + | true => + dsimp only + have hm16 := Nat.eq_of_beq_eq_true hd16 + have heq : W6 ^ k +> bitsM m = W6 ^ (k + 16) +> bitsM (m / 281474976710656) := by + rw [bitsM_eq_of_eq m (by omega) (bitsM_W6_16 (m / 281474976710656)), ← append_assoc, + ← pow_add_list] + rw [heq] + exact ih (k + 16) (m / 281474976710656) + | false => + dsimp only + cases hd4 : Nat.beq (m % 4096) 3510 with + | true => + dsimp only + have hm4 := Nat.eq_of_beq_eq_true hd4 + have heq : W6 ^ k +> bitsM m = W6 ^ (k + 4) +> bitsM (m / 4096) := by + rw [bitsM_eq_of_eq m (by omega) (bitsM_W6_4 (m / 4096)), ← append_assoc, ← pow_add_list] + rw [heq] + exact ih (k + 4) (m / 4096) + | false => + dsimp only + cases hd2 : Nat.beq (m % 64) 54 with + | true => + dsimp only + have hm2 := Nat.eq_of_beq_eq_true hd2 + have heq : W6 ^ k +> bitsM m = W6 ^ (k + 2) +> bitsM (m / 64) := by + rw [bitsM_eq_of_eq m (by omega) (bitsM_W6_2 (m / 64)), ← append_assoc, ← pow_add_list] + rw [heq] + exact ih (k + 2) (m / 64) + | false => + dsimp only + have heq : W6 ^ k +> bitsM m = W6 ^ (k + 1) +> bitsM (m / 8) := by + rw [bitsM_eq_of_eq m (by omega) (bitsM_W6 (m / 8)), ← append_assoc, ← pow_succ_list'] + rw [heq] + exact ih (k + 1) (m / 8) + +/-! ## `SpecL` / `SpecLP` Specification for `sweepLP` and `evalL_u` -/ + +def SpecL (hs : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))) + (r : ListBlank (Fin 2)) (o : ResL) : Prop := + match o with + | .failed => True + | .stopped => SideRLsHalt tm hs r + | .retU k x => SideRLs tm hs r (U ^ k +> bitsM x) + | .retUH k c z => ∃ w, r = w +> bitsM z ∧ SegRLs tm hs (h ^ c) w (U ^ k) + +def SpecLP (kp ku : Nat) (r : ListBlank (Fin 2)) (o : ResL) : Prop := + match o with + | .failed => True + | .stopped => SideRLsHalt tm (g ++ j) (P ^ kp +> r) + | .retU kout x => ∃ d, kout = ku + d ∧ SideRLs tm (g ++ j) (P ^ kp +> r) (U ^ d +> bitsM x) + | .retUH kout c z => + ∃ d w, kout = ku + d ∧ r = w +> bitsM z ∧ SegRLs tm (g ++ j) (h ^ c) (P ^ kp ++ w) (U ^ d) + +private theorem specLP_shiftP {s kp ku : Nat} {r : ListBlank (Fin 2)} {o : ResL} + (hS : SpecLP (kp + s) ku r o) : + SpecLP kp ku (P ^ s +> r) o := by + cases o with + | failed => trivial + | stopped => + dsimp only [SpecLP] at hS ⊢ + rwa [← append_assoc, ← pow_add_list] + | retU kout x => + obtain ⟨d, hk, hs⟩ := hS + refine ⟨d, hk, ?_⟩ + rwa [← append_assoc, ← pow_add_list] + | retUH kout c z => + obtain ⟨d, w, hk, hr, hseg⟩ := hS + refine ⟨d, P ^ s ++ w, hk, by rw [hr, ← append_assoc], ?_⟩ + rwa [← List.append_assoc, ← pow_add_list] + +private theorem specLP_w6 {kp ku : Nat} {r : ListBlank (Fin 2)} {o : ResL} + (hS : SpecLP kp (ku + 1) r o) : + SpecLP kp ku (W6 +> r) o := by + cases o with + | failed => trivial + | stopped => exact GJP_011 (fun _ : Nat => default) kp r (.stopped : Result Nat) hS + | retU kout x => + obtain ⟨d, hkout, hSide⟩ := hS + have h1 : SideRLs tm (g ++ j) (P ^ kp +> (W6 +> r)) (U +> (U ^ d +> bitsM x)) := + GJP_011 (fun _ : Unit => U ^ d +> bitsM x) kp r (.returned ()) hSide + refine ⟨1 + d, by omega, ?_⟩ + rw [pow_add_list, pow_one_list, append_assoc] + exact h1 + | retUH kout c z => + obtain ⟨d, w, hkout, hr, hseg⟩ := hS + refine ⟨1 + d, W6 ++ w, by omega, by rw [hr, ← append_assoc], ?_⟩ + rw [pow_add_list, pow_one_list] + exact GJP_011_seg kp hseg + +private theorem specLP_w6_2 {kp ku : Nat} {r : ListBlank (Fin 2)} {o : ResL} + (hS : SpecLP kp (ku + 2) r o) : + SpecLP kp ku (W6 ^ 2 +> r) o := by + have h1 := specLP_w6 (ku := ku + 1) (by simpa [Nat.add_assoc] using hS) + have h2 := specLP_w6 (ku := ku) h1 + have hw : W6 ^ 2 +> r = W6 +> (W6 +> r) := rfl + rwa [hw] + +private theorem specLP_w6_4 {kp ku : Nat} {r : ListBlank (Fin 2)} {o : ResL} + (hS : SpecLP kp (ku + 4) r o) : + SpecLP kp ku (W6 ^ 4 +> r) o := by + have h1 := specLP_w6_2 (ku := ku + 2) (by simpa [Nat.add_assoc] using hS) + have h2 := specLP_w6_2 (ku := ku) h1 + have hw : W6 ^ 4 +> r = W6 ^ 2 +> (W6 ^ 2 +> r) := by + rw [← append_assoc]; rfl + rwa [hw] + +private theorem specLP_w6_16 {kp ku : Nat} {r : ListBlank (Fin 2)} {o : ResL} + (hS : SpecLP kp (ku + 16) r o) : + SpecLP kp ku (W6 ^ 16 +> r) o := by + have h1 := specLP_w6_4 (ku := ku + 12) (by simpa [Nat.add_assoc] using hS) + have h2 := specLP_w6_4 (ku := ku + 8) (by simpa [Nat.add_assoc] using h1) + have h3 := specLP_w6_4 (ku := ku + 4) (by simpa [Nat.add_assoc] using h2) + have h4 := specLP_w6_4 (ku := ku) h3 + have hw : W6 ^ 16 +> r = W6 ^ 4 +> (W6 ^ 4 +> (W6 ^ 4 +> (W6 ^ 4 +> r))) := by + simp only [← append_assoc, ← pow_add_list] + rwa [hw] + +private theorem specLP_to_specL {ku0 : Nat} {r : ListBlank (Fin 2)} {o : ResL} + (hS : SpecLP 0 (ku0 + 1) r o) : + SpecL e (W6 ^ ku0 +> (P +> r)) o := by + have hpre : SegRLs tm e (g ++ j) (W6 ^ ku0 ++ P) (U ^ (ku0 + 1)) := by + rw [pow_add_list, pow_one_list] + exact (L011_run ku0).concat LP + rw [← append_assoc (W6 ^ ku0) P r] + cases o with + | failed => trivial + | stopped => + dsimp only [SpecLP, pow_zero_list, append_nil] at hS + exact hpre.sideRLsHalt_concat hS + | retU kout x => + obtain ⟨d, hk, hs⟩ := hS + dsimp only [pow_zero_list, append_nil] at hs + dsimp only [SpecL] + rw [hk, pow_add_list, append_assoc (U ^ (ku0 + 1)) (U ^ d)] + exact hpre.sideRLs_concat hs + | retUH kout c z => + obtain ⟨d, w, hk, hr, hseg⟩ := hS + dsimp only [pow_zero_list, List.nil_append] at hseg + refine ⟨(W6 ^ ku0 ++ P) ++ w, by rw [hr, ← append_assoc], ?_⟩ + rw [hk, pow_add_list] + exact hpre.concat hseg + +theorem sweepLP_spec (cont : Nat → Nat → Nat → ResL) + (hcont : ∀ kp ku ms, SpecLP kp (ku + 1) (bitsM ms) (cont kp ku ms)) + (fuel kp ku m : Nat) : + SpecLP kp (ku + 1) (bitsM m) (sweepLP fuel cont kp ku m) := by + induction fuel generalizing kp ku m with + | zero => exact hcont kp ku m + | succ fuel ih => + change SpecLP kp (ku + 1) (bitsM m) (sweepLP_step cont (sweepLP fuel cont) kp ku m) + unfold sweepLP_step sweepLP_p sweepLP_w6 + simp only [Nat.add_eq, shr_eq, land_7, land_63, land_4095, land_281474976710655] + cases hd4 : Nat.beq (m % 8) 4 with + | true => + dsimp only + have hm1 := Nat.eq_of_beq_eq_true hd4 + cases hp16 : Nat.beq (m % 281474976710656) 160842843834660 with + | true => + dsimp only + have hm16 := Nat.eq_of_beq_eq_true hp16 + rw [bitsM_eq_of_eq m (by omega) (bitsM_P16 (m / 281474976710656))] + exact specLP_shiftP (ih (kp + 16) ku (m / 281474976710656)) + | false => + dsimp only + cases hp4 : Nat.beq (m % 4096) 2340 with + | true => + dsimp only + have hm4 := Nat.eq_of_beq_eq_true hp4 + rw [bitsM_eq_of_eq m (by omega) (bitsM_P4 (m / 4096))] + exact specLP_shiftP (ih (kp + 4) ku (m / 4096)) + | false => + dsimp only + cases hp2 : Nat.beq (m % 64) 36 with + | true => + dsimp only + have hm2 := Nat.eq_of_beq_eq_true hp2 + rw [bitsM_eq_of_eq m (by omega) (bitsM_P2 (m / 64))] + exact specLP_shiftP (ih (kp + 2) ku (m / 64)) + | false => + dsimp only + rw [bitsM_eq_of_eq m (by omega) (bitsM_P (m / 8))] + exact specLP_shiftP (s := 1) (ih (kp + 1) ku (m / 8)) + | false => + dsimp only + cases hd6 : Nat.beq (m % 8) 6 with + | false => exact hcont kp ku m + | true => + dsimp only + have hm6 := Nat.eq_of_beq_eq_true hd6 + cases hw16 : Nat.beq (m % 281474976710656) 241264265751990 with + | true => + dsimp only + have hm16 := Nat.eq_of_beq_eq_true hw16 + rw [bitsM_eq_of_eq m (by omega) (bitsM_W6_16 (m / 281474976710656))] + have hsub := ih kp (ku + 16) (m / 281474976710656) + have hadd : ku + 16 + 1 = (ku + 1) + 16 := by omega + rw [hadd] at hsub + exact specLP_w6_16 hsub + | false => + dsimp only + cases hw4 : Nat.beq (m % 4096) 3510 with + | true => + dsimp only + have hm4 := Nat.eq_of_beq_eq_true hw4 + rw [bitsM_eq_of_eq m (by omega) (bitsM_W6_4 (m / 4096))] + have hsub := ih kp (ku + 4) (m / 4096) + have hadd : ku + 4 + 1 = (ku + 1) + 4 := by omega + rw [hadd] at hsub + exact specLP_w6_4 hsub + | false => + dsimp only + cases hw2 : Nat.beq (m % 64) 54 with + | true => + dsimp only + have hm2 := Nat.eq_of_beq_eq_true hw2 + rw [bitsM_eq_of_eq m (by omega) (bitsM_W6_2 (m / 64))] + have hsub := ih kp (ku + 2) (m / 64) + have hadd : ku + 2 + 1 = (ku + 1) + 2 := by omega + rw [hadd] at hsub + exact specLP_w6_2 hsub + | false => + dsimp only + rw [bitsM_eq_of_eq m (by omega) (bitsM_W6 (m / 8))] + have hsub := ih kp (ku + 1) (m / 8) + have hadd : ku + 1 + 1 = (ku + 1) + 1 := by omega + rw [hadd] at hsub + exact specLP_w6 hsub + +/-! ## Soundness of `evalG`, `evalJ`, `evalL_u`, `evalL` -/ + +def signalsM : ModeM → List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6)) + | .G => g + | .L => e + | .H n => h ^ n + +def EvalSpec (ev : ModeM → Nat → Result Nat) : Prop := + ∀ mode m0, Spec bitsM (signalsM mode) (bitsM m0) (ev mode m0) + +private theorem wrap_prependU_spec (k : Nat) + {hs : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))} + {w : List (Fin 2)} {r : ListBlank (Fin 2)} {o : Result Nat} {f : Nat → Nat} + (hRun : SegRLs tm hs hs w (U ^ k)) + (hS : Spec bitsM hs r (map_result f o)) : + Spec bitsM hs (w +> r) (map_result (fun x => prependU k (f x)) o) := by + have hL := lift_rule bitsM bitsM hRun (fun x => bitsM_prependU k x) hS + cases o <;> exact hL + +theorem evalG_k_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) (k m : Nat) : + Spec bitsM g (P ^ k +> bitsM m) (evalG_k rec k m) := by + unfold evalG_k evalG_b00 + simp only [Nat.add_eq, shr_2, shr_3, shr_4, shl_3, shl_5, land_1, land_3, retM_eq, callM_eq, + callH_eq] + have hb01 : m % 4 = 3 ∨ m % 4 = 1 ∨ m % 4 = 2 ∨ m % 4 = 0 := by omega + rcases hb01 with h3 | h1 | h2 | h0 + · simp only [h3, Nat.beq] + dsimp only [Spec] + rw [bitsM_eq_of_eq m (by omega) (bitsM_11 (m / 4))] + exact (GP_run k).sideRLsHalt_concat + (.here (E, [0, 0]) (C, [1]) [] ([1, 1] +> bitsM (m / 4)) (fun l => G11 l (bitsM (m / 4)))) + · simp only [h1, Nat.beq] + rw [bitsM_eq_of_eq m (by omega) (bitsM_10 (m / 4))] + have hih := hev (.H 1) (m / 4) + dsimp only [signalsM] at hih + have hW := wrap_prependU_spec k (GP_run k) (lift_rule bitsM bitsM G10 bitsM_U hih) + exact spec_of_eq hW (by cases rec (.H 1) (m / 4) <;> rfl) + · simp only [h2, Nat.beq] + dsimp only [Spec] + rw [bitsM_eq_of_eq m (by omega) (bitsM_01 (m / 4)), bitsM_prependU, bitsM_U] + exact (GP_run k).sideRLs_concat (G01.sideRLs_concat (.nil (bitsM (m / 4)))) + · simp only [h0, Nat.beq] + have hb23 : ((m / 4) % 4) % 2 = 1 ∨ (m / 4) % 4 = 2 ∨ (m / 4) % 4 = 0 := by omega + rcases hb23 with hp | h0001 | h0000 + · simp only [hp, Nat.beq] + rw [bitsM_eq_of_eq m (by omega) (bitsM_P (m / 8))] + have hW := wrap_prependU_spec k (GP_run k) (lift_rule bitsM bitsM GP bitsM_U (hev .G (m / 8))) + exact spec_of_eq hW (by cases rec .G (m / 8) <;> rfl) + · simp only [h0001, Nat.beq] + rw [bitsM_eq_of_eq m (by omega) (bitsM_0001 (m / 16))] + have hih := hev (.H 1) (m / 16) + dsimp only [signalsM] at hih + have hW := wrap_prependU_spec k (GP_run k) (lift_rule bitsM bitsM G0001 bitsM_17_32 hih) + exact spec_of_eq hW (by cases rec (.H 1) (m / 16) <;> rfl) + · have hp0 : ((m / 4) % 4) % 2 = 0 := by omega + have h2f : Nat.beq ((m / 4) % 4) 2 = false := by rw [h0000]; rfl + simp only [hp0, h2f, Nat.beq] + dsimp only [Spec] + rw [bitsM_eq_of_eq m (by omega) (bitsM_0000 (m / 16)), bitsM_prependU, bitsM_21_32] + exact (GP_run k).sideRLs_concat (G0000.sideRLs_concat (.nil (bitsM (m / 16)))) + +theorem evalG_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) (m0 : Nat) : + Spec bitsM g (bitsM m0) (evalG rec m0) := by + unfold evalG + simp only [shr_3, land_7] + cases hd4 : Nat.beq (m0 % 8) 4 with + | false => + dsimp only + simpa using evalG_k_spec hev 0 m0 + | true => + dsimp only + have hm := Nat.eq_of_beq_eq_true hd4 + have heq : bitsM m0 = P ^ 1 +> bitsM (m0 / 8) := by + rw [bitsM_eq_of_eq m0 (by omega) (bitsM_P (m0 / 8))]; rfl + rw [heq] + exact sweepP_inv (fun r o => Spec bitsM g r o) (evalG_k rec) (evalG_k_spec hev) 64 1 (m0 / 8) + +theorem evalJ_k_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) (k m : Nat) : + Spec bitsM j (O ^ k +> bitsM m) (evalJ_k rec k m) := by + unfold evalJ_k + simp only [Nat.add_eq, shr_1, shr_2, shl_3, land_1, retM_eq, callM_eq, callH_eq] + rw [land_2 m] + have hm4 : m % 4 = 1 ∨ m % 4 = 3 ∨ m % 4 = 2 ∨ m % 4 = 0 := by omega + rcases hm4 with h1 | h3 | h2 | h0 + · have hm2 : m % 2 = 1 := by omega + simp only [hm2, Nat.beq] + rw [bitsM_eq_of_eq m (by omega) (bitsM_bit1 (m / 2))] + change Spec bitsM j (O ^ k +> (([1] : List (Fin 2)) +> bitsM (m / 2))) _ + have hSub : Spec bitsM j (([1] : List (Fin 2)) +> + bitsM (m / 2)) (map_result id (rec .L (m / 2))) := + lift_rule bitsM bitsM J1 (fun _ => rfl) (hev .L (m / 2)) + have hW := wrap_prependU_spec k (JO_run k) hSub + exact spec_of_eq hW (by cases rec .L (m / 2) <;> rfl) + · have hm2 : m % 2 = 1 := by omega + simp only [hm2, Nat.beq] + rw [bitsM_eq_of_eq m (by omega) (bitsM_bit1 (m / 2))] + change Spec bitsM j (O ^ k +> (([1] : List (Fin 2)) +> bitsM (m / 2))) _ + have hSub : Spec bitsM j (([1] : List (Fin 2)) +> + bitsM (m / 2)) (map_result id (rec .L (m / 2))) := + lift_rule bitsM bitsM J1 (fun _ => rfl) (hev .L (m / 2)) + have hW := wrap_prependU_spec k (JO_run k) hSub + exact spec_of_eq hW (by cases rec .L (m / 2) <;> rfl) + · have hm2 : m % 2 = 0 := by omega + have hl2 : Nat.beq (Nat.land 2 2) 2 = true := rfl + simp only [hm2, h2, Nat.beq, hl2] + rw [bitsM_eq_of_eq m (by omega) (bitsM_01 (m / 4))] + have hih := hev (.H 1) (m / 4) + dsimp only [signalsM] at hih + have hW := wrap_prependU_spec k (JO_run k) (lift_rule bitsM bitsM J01 bitsM_U hih) + exact spec_of_eq hW (by cases rec (.H 1) (m / 4) <;> rfl) + · have hm2 : m % 2 = 0 := by omega + have hl0 : Nat.beq (Nat.land 0 2) 2 = false := rfl + simp only [hm2, h0, Nat.beq, hl0] + dsimp only [Spec] + rw [bitsM_eq_of_eq m (by omega) (bitsM_00 (m / 4)), bitsM_prependU, bitsM_O] + exact (JO_run k).sideRLs_concat (J00.sideRLs_concat (.nil (bitsM (m / 4)))) + +theorem evalJ_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) (m0 : Nat) : + Spec bitsM j (bitsM m0) (evalJ rec m0) := by + unfold evalJ + simp only [shr_3, land_7] + cases hd5 : Nat.beq (m0 % 8) 5 with + | false => + dsimp only + simpa using evalJ_k_spec hev 0 m0 + | true => + dsimp only + have hm := Nat.eq_of_beq_eq_true hd5 + have heq : bitsM m0 = O ^ 1 +> bitsM (m0 / 8) := by + rw [bitsM_eq_of_eq m0 (by omega) (bitsM_O (m0 / 8))]; rfl + rw [heq] + exact sweepO_inv (fun r o => Spec bitsM j r o) (evalJ_k rec) (evalJ_k_spec hev) 64 1 (m0 / 8) + +def unary (a : ℕ) (r : ListBlank (Fin 2)) : ListBlank (Fin 2) := + U ^ a +> r + +theorem T00N {X : Type} (den : X → ListBlank (Fin 2)) (a : ℕ) (r : ListBlank (Fin 2)) (o : Result X) + (ha : 2 ≤ a) (hS : Spec den (h ^ (a - 1)) r o) : + Spec (fun x => unary (a + 1) (den x)) j (unary a ([0, 0] +> r)) o := by + unfold unary + have ea : a = 2 + (a - 2) := by omega + have eo : a + 1 = 3 + (a - 2) := by omega + have eh : a - 1 = 1 + (a - 2) := by omega + rw [eh] at hS + have hT := T00 den (a - 2) r o hS + rwa [← ea, ← eo] at hT + +theorem T01N {X : Type} (den : X → ListBlank (Fin 2)) (a : ℕ) (r : ListBlank (Fin 2)) (o : Result X) + (hS : Spec den (h ^ (a + 1)) r o) : + Spec (fun x => unary (a + 1) (den x)) j (unary a ([0, 1] +> r)) o := by + unfold unary + have ha : a + 1 = 1 + a := by omega + rw [ha] at hS ⊢ + rw [← append_assoc (U ^ a) [0, 1] r] + exact rule_spec den (T01 a) hS + +theorem map_spec {X Y : Type} (dx : X → ListBlank (Fin 2)) (dy : Y → ListBlank (Fin 2)) + {hs : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))} + {r : ListBlank (Fin 2)} {o : Result X} {f : X → Y} + (hE : ∀ x, dy (f x) = dx x) (hS : Spec dx hs r o) : + Spec dy hs r (map_result f o) := by + cases o with + | failed => trivial + | stopped => exact hS + | returned x => + dsimp [Spec, map_result] + rw [hE x] + exact hS + +theorem TO_pow {X : Type} (den : X → ListBlank (Fin 2)) (a ko : ℕ) (r : ListBlank (Fin 2)) + (o : Result X) (hS : Spec den j (U ^ a +> r) o) : + Spec (fun x => U ^ ko +> den x) j (U ^ a +> (O ^ ko +> r)) o := by + induction ko with + | zero => exact hS + | succ ko ih => + rw [pow_succ_list O ko, append_assoc] + have hT := TO (fun x => U ^ ko +> den x) a (O ^ ko +> r) o ih + have hf : (fun x => U +> (U ^ ko +> den x)) = (fun x => U ^ (ko + 1) +> den x) := by + funext x + rw [pow_succ_list U ko, append_assoc] + rwa [hf] at hT + +theorem evalL_u_p_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) (kp ku ms : Nat) : + SpecLP kp (ku + 1) (bitsM ms) (evalL_u_p rec kp ku ms) := by + unfold evalL_u_p evalL_u_p_md0 evalL_u_p_md2 evalL_u_p_gen + simp only [Nat.add_eq, shr_4, shl_6, land_7, land_15, retLU_eq, retLUH_eq] + cases hd0 : Nat.beq (ms % 8) 0 with + | true => + dsimp only + have hm8 := Nat.eq_of_beq_eq_true hd0 + have hm16 : ms % 16 = 0 ∨ ms % 16 = 8 := by omega + rcases hm16 with h0000 | h0001 + · simp only [h0000, Nat.beq] + dsimp only [SpecLP] + refine ⟨kp + 2, [0, 0, 0, 0], by omega, bitsM_eq_of_eq ms (by omega) (bitsM_0000 (ms / 16)), + ?_⟩ + have hG : SegRLs tm g [] (P ^ kp ++ [0, 0, 0, 0]) (U ^ kp ++ (O ++ [0, 1])) := by + have hc := (GP_run kp).concat G0000 + have hw : U ^ kp ++ [1, 0, 1, 0, 1] = U ^ kp ++ (O ++ [0, 1]) := rfl + rwa [hw] at hc + have hJ : SegRLs tm j (h ^ (1 + kp)) (U ^ kp ++ (O ++ [0, 1])) (U ++ U ^ (1 + kp)) := + TO_seg kp (T01 kp) + have hTile := hG.trans hJ + have hk1 : [] ++ h ^ (1 + kp) = h ^ (kp + 1) := by + have hk : 1 + kp = kp + 1 := by omega + rw [List.nil_append, hk] + have hk2 : U ++ U ^ (1 + kp) = U ^ (kp + 2) := by + have hk : kp + 2 = (1 + kp) + 1 := by omega + rw [hk, pow_succ_list] + rwa [hk1, hk2] at hTile + · simp only [h0001, Nat.beq] + dsimp only [SpecLP] + refine ⟨kp + 2, [0, 0, 0, 1], by omega, bitsM_eq_of_eq ms (by omega) (bitsM_0001 (ms / 16)), + ?_⟩ + have hG : SegRLs tm g h (P ^ kp ++ [0, 0, 0, 1]) (U ^ (kp + 1) ++ [0, 1]) := by + have hc := (GP_run kp).concat G0001 + have hw : U ^ kp ++ [1, 0, 0, 0, 1] = U ^ (kp + 1) ++ [0, 1] := by + rw [pow_succ_list' U kp, List.append_assoc]; rfl + rwa [hw] at hc + have hJ : SegRLs tm j (h ^ (1 + (kp + 1))) (U ^ (kp + 1) ++ [0, 1]) (U ^ (1 + (kp + 1))) := + T01 (kp + 1) + have hTile := hG.trans hJ + have hsig : h ++ h ^ (1 + (kp + 1)) = h ^ (kp + 3) := by + have hk : kp + 3 = (1 + (kp + 1)) + 1 := by omega + rw [hk, pow_succ_list] + have hout : U ^ (1 + (kp + 1)) = U ^ (kp + 2) := by + have hk : 1 + (kp + 1) = kp + 2 := by omega + rw [hk] + rwa [hsig, hout] at hTile + | false => + dsimp only + cases hd2 : Nat.beq (ms % 8) 2 with + | true => + dsimp only + have hm8 := Nat.eq_of_beq_eq_true hd2 + have hm16 : ms % 16 = 2 ∨ ms % 16 = 10 := by omega + rcases hm16 with h0100 | h0101 + · simp only [h0100, Nat.beq] + rcases kp with _ | kp' + · simp only [Nat.beq] + dsimp only [SpecLP, pow_zero_list, append_nil] + rw [bitsM_eq_of_eq ms (by omega) (bitsM_0100 (ms / 16))] + have hG0 : SideRLs tm g (([0, 1, 0, 0] : List (Fin 2)) +> bitsM (ms / 16)) + ((U ++ [0, 0]) +> bitsM (ms / 16)) := by + have := G01.sideRLs_concat (.nil (([0, 0] : List (Fin 2)) +> bitsM (ms / 16))) + rwa [append_assoc] + have hJ0 : SideRLs tm j ((U ++ [0, 0]) +> bitsM (ms / 16)) + ((U ++ P) +> bitsM (ms / 16)) := + T00one.sideRLs_concat (.nil (bitsM (ms / 16))) + refine ⟨0, by omega, ?_⟩ + dsimp only [pow_zero_list, append_nil] + rw [bitsM_33_64] + exact hG0.trans hJ0 + · have hkp0 : Nat.beq (kp' + 1) 0 = false := rfl + simp only [hkp0] + dsimp only [SpecLP] + refine ⟨kp' + 3, [0, 1, 0, 0], by omega, + bitsM_eq_of_eq ms (by omega) (bitsM_0100 (ms / 16)), ?_⟩ + have hG : SegRLs tm g [] ((P ^ (kp' + 1) ++ [0, 1]) ++ [0, 0]) (U ^ (2 + kp') ++ [0, + 0]) := by + have h1 := ((GP_run (kp' + 1)).concat G01).concat (.nil [0, 0]) + have he : U ^ (kp' + 1) ++ U = U ^ (2 + kp') := by + have hk : 2 + kp' = (kp' + 1) + 1 := by omega + rw [hk, pow_succ_list' U (kp' + 1)] + rwa [he] at h1 + have hin : (P ^ (kp' + 1) ++ [0, 1]) ++ [0, 0] = P ^ (kp' + 1) ++ [0, 1, 0, 0] := by + rw [List.append_assoc]; rfl + rw [hin] at hG + have hTile := hG.trans (T00_seg kp') + have hsig : [] ++ h ^ (1 + kp') = h ^ (kp' + 1) := by + have hk : 1 + kp' = kp' + 1 := by omega + rw [List.nil_append, hk] + have hout : U ^ (3 + kp') = U ^ (kp' + 3) := by + have hk : 3 + kp' = kp' + 3 := by omega + rw [hk] + rwa [hsig, hout] at hTile + · simp only [h0101, Nat.beq] + dsimp only [SpecLP] + refine ⟨kp + 2, [0, 1, 0, 1], by omega, + bitsM_eq_of_eq ms (by omega) (bitsM_0101 (ms / 16)), ?_⟩ + have hG : SegRLs tm g [] ((P ^ kp ++ [0, 1]) ++ [0, 1]) (U ^ (kp + 1) ++ [0, 1]) := by + have h1 := ((GP_run kp).concat G01).concat (.nil [0, 1]) + rwa [← pow_succ_list' U kp] at h1 + have hin : (P ^ kp ++ [0, 1]) ++ [0, 1] = P ^ kp ++ [0, 1, 0, 1] := by + rw [List.append_assoc]; rfl + rw [hin] at hG + have hTile := hG.trans (T01 (kp + 1)) + have hsig : [] ++ h ^ (1 + (kp + 1)) = h ^ (kp + 2) := by + have hk : 1 + (kp + 1) = kp + 2 := by omega + rw [List.nil_append, hk] + have hout : U ^ (1 + (kp + 1)) = U ^ (kp + 2) := by + have hk : 1 + (kp + 1) = kp + 2 := by omega + rw [hk] + rwa [hsig, hout] at hTile + | false => + dsimp only + have hG := + lift_rule bitsM bitsM (GP_run kp) (fun r => bitsM_prependU kp r) (evalG_spec hev ms) + have hseq := bind_spec bitsM bitsM hG (fun x => evalJ_spec hev x) + cases hg : evalG rec ms with + | failed => trivial + | stopped => rw [hg] at hseq; exact hseq + | returned r => + rw [hg] at hseq + dsimp only [then_result, map_result, mapRetL] at hseq ⊢ + cases hj : evalJ rec (prependU kp r) with + | failed => trivial + | stopped => rw [hj] at hseq; exact hseq + | returned r2 => + rw [hj] at hseq + dsimp only [SpecLP, Spec] at hseq ⊢ + exact ⟨0, by omega, hseq⟩ + +theorem evalL_u_k_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) (ku0 m : Nat) : + SpecL e (W6 ^ ku0 +> bitsM m) (evalL_u_k rec ku0 m) := by + unfold evalL_u_k evalL_u_k_non4 + simp only [Nat.add_eq, shr_2, shr_3, shr_4, shl_6, land_3, land_7, land_15, + retLU_eq, retLUH_eq, callH_eq] + cases hd4 : Nat.beq (m % 8) 4 with + | true => + dsimp only + have hm8 := Nat.eq_of_beq_eq_true hd4 + rw [bitsM_eq_of_eq m (by omega) (bitsM_P (m / 8))] + exact specLP_to_specL (sweepLP_spec (evalL_u_p rec) (evalL_u_p_spec hev) 64 0 ku0 (m / 8)) + | false => + dsimp only + have hb01 : m % 4 = 3 ∨ m % 4 = 1 ∨ m % 4 = 2 ∨ m % 4 = 0 := by omega + rcases hb01 with h3 | h1 | h2 | h0 + · simp only [h3, Nat.beq] + dsimp only [SpecL] + rw [bitsM_eq_of_eq m (by omega) (bitsM_11 (m / 4))] + exact (L011_run ku0).sideRLsHalt_concat + (.here (E, [0, 0, 0]) (C, [1]) [] ([1, 1] +> bitsM (m / 4)) (fun l => + L11 l (bitsM (m / 4)))) + · simp only [h1, Nat.beq] + rw [bitsM_eq_of_eq m (by omega) (bitsM_10 (m / 4))] + have h1s := hev (.H 1) (m / 4) + dsimp only [signalsM] at h1s + have hseq := bind_spec bitsM bitsM h1s (fun r => evalJ_spec hev r) + cases hh : rec (.H 1) (m / 4) with + | failed => trivial + | stopped => + rw [hh] at hseq + exact (L011_run ku0).sideRLsHalt_concat (L10.sideRLsHalt_concat hseq) + | returned r => + rw [hh] at hseq + dsimp only [then_result, mapRetL] at hseq ⊢ + cases hj : evalJ rec r with + | failed => trivial + | stopped => + rw [hj] at hseq + exact (L011_run ku0).sideRLsHalt_concat (L10.sideRLsHalt_concat hseq) + | returned r2 => + rw [hj] at hseq + dsimp only [SpecL, Spec] at hseq ⊢ + rw [pow_add_list, pow_one_list, append_assoc] + exact (L011_run ku0).sideRLs_concat (L10.sideRLs_concat hseq) + · simp only [h2, Nat.beq] + cases hm16_2 : Nat.beq (m % 16) 2 with + | true => + dsimp only [SpecL] + have hm2 := Nat.eq_of_beq_eq_true hm16_2 + rw [bitsM_eq_of_eq m (by omega) (bitsM_0100 (m / 16)), bitsM_41_64] + exact (L011_run ku0).sideRLs_concat (L0100.sideRLs_concat (.nil (bitsM (m / 16)))) + | false => + dsimp only + rw [bitsM_eq_of_eq m (by omega) (bitsM_01 (m / 4))] + have hjs := evalJ_spec hev (m / 4) + cases hj : evalJ rec (m / 4) with + | failed => trivial + | stopped => + rw [hj] at hjs + exact (L011_run ku0).sideRLsHalt_concat (L01.sideRLsHalt_concat hjs) + | returned r2 => + rw [hj] at hjs + dsimp only [mapRetL, SpecL, Spec] at hjs ⊢ + rw [pow_add_list, pow_one_list, append_assoc] + exact (L011_run ku0).sideRLs_concat (L01.sideRLs_concat hjs) + · simp only [h0, Nat.beq] + have hm8_0 : m % 8 = 0 := by + rcases (by omega : m % 8 = 0 ∨ m % 8 = 4) with h_0 | h_4 + · exact h_0 + · rw [h_4] at hd4; cases hd4 + have hm16 : m % 16 = 8 ∨ m % 16 = 0 := by omega + rcases hm16 with h0001 | h0000 + · simp only [h0001, Nat.beq] + dsimp only [SpecL] + refine ⟨W6 ^ ku0 ++ [0, 0, 0, 1], ?_, ?_⟩ + · rw [bitsM_eq_of_eq m (by omega) (bitsM_0001 (m / 16)), ← append_assoc] + · have hc := (L011_run ku0).concat L0001 + have hout : U ^ ku0 ++ (U ++ U) = U ^ (ku0 + 2) := by + rw [pow_add_list]; rfl + rwa [hout] at hc + · simp only [h0000, Nat.beq] + dsimp only [SpecL] + rw [bitsM_eq_of_eq m (by omega) (bitsM_0000 (m / 16)), bitsM_33_64] + exact (L011_run ku0).sideRLs_concat (L0000.sideRLs_concat (.nil (bitsM (m / 16)))) + +theorem evalL_u_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) (m0 : Nat) : + SpecL e (bitsM m0) (evalL_u rec m0) := by + unfold evalL_u + simp only [shr_3, land_7] + cases hd6 : Nat.beq (m0 % 8) 6 with + | false => + dsimp only + simpa using evalL_u_k_spec hev 0 m0 + | true => + dsimp only + have hm := Nat.eq_of_beq_eq_true hd6 + have heq : bitsM m0 = W6 ^ 1 +> bitsM (m0 / 8) := by + rw [bitsM_eq_of_eq m0 (by omega) (bitsM_W6 (m0 / 8))]; rfl + rw [heq] + exact sweep6_inv (fun r o => SpecL e r o) (evalL_u_k rec) (evalL_u_k_spec hev) 64 1 (m0 / 8) + +theorem evalL_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) (m0 : Nat) : + Spec bitsM e (bitsM m0) (evalL rec m0) := by + unfold evalL + have hLu := evalL_u_spec hev m0 + cases hres : evalL_u rec m0 with + | failed => trivial + | stopped => rw [hres] at hLu; exact hLu + | retU k x => + rw [hres] at hLu + dsimp only [retM_eq, Spec] + rw [bitsM_prependU] + exact hLu + | retUH k c z => + rw [hres] at hLu + obtain ⟨w, hbm, hseg⟩ := hLu + dsimp only [retM_eq, callH_eq] + rw [hbm] + cases hc0 : Nat.beq c 0 with + | true => + dsimp only [Spec] + rw [Nat.eq_of_beq_eq_true hc0] at hseg + rw [bitsM_prependU] + exact hseg.sideRLs_concat (.nil (bitsM z)) + | false => + dsimp only + have hL := lift_rule bitsM bitsM hseg (fun r => bitsM_prependU k r) (hev (.H c) z) + exact spec_of_eq hL (by cases rec (.H c) z <;> rfl) + +/-! ## Soundness of `finishUH`, `evalHL`, `evalH`, `evalT`, `tcallT`, `roundT`, `runT` -/ + +theorem finishUH_u_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) + (k n z : Nat) : + Spec bitsM (h ^ n) (U ^ k +> bitsM z) (finishUH rec k 0 n z) := by + unfold finishUH + simp only [Nat.add_eq, Nat.zero_add, retM_eq, callH_eq] + obtain ⟨v, hSeg, hb⟩ := digitsK_spec k n + cases hc : Nat.beq (carryK k n) 0 with + | true => + dsimp only [Spec] + rw [Nat.eq_of_beq_eq_true hc] at hSeg + rw [hb z] + exact hSeg.sideRLs_concat (.nil (bitsM z)) + | false => + dsimp only + have hL := lift_rule bitsM bitsM hSeg hb (hev (.H (carryK k n)) z) + exact spec_of_eq hL (by cases rec (.H (carryK k n)) z <;> rfl) + +theorem finishUH_uh_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) + {w : List (Fin 2)} (k c n z : Nat) + (hSegE : SegRLs tm e (h ^ c) w (U ^ k)) : + Spec bitsM (e ++ h ^ n) (w +> bitsM z) (finishUH rec k c n z) := by + unfold finishUH + simp only [Nat.add_eq, retM_eq, callH_eq] + obtain ⟨v, hSegD, hb⟩ := digitsK_spec k n + have hTot : SegRLs tm (e ++ h ^ n) (h ^ (c + carryK k n)) w v := by + rw [pow_add_list] + exact hSegE.trans hSegD + cases hc : Nat.beq (c + carryK k n) 0 with + | true => + dsimp only [Spec] + rw [Nat.eq_of_beq_eq_true hc] at hTot + rw [hb z] + exact hTot.sideRLs_concat (.nil (bitsM z)) + | false => + dsimp only + have hL := lift_rule bitsM bitsM hTot hb (hev (.H (c + carryK k n)) z) + exact spec_of_eq hL (by cases rec (.H (c + carryK k n)) z <;> rfl) + +theorem evalHL_fast2_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) + {w : List (Fin 2)} (base n z2 : Nat) (hbase : base < 16) + (hL0 : SegRLs tm e [] w (digits2 base)) : + Spec bitsM (e ++ h ^ n) (w +> bitsM z2) (evalHL_fast2 rec base n z2) := by + unfold evalHL_fast2 + simp only [Nat.add_eq, shr_4, shl_6, land_15, retM_eq, callH_eq] + have hRule : SegRLs tm (e ++ h ^ n) (h ^ ((base + n) / 16)) w (digits2 ((base + n) % 16)) := + hL0.trans (digits2_count base n hbase) + cases hqn2 : Nat.beq ((base + n) / 16) 0 with + | true => + dsimp only [Spec] + rw [Nat.eq_of_beq_eq_true hqn2] at hRule + rw [bitsM_enc2 ((base + n) % 16) z2 (by omega)] + exact hRule.sideRLs_concat (.nil (bitsM z2)) + | false => + dsimp only + have hL := lift_rule bitsM bitsM hRule + (fun r2 => bitsM_enc2 ((base + n) % 16) r2 (by omega)) + (hev (.H ((base + n) / 16)) z2) + exact spec_of_eq hL (by cases rec (.H ((base + n) / 16)) z2 <;> rfl) + +theorem evalHL_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) (n y : Nat) : + Spec bitsM (e ++ h ^ n) (bitsM y) (evalHL rec n y) := by + unfold evalHL evalHL_gen + simp only [shr_4, land_15] + cases hd2 : Nat.beq (y % 16) 2 with + | true => + dsimp only + have hy2 := Nat.eq_of_beq_eq_true hd2 + rw [bitsM_eq_of_eq y (by omega) (bitsM_0100 (y / 16))] + exact evalHL_fast2_spec hev 8 n (y / 16) (by decide) L0100 + | false => + dsimp only + cases hd0 : Nat.beq (y % 16) 0 with + | true => + dsimp only + have hy0 := Nat.eq_of_beq_eq_true hd0 + rw [bitsM_eq_of_eq y (by omega) (bitsM_0000 (y / 16))] + exact evalHL_fast2_spec hev 12 n (y / 16) (by decide) L0000 + | false => + dsimp only + have hLu := evalL_u_spec hev y + cases hres : evalL_u rec y with + | failed => trivial + | stopped => rw [hres] at hLu; exact SideRLsHalt.app_left hLu + | retU k x => + rw [hres] at hLu + exact after_spec bitsM hLu (finishUH_u_spec hev k n x) + | retUH k c z => + rw [hres] at hLu + obtain ⟨w, hbm, hSegE⟩ := hLu + rw [hbm] + exact finishUH_uh_spec hev k c n z hSegE + +private theorem land_div8_2_fin : ∀ x : Fin 64, + Nat.land x.val 2 = 0 → Nat.beq (Nat.land x.val 18) 0 = false → + Nat.beq (Nat.land (x.val / 8) 2) 0 = false := by + decide +kernel + +private theorem land_div8_2_ne0 (m0 : Nat) + (hm2 : Nat.land m0 2 = 0) (hm18 : Nat.beq (Nat.land m0 18) 0 = false) : + Nat.beq (Nat.land (m0 / 8) 2) 0 = false := by + have h1 : Nat.land (m0 % 64) 2 = 0 := by + rw [land_2] at hm2 ⊢ + have e : (m0 % 64) % 4 = m0 % 4 := by omega + rwa [e] + have h2 : Nat.beq (Nat.land (m0 % 64) 18) 0 = false := by + rwa [← land_18] + have hf := land_div8_2_fin ⟨m0 % 64, by omega⟩ h1 h2 + dsimp only at hf + rw [land_2] at hf ⊢ + have e2 : ((m0 % 64) / 8) % 4 = (m0 / 8) % 4 := by omega + rwa [← e2] + +theorem evalH_inv_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) + (n m0 : Nat) (hn : 1 ≤ n) (hm2 : Nat.beq (Nat.land m0 2) 0 = false) : + Spec bitsM (h ^ n) (bitsM m0) (evalH_inv rec n m0) := by + rcases n with _ | n0 + · omega + unfold evalH_inv + simp only [Nat.add_eq, Nat.sub_eq, shr_2, shl_2, land_1, retM_eq] + have h_b1 : m0 % 4 = 2 ∨ m0 % 4 = 3 := by + rw [land_2] at hm2 + rcases (by omega : m0 % 4 = 0 ∨ m0 % 4 = 1 ∨ m0 % 4 = 2 ∨ m0 % 4 = 3) with h0 | h1 | h2 | h3 + · rw [h0] at hm2; cases hm2 + · rw [h1] at hm2; cases hm2 + · exact Or.inl h2 + · exact Or.inr h3 + rcases h_b1 with h01 | h11 + · have hm0_1 : m0 % 2 = 0 := by omega + simp only [hm0_1, Nat.beq, Nat.add_sub_cancel] + rw [bitsM_eq_of_eq m0 (by omega) (bitsM_01 (m0 / 4)), pow_succ_list h n0] + exact rule_spec bitsM (H01rest n0) (evalHL_spec hev n0 (m0 / 4)) + · have hm0_1 : m0 % 2 = 1 := by omega + simp only [hm0_1, Nat.beq] + rcases n0 with _ | n1 + · simp only [Nat.beq] + dsimp only [Spec] + have hb_in : bitsM m0 = ([1] : List (Fin 2)) +> (([1] : List (Fin 2)) +> bitsM (m0 / 4)) := by + rw [bitsM_eq_of_eq m0 (by omega) (bitsM_11 (m0 / 4))]; rfl + rw [hb_in, bitsM_01 (m0 / 4)] + exact H1.sideRLs_concat (.nil (([1] : List (Fin 2)) +> bitsM (m0 / 4))) + · have hsub2 : n1 + 1 + 1 - 2 = n1 := by omega + simp only [hsub2] + have hb_in : bitsM m0 = ([1] : List (Fin 2)) +> (([1] : List (Fin 2)) +> bitsM (m0 / 4)) := by + rw [bitsM_eq_of_eq m0 (by omega) (bitsM_11 (m0 / 4))]; rfl + have hH1 : SideRLs tm h (bitsM m0) (([0, 1] : List (Fin 2)) +> bitsM (m0 / 4)) := by + rw [hb_in] + exact H1.sideRLs_concat (.nil (([1] : List (Fin 2)) +> bitsM (m0 / 4))) + have hR' : Spec bitsM (h ^ (n1 + 1)) (([0, 1] : List (Fin 2)) +> bitsM (m0 / 4)) + (evalHL rec n1 (m0 / 4)) := by + rw [pow_succ_list h n1] + exact rule_spec bitsM (H01rest n1) (evalHL_spec hev n1 (m0 / 4)) + rw [pow_succ_list h (n1 + 1)] + exact after_spec bitsM hH1 hR' + +theorem evalH_spec {rec : ModeM → Nat → Result Nat} (hev : EvalSpec rec) (n m0 : Nat) : + Spec bitsM (h ^ n) (bitsM m0) (evalH rec n m0) := by + unfold evalH evalH_valid evalH_wide evalH_w1 evalH_w2 evalH_w4 evalH_w12 + simp only [Nat.add_eq, + shr_2, shr_3, shr_4, shr_6, shr_8, shr_12, shr_24, shr_36, + shl_3, shl_6, shl_12, shl_36, + land_3, land_7, land_15, land_63, land_255, land_4095, land_16777215, + retM_eq, callH_eq] + rcases n with _ | n0 + · exact .nil (bitsM m0) + · have hne0 : Nat.beq (n0 + 1) 0 = false := rfl + simp only [hne0] + cases hm2 : Nat.beq (Nat.land m0 2) 0 with + | false => + dsimp only + exact evalH_inv_spec hev (n0 + 1) m0 (by omega) hm2 + | true => + dsimp only + have hm2_eq := Nat.eq_of_beq_eq_true hm2 + have hm2_0 : Nat.land (m0 % 8) 2 = 0 := by + rwa [← land_2_8] + obtain ⟨hp_lt, henc_d3⟩ := dec1_lt4 (m0 % 8) (by omega) hm2_0 + have hb_m0 : bitsM m0 = digit (dec1 (m0 % 8)) +> bitsM (m0 / 8) := + bitsM_eq_of_eq m0 (by omega) (bitsM_enc1 (dec1 (m0 % 8)) (m0 / 8) hp_lt) + set p := dec1 (m0 % 8) + set n := n0 + 1 + cases hs3 : Nat.ble (p + n) 3 with + | true => + dsimp only [Spec] + have hle := Nat.ble_eq.mp hs3 + have hq0 : (p + n) / 4 = 0 := by omega + have hrem : (p + n) % 4 = p + n := by omega + have hdc := digit_count p n hp_lt + rw [hq0, hrem] at hdc + rw [hb_m0, bitsM_enc1 (p + n) (m0 / 8) (by omega)] + exact hdc.sideRLs_concat (.nil (bitsM (m0 / 8))) + | false => + dsimp only + have hs4 : 4 ≤ p + n := by + rcases (by omega : p + n ≤ 3 ∨ 4 ≤ p + n) with hle | hge + · rw [Nat.ble_eq.mpr hle] at hs3; cases hs3 + · exact hge + cases h2 : Nat.beq (Nat.land m0 18) 0 with + | false => + dsimp only + rw [hb_m0] + have hinv := evalH_inv_spec hev ((p + n) / 4) (m0 / 8) (by omega) + (land_div8_2_ne0 m0 hm2_eq h2) + have hL := lift_rule bitsM bitsM (digit_count p n hp_lt) + (fun r2 => bitsM_enc1 ((p + n) % 4) r2 (by omega)) + hinv + exact spec_of_eq hL (by cases evalH_inv rec ((p + n) / 4) (m0 / 8) <;> rfl) + | true => + dsimp only + cases h4 : Nat.beq (Nat.land m0 1170) 0 with + | false => + dsimp only + obtain ⟨hv2, hb2⟩ := bitsM_dec2 m0 (Nat.eq_of_beq_eq_true h2) + set v2 := dec2 (m0 % 64) + rw [hb2] + have hdc2 := digits2_count v2 n hv2 + cases hqn2 : Nat.beq ((v2 + n) / 16) 0 with + | true => + dsimp only [Spec] + rw [Nat.eq_of_beq_eq_true hqn2] at hdc2 + rw [bitsM_enc2 ((v2 + n) % 16) (m0 / 64) (by omega)] + exact hdc2.sideRLs_concat (.nil (bitsM (m0 / 64))) + | false => + dsimp only + have hqn2_pos : 1 ≤ (v2 + n) / 16 := by + rcases hq : (v2 + n) / 16 with _ | q' + · rw [hq] at hqn2; cases hqn2 + · omega + cases hz2 : Nat.beq (Nat.land (m0 / 64) 2) 0 with + | true => + dsimp only + have hL := lift_rule bitsM bitsM hdc2 + (fun r2 => bitsM_enc2 ((v2 + n) % 16) r2 (by omega)) + (hev (.H ((v2 + n) / 16)) (m0 / 64)) + exact spec_of_eq hL (by cases rec (.H ((v2 + n) / 16)) (m0 / 64) <;> rfl) + | false => + dsimp only + have hinv := evalH_inv_spec hev ((v2 + n) / 16) (m0 / 64) hqn2_pos hz2 + have hL := lift_rule bitsM bitsM hdc2 + (fun r2 => bitsM_enc2 ((v2 + n) % 16) r2 (by omega)) + hinv + exact spec_of_eq hL (by cases evalH_inv rec ((v2 + n) / 16) (m0 / 64) <;> rfl) + | true => + dsimp only + cases h12 : Bool.rec (motive := fun _ => Bool) false (ok12_hi m0) (Nat.ble 256 n) with + | true => + dsimp only + have hok : ok12_hi m0 = true := by + cases hble : Nat.ble 256 n with + | false => rw [hble] at h12; cases h12 + | true => rw [hble] at h12; exact h12 + obtain ⟨hv12, hb12⟩ := bitsM_dec12 m0 (Nat.eq_of_beq_eq_true h4) hok + set v12 := dec12_3x4 (Nat.land m0 68719476735) + rw [hb12] + have hdc12 := digits12_count v12 n hv12 + cases hqn12 : Nat.beq ((v12 + n) / 16777216) 0 with + | true => + dsimp only [Spec] + rw [Nat.eq_of_beq_eq_true hqn12] at hdc12 + rw [bitsM_enc12 ((v12 + n) % 16777216) (m0 / 68719476736) (by omega)] + exact hdc12.sideRLs_concat (.nil (bitsM (m0 / 68719476736))) + | false => + dsimp only + have hL := lift_rule bitsM bitsM hdc12 + (fun r2 => bitsM_enc12 ((v12 + n) % 16777216) r2 (by omega)) + (hev (.H ((v12 + n) / 16777216)) (m0 / 68719476736)) + exact spec_of_eq hL (by cases rec (.H ((v12 + n) / 16777216)) (m0 / 68719476736) <;> + rfl) + | false => + dsimp only + obtain ⟨hv4, hb4⟩ := bitsM_dec4 m0 (Nat.eq_of_beq_eq_true h4) + set v4 := dec4 (m0 % 4096) + rw [hb4] + have hdc4 := digits4_count v4 n hv4 + cases hqn4 : Nat.beq ((v4 + n) / 256) 0 with + | true => + dsimp only [Spec] + rw [Nat.eq_of_beq_eq_true hqn4] at hdc4 + rw [bitsM_enc4 ((v4 + n) % 256) (m0 / 4096) (by omega)] + exact hdc4.sideRLs_concat (.nil (bitsM (m0 / 4096))) + | false => + dsimp only + have hL := lift_rule bitsM bitsM hdc4 + (fun r2 => bitsM_enc4 ((v4 + n) % 256) r2 (by omega)) + (hev (.H ((v4 + n) / 256)) (m0 / 4096)) + exact spec_of_eq hL (by cases rec (.H ((v4 + n) / 256)) (m0 / 4096) <;> rfl) + +theorem evalT_spec (fuel : Nat) : EvalSpec (evalT fuel) := by + induction fuel with + | zero => intro _ _; trivial + | succ fuel ih => + intro mode m0 + cases mode with + | G => exact evalG_spec ih m0 + | L => exact evalL_spec ih m0 + | H n => exact evalH_spec ih n m0 + +def pairM_side (x : Nat × Nat) : ListBlank (Fin 2) := + unary x.1 (bitsM x.2) + +theorem add_unaryM_spec (b : Nat) (x : Nat × Nat) : + pairM_side (b + x.1, x.2) = unary b (pairM_side x) := by + unfold pairM_side unary + dsimp only + rw [pow_add_list, append_assoc] + +def toResultP : ResP → Result (Nat × Nat) + | .failed => .failed + | .stopped => .stopped + | .ret a m => .returned (a, m) + +theorem collectM_inv {α : Type} (P_ok : ListBlank (Fin 2) → α → Prop) + (cont : Nat → Nat → α) + (hcont : ∀ acc m, P_ok (unary acc (bitsM m)) (cont acc m)) + (fuel acc m : Nat) : + P_ok (unary acc (bitsM m)) (collectM fuel cont acc m) := by + induction fuel generalizing acc m with + | zero => exact hcont acc m + | succ fuel ih => + change P_ok (unary acc (bitsM m)) (collectM_step cont (collectM fuel cont) acc m) + unfold collectM_step collectM_hit + simp only [Nat.add_eq, shr_eq, land_7, land_4095, land_281474976710655] + cases hd1 : Nat.beq (m % 8) 1 with + | false => exact hcont acc m + | true => + dsimp only + have hm1 := Nat.eq_of_beq_eq_true hd1 + cases hd16 : Nat.beq (m % 281474976710656) 40210710958665 with + | true => + dsimp only + have hm16 := Nat.eq_of_beq_eq_true hd16 + have heq : unary acc (bitsM m) = unary (acc + 16) (bitsM (m / 281474976710656)) := by + unfold unary + rw [bitsM_eq_of_eq m (by omega) (bitsM_U16 (m / 281474976710656)), ← append_assoc, + ← pow_add_list] + rw [heq] + exact ih (acc + 16) (m / 281474976710656) + | false => + dsimp only + cases hd4 : Nat.beq (m % 4096) 585 with + | true => + dsimp only + have hm4 := Nat.eq_of_beq_eq_true hd4 + have heq : unary acc (bitsM m) = unary (acc + 4) (bitsM (m / 4096)) := by + unfold unary + rw [bitsM_eq_of_eq m (by omega) (bitsM_U4 (m / 4096)), ← append_assoc, ← pow_add_list] + rw [heq] + exact ih (acc + 4) (m / 4096) + | false => + dsimp only + have heq : unary acc (bitsM m) = unary (acc + 1) (bitsM (m / 8)) := by + unfold unary + rw [bitsM_eq_of_eq m (by omega) (bitsM_U (m / 8)), ← append_assoc, ← pow_succ_list'] + rw [heq] + exact ih (acc + 1) (m / 8) + +def TCallSpec (rec : Nat → Nat → ResP) : Prop := + ∀ a m, Spec pairM_side j (unary a (bitsM m)) (toResultP (rec a m)) + +theorem tcallT_k_spec {ev : ModeM → Nat → Result Nat} {rec : Nat → Nat → ResP} + (hev : EvalSpec ev) (hrec : TCallSpec rec) (a ko m1 : Nat) : + Spec pairM_side j (unary a (O ^ ko +> bitsM m1)) (toResultP (tcallT_k ev rec a ko m1)) := by + unfold tcallT_k tcallT_even tcallT_odd + simp only [Nat.add_eq, Nat.sub_eq, shr_2, shr_3, shl_3, land_1, land_3, land_7, retP_eq] + have hcase : m1 % 4 = 0 ∨ m1 % 4 = 2 ∨ m1 % 8 = 1 ∨ m1 % 8 = 5 ∨ m1 % 8 = 3 ∨ m1 % 8 = 7 := by + omega + rcases hcase with h00 | h01 | h100 | h101 | h110 | h111 + · have hm2 : m1 % 2 = 0 := by omega + simp only [hm2, h00, Nat.beq] + rw [bitsM_eq_of_eq m1 (by omega) (bitsM_00 (m1 / 4))] + rcases a with _ | _ | a2 + · simp only [Nat.beq] + have h0 : Spec pairM_side j (U ^ 0 +> (([0, 0] : List (Fin 2)) +> bitsM (m1 / 4))) + (.returned (0, 5 + 8 * (m1 / 4))) := by + dsimp [Spec, pairM_side, unary] + rw [bitsM_O] + exact T00zero.sideRLs_concat (.nil (bitsM (m1 / 4))) + have hT := TO_pow pairM_side 0 ko _ _ h0 + exact map_spec (f := fun p => (ko + p.1, p.2)) + (fun p => U ^ ko +> pairM_side p) pairM_side (fun p => add_unaryM_spec ko p) hT + · simp only [Nat.beq] + have h0 : Spec pairM_side j (U ^ 1 +> (([0, 0] : List (Fin 2)) +> bitsM (m1 / 4))) + (.returned (1, 4 + 8 * (m1 / 4))) := by + dsimp [Spec, pairM_side, unary] + rw [bitsM_P] + simpa [append_assoc] using T00one.sideRLs_concat (.nil (bitsM (m1 / 4))) + have hT := TO_pow pairM_side 1 ko _ _ h0 + exact map_spec (f := fun p => (ko + p.1, p.2)) + (fun p => U ^ ko +> pairM_side p) pairM_side (fun p => add_unaryM_spec ko p) hT + · have ha0 : Nat.beq (a2 + 2) 0 = false := rfl + have ha1 : Nat.beq (a2 + 2) 1 = false := rfl + simp only [ha0, ha1] + have hevH := evalH_spec hev (a2 + 2 - 1) (m1 / 4) + have hT0 := T00N bitsM (a2 + 2) (bitsM (m1 / 4)) _ (by omega) hevH + have hM0 := map_spec (f := fun s => (a2 + 2 + 1, s)) + (fun s => unary (a2 + 2 + 1) (bitsM s)) pairM_side (fun _ => rfl) hT0 + have hT := TO_pow pairM_side (a2 + 2) ko _ _ hM0 + have hM := map_spec (f := fun p => (ko + p.1, p.2)) + (fun p => U ^ ko +> pairM_side p) pairM_side (fun p => add_unaryM_spec ko p) hT + exact spec_of_eq hM (by cases evalH ev (a2 + 2 - 1) (m1 / 4) <;> rfl) + · have hm2 : m1 % 2 = 0 := by omega + simp only [hm2, h01, Nat.beq] + rw [bitsM_eq_of_eq m1 (by omega) (bitsM_01 (m1 / 4))] + have hevH := evalH_spec hev (a + 1) (m1 / 4) + have hT0 := T01N bitsM a (bitsM (m1 / 4)) _ hevH + have hM0 := map_spec (f := fun s => (a + 1, s)) + (fun s => unary (a + 1) (bitsM s)) pairM_side (fun _ => rfl) hT0 + have hT := TO_pow pairM_side a ko _ _ hM0 + have hM := map_spec (f := fun p => (ko + p.1, p.2)) + (fun p => U ^ ko +> pairM_side p) pairM_side (fun p => add_unaryM_spec ko p) hT + exact spec_of_eq hM (by cases evalH ev (a + 1) (m1 / 4) <;> rfl) + · have hm2 : m1 % 2 = 1 := by omega + simp only [hm2, h100, Nat.beq] + have hb : bitsM m1 = unary 1 (bitsM (m1 / 8)) := by + rw [bitsM_eq_of_eq m1 (by omega) (bitsM_U (m1 / 8))]; rfl + rw [hb] + exact collectM_inv + (fun sub o => Spec pairM_side j (unary a (O ^ ko +> sub)) (toResultP o)) + (fun ku zm => mapRetP (rec (a + ku) zm) (fun pa pm => .ret (ko + pa) pm)) + (fun ku zm => by + have hu : U ^ (a + ku) +> bitsM zm = U ^ a +> unary ku (bitsM zm) := by + unfold unary; rw [pow_add_list, append_assoc] + have h0 : Spec pairM_side j (U ^ a +> unary ku (bitsM zm)) (toResultP (rec (a + ku) zm)) := + by + rw [← hu]; exact hrec (a + ku) zm + have hT := TO_pow pairM_side a ko _ _ h0 + have hM := map_spec (f := fun p => (ko + p.1, p.2)) + (fun p => U ^ ko +> pairM_side p) pairM_side (fun p => add_unaryM_spec ko p) hT + exact spec_of_eq hM (by cases rec (a + ku) zm <;> rfl)) + 64 1 (m1 / 8) + · have hm2 : m1 % 2 = 1 := by omega + simp only [hm2, h101, Nat.beq] + rw [bitsM_eq_of_eq m1 (by omega) (bitsM_O (m1 / 8))] + have hSub := TO pairM_side a (bitsM (m1 / 8)) _ (hrec a (m1 / 8)) + have hT := TO_pow (fun p => U +> pairM_side p) a ko _ _ hSub + have hM := map_spec (f := fun p => ((ko + 1) + p.1, p.2)) + (fun p => U ^ ko +> (U +> pairM_side p)) pairM_side + (fun p => by + unfold pairM_side unary + dsimp only + rw [pow_add_list, pow_succ_list', append_assoc, append_assoc]) + hT + exact spec_of_eq hM (by cases rec a (m1 / 8) <;> rfl) + · have hm2 : m1 % 2 = 1 := by omega + simp only [hm2, h110, Nat.beq] + rw [bitsM_eq_of_eq m1 (by omega) (bitsM_110 (m1 / 8))] + have hevH := evalH_spec hev 1 (m1 / 8) + cases h_res : evalH ev 1 (m1 / 8) with + | failed => trivial + | stopped => + rw [h_res] at hevH + exact TO_pow pairM_side a ko _ (.stopped : Result (Nat × Nat)) + (T110_halt a (bitsM (m1 / 8)) hevH) + | returned r => + rw [h_res] at hevH + dsimp only [evalToP] + have hSub := T110_return pairM_side a (bitsM (m1 / 8)) (bitsM r) _ hevH (hrec a r) + have hT := TO_pow (fun p => U +> pairM_side p) a ko _ _ hSub + have hM := map_spec (f := fun p => ((ko + 1) + p.1, p.2)) + (fun p => U ^ ko +> (U +> pairM_side p)) pairM_side + (fun p => by + unfold pairM_side unary + dsimp only + rw [pow_add_list, pow_succ_list', append_assoc, append_assoc]) + hT + exact spec_of_eq hM (by cases rec a r <;> rfl) + · have hm2 : m1 % 2 = 1 := by omega + simp only [hm2, h111, Nat.beq] + rw [bitsM_eq_of_eq m1 (by omega) (bitsM_111 (m1 / 8))] + exact TO_pow pairM_side a ko _ (.stopped : Result (Nat × Nat)) (T111 a (bitsM (m1 / 8))) + +theorem tcallT_step_spec {ev : ModeM → Nat → Result Nat} {rec : Nat → Nat → ResP} + (hev : EvalSpec ev) (hrec : TCallSpec rec) : TCallSpec (tcallT_step ev rec) := by + intro a m + unfold tcallT_step + simp only [shr_3, land_7] + cases hd5 : Nat.beq (m % 8) 5 with + | false => + dsimp only + simpa using tcallT_k_spec hev hrec a 0 m + | true => + dsimp only + have hm := Nat.eq_of_beq_eq_true hd5 + have heq : bitsM m = O ^ 1 +> bitsM (m / 8) := by + rw [bitsM_eq_of_eq m (by omega) (bitsM_O (m / 8))]; rfl + rw [heq] + exact sweepO_inv (fun r o => Spec pairM_side j (unary a r) (toResultP o)) + (tcallT_k ev rec a) (tcallT_k_spec hev hrec a) 64 1 (m / 8) + +theorem tcallT_spec {ev : ModeM → Nat → Result Nat} (hev : EvalSpec ev) (fuel : Nat) : + TCallSpec (tcallT fuel ev) := by + induction fuel with + | zero => intro _ _; trivial + | succ fuel ih => exact tcallT_step_spec hev ih + +private theorem collect_tail_side {hs : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))} + {r : ListBlank (Fin 2)} (pa pm : Nat) + (hSide : SideRLs tm hs r (U +> unary pa (bitsM pm))) : + Spec pairM_side hs r (toResultP (Bool.rec (retP (1 + pa) pm) + (collectM 64 (roundT_col1 pa) 1 (pm / 8)) (Nat.beq (pm % 8) 1))) := by + have h1 : U +> unary pa (bitsM pm) = pairM_side (1 + pa, pm) := by + unfold pairM_side unary + dsimp only + have he : 1 + pa = pa + 1 := by omega + rw [he, pow_succ_list, append_assoc] + rw [h1] at hSide + cases hd1 : Nat.beq (pm % 8) 1 with + | false => exact hSide + | true => + dsimp only + have hm1 := Nat.eq_of_beq_eq_true hd1 + exact collectM_inv + (fun sub o => + U ^ (1 + pa) +> sub = pairM_side (1 + pa, pm) → Spec pairM_side hs r (toResultP o)) + (roundT_col1 pa) + (fun ca cm heq => by + unfold roundT_col1 + rw [retP_eq] + dsimp only [toResultP, Spec, pairM_side, unary] + dsimp only [unary] at heq + rw [Nat.add_eq, Nat.add_eq, pow_add_list, append_assoc, heq] + exact hSide) + 64 1 (pm / 8) + (by + unfold pairM_side unary + dsimp only + rw [bitsM_eq_of_eq pm (by omega) (bitsM_U (pm / 8))] + rfl) + +theorem roundT_spec {ev : ModeM → Nat → Result Nat} (hev : EvalSpec ev) (tfuel a m : Nat) : + Spec pairM_side g (pairM_side (a, m)) (toResultP (roundT tfuel ev a m)) := by + unfold roundT roundT_a0 roundT_tcall roundT_fast00 roundT_finish + simp only [Nat.add_eq, Nat.sub_eq, shr_2, shr_3, land_3, land_7] + cases hle2 : Nat.ble a 2 with + | true => + dsimp only + rcases a with _ | a0 + · simp only [Nat.beq] + have hevG := evalG_spec hev m + cases hg : evalG ev m with + | failed => trivial + | stopped => rw [hg] at hevG; exact hevG + | returned r => + rw [hg] at hevG + dsimp only [evalToP, Spec] at hevG ⊢ + exact collectM_inv + (fun sub o => sub = bitsM r → Spec pairM_side g (pairM_side (0, m)) (toResultP o)) + retP + (fun ca cm heq => by + rw [retP_eq] + dsimp only [toResultP, Spec, pairM_side] + rw [heq] + exact hevG) + 64 0 r rfl + · have ha0_ne : Nat.beq (a0 + 1) 0 = false := rfl + simp only [ha0_ne, Nat.add_sub_cancel] + have htc := tcallT_spec hev tfuel a0 m + have hun : pairM_side (a0 + 1, m) = U +> unary a0 (bitsM m) := by + unfold pairM_side unary; dsimp only; rw [pow_succ_list, append_assoc] + rw [hun] + have hR := rule_spec pairM_side GU htc + cases htc_res : tcallT tfuel ev a0 m with + | failed => trivial + | stopped => rw [htc_res] at hR; exact hR + | ret pa pm => + rw [htc_res] at hR + dsimp only [mapRetP, toResultP, Spec] at hR ⊢ + exact collect_tail_side pa pm hR + | false => + dsimp only + have ha3 : 3 ≤ a := by + rcases (by omega : a ≤ 2 ∨ 3 ≤ a) with h2 | h3 + · rw [Nat.ble_eq.mpr h2] at hle2; cases hle2 + · exact h3 + cases hm4 : Nat.beq (m % 4) 0 with + | true => + dsimp only + have hm0 := Nat.eq_of_beq_eq_true hm4 + have hun : pairM_side (a, m) = U +> unary (a - 1) (([0, + 0] : List (Fin 2)) +> bitsM (m / 4)) := by + unfold pairM_side unary + dsimp only + have ha1 : a = (a - 1) + 1 := by omega + rw [bitsM_eq_of_eq m (by omega) (bitsM_00 (m / 4))] + conv_lhs => rw [ha1, pow_succ_list, append_assoc] + rw [hun] + have hevH := evalH_spec hev (a - 2) (m / 4) + have hsub : (a - 1) - 1 = a - 2 := by omega + have hadd1 : (a - 1) + 1 = a := by omega + have hT := T00N bitsM (a - 1) (bitsM (m / 4)) (evalH ev (a - 2) (m / 4)) (by omega) + (by rwa [hsub]) + rw [hadd1] at hT + have hR := rule_spec (fun pm => unary a (bitsM pm)) GU hT + cases hh : evalH ev (a - 2) (m / 4) with + | failed => trivial + | stopped => rw [hh] at hR; exact hR + | returned pm => + rw [hh] at hR + dsimp only [evalToP, Spec] at hR ⊢ + exact collect_tail_side a pm hR + | false => + dsimp only + have htc := tcallT_spec hev tfuel (a - 1) m + have hun : pairM_side (a, m) = U +> unary (a - 1) (bitsM m) := by + unfold pairM_side unary + dsimp only + have ha1 : a = (a - 1) + 1 := by omega + conv_lhs => rw [ha1, pow_succ_list, append_assoc] + rw [hun] + have hR := rule_spec pairM_side GU htc + cases htc_res : tcallT tfuel ev (a - 1) m with + | failed => trivial + | stopped => rw [htc_res] at hR; exact hR + | ret pa pm => + rw [htc_res] at hR + dsimp only [mapRetP, toResultP, Spec] at hR ⊢ + exact collect_tail_side pa pm hR + +def rootM (a m : Nat) : Cfg (Fin 2) (Fin 6) := + default <{{C}} ([1] +> pairM_side (a, m)) + +theorem emit (r : ListBlank (Fin 2)) : + (default <{{C}} ([1] +> r)) [tm]⊢⁺ (toDHCfg ((E, [0, 0]), .right) default r) := by + dsimp [toDHCfg] + tm_steps + +theorem init_reaches_rootM : + (init []) [tm]⊢* (rootM 0 1) := by + have h_init : (init [] : Cfg (Fin 2) (Fin 6)) = (default {{A}}> default) := rfl + have hb1 : bitsM 1 = ([1] : List (Fin 2)) +> default := by + exact (bitsM_bit1 0).trans (by rw [bitsM_zero]; rfl) + rw [h_init] + unfold rootM pairM_side unary + rw [hb1] + dsimp [U] + tm_steps + +def machineM_spec (a m : Nat) (o : ResP) : Prop := + match o with + | .failed => True + | .stopped => HaltsFrom tm (rootM a m) + | .ret a' m' => (rootM a m) [tm]⊢* (rootM a' m') + +theorem roundT_machine (tfuel efuel a m : Nat) : + machineM_spec a m (roundT tfuel (evalT efuel) a m) := by + have H := roundT_spec (evalT_spec efuel) tfuel a m + cases hr : roundT tfuel (evalT efuel) a m with + | failed => trivial + | stopped => + rw [hr] at H + exact HaltsFrom.of_reachesStar (stepPlus_to_stepStar (emit (pairM_side (a, m)))) + (H.elim_single default) + | ret a' m' => + rw [hr] at H + exact stepPlus_to_stepStar (stepPlus_trans (emit (pairM_side (a, m))) (H.elim_single default)) + +theorem runT_spec (fuel tfuel efuel a m : Nat) : + machineM_spec a m (runT fuel tfuel efuel a m) := by + induction fuel generalizing a m with + | zero => exact stepStar_refl tm (rootM a m) + | succ fuel ih => + change machineM_spec a m (runT_step tfuel (evalT efuel) (runT fuel tfuel efuel) a m) + unfold runT_step + have hr := roundT_machine tfuel efuel a m + cases hrm : roundT tfuel (evalT efuel) a m with + | failed => trivial + | stopped => rw [hrm] at hr; exact hr + | ret a' m' => + rw [hrm] at hr + dsimp only [mapRetP] + have hnext := ih a' m' + cases hrun : runT fuel tfuel efuel a' m' with + | failed => trivial + | stopped => rw [hrun] at hnext; exact HaltsFrom.of_reachesStar hr hnext + | ret a2 m2 => rw [hrun] at hnext; exact stepStar_trans hr hnext + +theorem runT_chk_step {fuel a m ta tm_exp : Nat} + (hchk : runT_chk fuel a m ta tm_exp = true) + (htgt : HaltsFrom tm (rootM ta tm_exp)) : + HaltsFrom tm (rootM a m) := by + unfold runT_chk at hchk + have hs := runT_spec fuel 64 256 a m + cases hr : runT fuel 64 256 a m with + | failed => rw [hr] at hchk; cases hchk + | stopped => rw [hr] at hchk; cases hchk + | ret a' m' => + rw [hr] at hchk hs + dsimp only at hchk + cases ha : Nat.beq a' ta with + | false => rw [ha] at hchk; cases hchk + | true => + rw [ha] at hchk; dsimp only at hchk + rw [Nat.eq_of_beq_eq_true ha, Nat.eq_of_beq_eq_true hchk] at hs + exact HaltsFrom.of_reachesStar hs htgt + +theorem runT_halt_spec {fuel a m : Nat} + (hhalt : runT_halt fuel a m = true) : + HaltsFrom tm (rootM a m) := by + unfold runT_halt at hhalt + have hs := runT_spec fuel 64 256 a m + cases hr : runT fuel 64 256 a m with + | failed => rw [hr] at hhalt; cases hhalt + | ret _ _ => rw [hr] at hhalt; cases hhalt + | stopped => rw [hr] at hs; exact hs + +theorem halt_of_rootM01 (H : HaltsFrom tm (rootM 0 1)) : IsHalt target_tm := by + obtain ⟨cfg, h_reach, h_none⟩ := HaltsFrom.of_reachesStar init_reaches_rootM H + refine ⟨flipCfg cfg, ?_, ?_⟩ + · exact stepStar_unflipTM h_reach + · rw [Option.isNone_iff_eq_none] at h_none ⊢ + have h_step := step_flipTM tm cfg + rw [flipTM_flipTM, h_none] at h_step + exact h_step + +private theorem chunk_0 : runT_chk 6400 0 1 12593 8818796 = true := by decide +kernel +private theorem chunk_1 : runT_chk 6400 12593 8818796 25235 11704360 = true := by decide +kernel +private theorem chunk_2 : runT_chk 6400 25235 11704360 37998 10754093 = true := by decide +kernel +private theorem chunk_3 : runT_chk 6400 37998 10754093 50947 11829824 = true := by decide +kernel +private theorem chunk_4 : runT_chk 6400 50947 11829824 63532 2396997 = true := by decide +kernel +private theorem chunk_5 : runT_chk 6400 63532 2396997 76241 353398852384 = true := by decide +kernel +private theorem chunk_6 : runT_chk 6400 76241 353398852384 88987 8819213 = true := by decide +kernel +private theorem chunk_7 : runT_chk 6400 88987 8819213 101756 1315396 = true := by decide +kernel +private theorem chunk_8 : runT_chk 6400 101756 1315396 114527 11847680 = true := by decide +kernel +private theorem chunk_9 : runT_chk 6400 114527 11847680 127285 537970789 = true := by decide +kernel +private theorem chunk_10 : runT_chk 6400 127285 537970789 140058 35655045632 = true := by + decide +kernel +private theorem chunk_11 : runT_chk 6400 140058 35655045632 152712 20748 = true := by decide +kernel +private theorem chunk_12 : runT_chk 6400 152712 20748 165515 689178664 = true := by decide +kernel +private theorem chunk_13 : runT_chk 6400 165515 689178664 178517 4524654600 = true := by + decide +kernel +private theorem chunk_14 : runT_chk 6400 178517 4524654600 191204 699828256 = true := by + decide +kernel +private theorem chunk_15 : runT_chk 6400 191204 699828256 203927 682803276 = true := by + decide +kernel +private theorem chunk_16 : runT_chk 6400 203927 682803276 216710 738611813 = true := by + decide +kernel +private theorem chunk_17 : runT_chk 6400 216710 738611813 229298 87033928 = true := by + decide +kernel +private theorem chunk_18 : runT_chk 6400 229298 87033928 242036 1731955742471522852 = true := by + decide +kernel +private theorem chunk_19 : runT_chk 6400 242036 1731955742471522852 254784 682935085 = true := by + decide +kernel +private theorem chunk_20 : runT_chk 6400 254784 682935085 267535 10652420 = true := by + decide +kernel +private theorem chunk_21 : runT_chk 6400 267535 10652420 280239 556030828 = true := by + decide +kernel +private theorem chunk_22 : runT_chk 6400 280239 556030828 292798 679533316 = true := by + decide +kernel +private theorem chunk_23 : runT_chk 6400 292798 679533316 305363 4323711789 = true := by + decide +kernel +private theorem chunk_24 : runT_chk 6400 305363 4323711789 317940 755141476 = true := by + decide +kernel +private theorem chunk_25 : runT_chk 6400 317940 755141476 330603 565348416 = true := by + decide +kernel +private theorem chunk_26 : runT_chk 6400 330603 565348416 343499 741364261 = true := by + decide +kernel +private theorem chunk_27 : runT_chk 6400 343499 741364261 356222 763511141 = true := by + decide +kernel +private theorem chunk_28 : runT_chk 6400 356222 763511141 368743 681612077 = true := by + decide +kernel +private theorem chunk_29 : runT_chk 6400 368743 681612077 381601 739660069 = true := by + decide +kernel +private theorem chunk_30 : runT_chk 6400 381601 739660069 394329 755143424 = true := by + decide +kernel +private theorem chunk_31 : runT_chk 6400 394329 755143424 407198 564155213 = true := by + decide +kernel +private theorem chunk_32 : runT_chk 6400 407198 564155213 419930 557224448 = true := by + decide +kernel +private theorem chunk_33 : runT_chk 6400 419930 557224448 432658 70539852 = true := by + decide +kernel +private theorem chunk_34 : runT_chk 6400 432658 70539852 445371 629459752 = true := by + decide +kernel +private theorem chunk_35 : runT_chk 6400 445371 629459752 458224 691159368 = true := by + decide +kernel +private theorem chunk_36 : runT_chk 6400 458224 691159368 471175 757109024 = true := by + decide +kernel +private theorem chunk_37 : runT_chk 6400 471175 757109024 483802 5596271148 = true := by + decide +kernel +private theorem chunk_38 : runT_chk 6400 483802 5596271148 496578 755030028 = true := by + decide +kernel +private theorem chunk_39 : runT_chk 6400 496578 755030028 509523 547373677 = true := by + decide +kernel +private theorem chunk_40 : runT_chk 6400 509523 547373677 522244 673597733 = true := by + decide +kernel +private theorem chunk_41 : runT_chk 6400 522244 673597733 535122 2759134204000 = true := by + decide +kernel +private theorem chunk_42 : runT_chk 6400 535122 2759134204000 547837 538101804 = true := by + decide +kernel +private theorem chunk_43 : runT_chk 6400 547837 538101804 560792 1130926791088716 = true := by + decide +kernel +private theorem chunk_44 : runT_chk 6400 560792 1130926791088716 573724 614767372 = true := by + decide +kernel +private theorem chunk_45 : runT_chk 6400 573724 614767372 586487 629574496 = true := by + decide +kernel +private theorem chunk_46 : runT_chk 6400 586487 629574496 599316 631652965 = true := by + decide +kernel +private theorem chunk_47 : runT_chk 6400 599316 631652965 612071 629166341 = true := by + decide +kernel +private theorem chunk_48 : runT_chk 6400 612071 629166341 624737 631523884 = true := by + decide +kernel +private theorem chunk_49 : runT_chk 6400 624737 631523884 637630 5453814568 = true := by + decide +kernel +private theorem chunk_50 : runT_chk 6400 637630 5453814568 650335 44704337920 = true := by + decide +kernel +private theorem chunk_51 : runT_chk 6400 650335 44704337920 663130 607277132 = true := by + decide +kernel +private theorem chunk_52 : runT_chk 6400 663130 607277132 675912 740332388 = true := by + decide +kernel +private theorem chunk_53 : runT_chk 6400 675912 740332388 688663 765481224 = true := by + decide +kernel +private theorem chunk_54 : runT_chk 6400 688663 765481224 701509 18221091787016 = true := by + decide +kernel +private theorem chunk_55 : runT_chk 6400 701509 18221091787016 714323 6133422189 = true := by + decide +kernel +private theorem chunk_56 : runT_chk 6400 714323 6133422189 727195 698405696 = true := by + decide +kernel +private theorem chunk_57 : runT_chk 6400 727195 698405696 739929 691406880 = true := by + decide +kernel +private theorem chunk_58 : runT_chk 6400 739929 691406880 752893 5595470181 = true := by + decide +kernel +private theorem chunk_59 : runT_chk 6400 752893 5595470181 765593 5505178124 = true := by + decide +kernel +private theorem chunk_60 : runT_chk 6400 765593 5505178124 778344 36180246637 = true := by + decide +kernel +private theorem chunk_61 : runT_chk 6400 778344 36180246637 791032 5504402028 = true := by + decide +kernel +private theorem chunk_62 : runT_chk 6400 791032 5504402028 803867 5438968416 = true := by + decide +kernel +private theorem chunk_63 : runT_chk 6400 803867 5438968416 816770 5041740044 = true := by + decide +kernel +private theorem chunk_64 : runT_chk 6400 816770 5041740044 829360 1688521324 = true := by + decide +kernel +private theorem chunk_65 : runT_chk 6400 829360 1688521324 842050 5462444292 = true := by + decide +kernel +private theorem chunk_66 : runT_chk 6400 842050 5462444292 854658 35503132677 = true := by + decide +kernel +private theorem chunk_67 : runT_chk 6400 854658 35503132677 867544 4857037096 = true := by + decide +kernel +private theorem chunk_68 : runT_chk 6400 867544 4857037096 880465 5924606060 = true := by + decide +kernel +private theorem chunk_69 : runT_chk 6400 880465 5924606060 893181 696423200 = true := by + decide +kernel +private theorem chunk_70 : runT_chk 6400 893181 696423200 905958 5570465829 = true := by + decide +kernel +private theorem chunk_71 : runT_chk 6400 905958 5570465829 918560 5587126316 = true := by + decide +kernel +private theorem chunk_72 : runT_chk 6400 918560 5587126316 931438 697752109 = true := by + decide +kernel +private theorem chunk_73 : runT_chk 6400 931438 697752109 944197 5908859468 = true := by + decide +kernel +private theorem chunk_74 : runT_chk 6400 944197 5908859468 956812 5452763429 = true := by + decide +kernel +private theorem chunk_75 : runT_chk 6400 956812 5452763429 969696 5916197124 = true := by + decide +kernel +private theorem chunk_76 : runT_chk 6400 969696 5916197124 982467 671240740 = true := by + decide +kernel +private theorem chunk_77 : runT_chk 6400 982467 671240740 995065 95476069 = true := by + decide +kernel +private theorem chunk_78 : runT_chk 6400 995065 95476069 1007858 739379520 = true := by + decide +kernel +private theorem chunk_79 : runT_chk 6400 1007858 739379520 1020513 5372168296 = true := by + decide +kernel +private theorem chunk_80 : runT_chk 6400 1020513 5372168296 1033229 671371533 = true := by + decide +kernel +private theorem chunk_81 : runT_chk 6400 1033229 671371533 1046044 6116526605 = true := by + decide +kernel +private theorem chunk_82 : runT_chk 6400 1046044 6116526605 1058729 672547620 = true := by + decide +kernel +private theorem chunk_83 : runT_chk 6400 1058729 672547620 1071541 672192588 = true := by + decide +kernel +private theorem chunk_84 : runT_chk 6400 1071541 672192588 1084175 21925272956179430431533 = true := + by decide +kernel +private theorem chunk_85 : runT_chk 6400 1084175 21925272956179430431533 1096957 48481092160 = + true := by decide +kernel +private theorem chunk_86 : runT_chk 6400 1096957 48481092160 1109745 688311080 = true := by + decide +kernel +private theorem chunk_87 : runT_chk 6400 1109745 688311080 1122300 5371250952 = true := by + decide +kernel +private theorem chunk_88 : runT_chk 6400 1122300 5371250952 1135104 283627389740 = true := by + decide +kernel +private theorem chunk_89 : runT_chk 6400 1135104 283627389740 1147873 5521054028 = true := by + decide +kernel +private theorem chunk_90 : runT_chk 6400 1147873 5521054028 1160581 94666764 = true := by + decide +kernel +private theorem chunk_91 : runT_chk 6400 1160581 94666764 1173249 4457765476 = true := by + decide +kernel +private theorem chunk_92 : runT_chk 6400 1173249 4457765476 1186166 6048598341 = true := by + decide +kernel +private theorem chunk_93 : runT_chk 6400 1186166 6048598341 1198988 1822839592 = true := by + decide +kernel +private theorem chunk_94 : runT_chk 6400 1198988 1822839592 1211753 6059858757 = true := by + decide +kernel +private theorem chunk_95 : runT_halt 6400 1211753 6059858757 = true := by decide +kernel + +end Solution + + + +public section + +theorem is_halt : IsHalt target := by + have h95 : HaltsFrom Solution.tm (Solution.rootM 1211753 6059858757) := + Solution.runT_halt_spec Solution.chunk_95 + have h94 : HaltsFrom Solution.tm (Solution.rootM 1198988 1822839592) := + Solution.runT_chk_step Solution.chunk_94 h95 + have h93 : HaltsFrom Solution.tm (Solution.rootM 1186166 6048598341) := + Solution.runT_chk_step Solution.chunk_93 h94 + have h92 : HaltsFrom Solution.tm (Solution.rootM 1173249 4457765476) := + Solution.runT_chk_step Solution.chunk_92 h93 + have h91 : HaltsFrom Solution.tm (Solution.rootM 1160581 94666764) := + Solution.runT_chk_step Solution.chunk_91 h92 + have h90 : HaltsFrom Solution.tm (Solution.rootM 1147873 5521054028) := + Solution.runT_chk_step Solution.chunk_90 h91 + have h89 : HaltsFrom Solution.tm (Solution.rootM 1135104 283627389740) := + Solution.runT_chk_step Solution.chunk_89 h90 + have h88 : HaltsFrom Solution.tm (Solution.rootM 1122300 5371250952) := + Solution.runT_chk_step Solution.chunk_88 h89 + have h87 : HaltsFrom Solution.tm (Solution.rootM 1109745 688311080) := + Solution.runT_chk_step Solution.chunk_87 h88 + have h86 : HaltsFrom Solution.tm (Solution.rootM 1096957 48481092160) := + Solution.runT_chk_step Solution.chunk_86 h87 + have h85 : HaltsFrom Solution.tm (Solution.rootM 1084175 21925272956179430431533) := + Solution.runT_chk_step Solution.chunk_85 h86 + have h84 : HaltsFrom Solution.tm (Solution.rootM 1071541 672192588) := + Solution.runT_chk_step Solution.chunk_84 h85 + have h83 : HaltsFrom Solution.tm (Solution.rootM 1058729 672547620) := + Solution.runT_chk_step Solution.chunk_83 h84 + have h82 : HaltsFrom Solution.tm (Solution.rootM 1046044 6116526605) := + Solution.runT_chk_step Solution.chunk_82 h83 + have h81 : HaltsFrom Solution.tm (Solution.rootM 1033229 671371533) := + Solution.runT_chk_step Solution.chunk_81 h82 + have h80 : HaltsFrom Solution.tm (Solution.rootM 1020513 5372168296) := + Solution.runT_chk_step Solution.chunk_80 h81 + have h79 : HaltsFrom Solution.tm (Solution.rootM 1007858 739379520) := + Solution.runT_chk_step Solution.chunk_79 h80 + have h78 : HaltsFrom Solution.tm (Solution.rootM 995065 95476069) := + Solution.runT_chk_step Solution.chunk_78 h79 + have h77 : HaltsFrom Solution.tm (Solution.rootM 982467 671240740) := + Solution.runT_chk_step Solution.chunk_77 h78 + have h76 : HaltsFrom Solution.tm (Solution.rootM 969696 5916197124) := + Solution.runT_chk_step Solution.chunk_76 h77 + have h75 : HaltsFrom Solution.tm (Solution.rootM 956812 5452763429) := + Solution.runT_chk_step Solution.chunk_75 h76 + have h74 : HaltsFrom Solution.tm (Solution.rootM 944197 5908859468) := + Solution.runT_chk_step Solution.chunk_74 h75 + have h73 : HaltsFrom Solution.tm (Solution.rootM 931438 697752109) := + Solution.runT_chk_step Solution.chunk_73 h74 + have h72 : HaltsFrom Solution.tm (Solution.rootM 918560 5587126316) := + Solution.runT_chk_step Solution.chunk_72 h73 + have h71 : HaltsFrom Solution.tm (Solution.rootM 905958 5570465829) := + Solution.runT_chk_step Solution.chunk_71 h72 + have h70 : HaltsFrom Solution.tm (Solution.rootM 893181 696423200) := + Solution.runT_chk_step Solution.chunk_70 h71 + have h69 : HaltsFrom Solution.tm (Solution.rootM 880465 5924606060) := + Solution.runT_chk_step Solution.chunk_69 h70 + have h68 : HaltsFrom Solution.tm (Solution.rootM 867544 4857037096) := + Solution.runT_chk_step Solution.chunk_68 h69 + have h67 : HaltsFrom Solution.tm (Solution.rootM 854658 35503132677) := + Solution.runT_chk_step Solution.chunk_67 h68 + have h66 : HaltsFrom Solution.tm (Solution.rootM 842050 5462444292) := + Solution.runT_chk_step Solution.chunk_66 h67 + have h65 : HaltsFrom Solution.tm (Solution.rootM 829360 1688521324) := + Solution.runT_chk_step Solution.chunk_65 h66 + have h64 : HaltsFrom Solution.tm (Solution.rootM 816770 5041740044) := + Solution.runT_chk_step Solution.chunk_64 h65 + have h63 : HaltsFrom Solution.tm (Solution.rootM 803867 5438968416) := + Solution.runT_chk_step Solution.chunk_63 h64 + have h62 : HaltsFrom Solution.tm (Solution.rootM 791032 5504402028) := + Solution.runT_chk_step Solution.chunk_62 h63 + have h61 : HaltsFrom Solution.tm (Solution.rootM 778344 36180246637) := + Solution.runT_chk_step Solution.chunk_61 h62 + have h60 : HaltsFrom Solution.tm (Solution.rootM 765593 5505178124) := + Solution.runT_chk_step Solution.chunk_60 h61 + have h59 : HaltsFrom Solution.tm (Solution.rootM 752893 5595470181) := + Solution.runT_chk_step Solution.chunk_59 h60 + have h58 : HaltsFrom Solution.tm (Solution.rootM 739929 691406880) := + Solution.runT_chk_step Solution.chunk_58 h59 + have h57 : HaltsFrom Solution.tm (Solution.rootM 727195 698405696) := + Solution.runT_chk_step Solution.chunk_57 h58 + have h56 : HaltsFrom Solution.tm (Solution.rootM 714323 6133422189) := + Solution.runT_chk_step Solution.chunk_56 h57 + have h55 : HaltsFrom Solution.tm (Solution.rootM 701509 18221091787016) := + Solution.runT_chk_step Solution.chunk_55 h56 + have h54 : HaltsFrom Solution.tm (Solution.rootM 688663 765481224) := + Solution.runT_chk_step Solution.chunk_54 h55 + have h53 : HaltsFrom Solution.tm (Solution.rootM 675912 740332388) := + Solution.runT_chk_step Solution.chunk_53 h54 + have h52 : HaltsFrom Solution.tm (Solution.rootM 663130 607277132) := + Solution.runT_chk_step Solution.chunk_52 h53 + have h51 : HaltsFrom Solution.tm (Solution.rootM 650335 44704337920) := + Solution.runT_chk_step Solution.chunk_51 h52 + have h50 : HaltsFrom Solution.tm (Solution.rootM 637630 5453814568) := + Solution.runT_chk_step Solution.chunk_50 h51 + have h49 : HaltsFrom Solution.tm (Solution.rootM 624737 631523884) := + Solution.runT_chk_step Solution.chunk_49 h50 + have h48 : HaltsFrom Solution.tm (Solution.rootM 612071 629166341) := + Solution.runT_chk_step Solution.chunk_48 h49 + have h47 : HaltsFrom Solution.tm (Solution.rootM 599316 631652965) := + Solution.runT_chk_step Solution.chunk_47 h48 + have h46 : HaltsFrom Solution.tm (Solution.rootM 586487 629574496) := + Solution.runT_chk_step Solution.chunk_46 h47 + have h45 : HaltsFrom Solution.tm (Solution.rootM 573724 614767372) := + Solution.runT_chk_step Solution.chunk_45 h46 + have h44 : HaltsFrom Solution.tm (Solution.rootM 560792 1130926791088716) := + Solution.runT_chk_step Solution.chunk_44 h45 + have h43 : HaltsFrom Solution.tm (Solution.rootM 547837 538101804) := + Solution.runT_chk_step Solution.chunk_43 h44 + have h42 : HaltsFrom Solution.tm (Solution.rootM 535122 2759134204000) := + Solution.runT_chk_step Solution.chunk_42 h43 + have h41 : HaltsFrom Solution.tm (Solution.rootM 522244 673597733) := + Solution.runT_chk_step Solution.chunk_41 h42 + have h40 : HaltsFrom Solution.tm (Solution.rootM 509523 547373677) := + Solution.runT_chk_step Solution.chunk_40 h41 + have h39 : HaltsFrom Solution.tm (Solution.rootM 496578 755030028) := + Solution.runT_chk_step Solution.chunk_39 h40 + have h38 : HaltsFrom Solution.tm (Solution.rootM 483802 5596271148) := + Solution.runT_chk_step Solution.chunk_38 h39 + have h37 : HaltsFrom Solution.tm (Solution.rootM 471175 757109024) := + Solution.runT_chk_step Solution.chunk_37 h38 + have h36 : HaltsFrom Solution.tm (Solution.rootM 458224 691159368) := + Solution.runT_chk_step Solution.chunk_36 h37 + have h35 : HaltsFrom Solution.tm (Solution.rootM 445371 629459752) := + Solution.runT_chk_step Solution.chunk_35 h36 + have h34 : HaltsFrom Solution.tm (Solution.rootM 432658 70539852) := + Solution.runT_chk_step Solution.chunk_34 h35 + have h33 : HaltsFrom Solution.tm (Solution.rootM 419930 557224448) := + Solution.runT_chk_step Solution.chunk_33 h34 + have h32 : HaltsFrom Solution.tm (Solution.rootM 407198 564155213) := + Solution.runT_chk_step Solution.chunk_32 h33 + have h31 : HaltsFrom Solution.tm (Solution.rootM 394329 755143424) := + Solution.runT_chk_step Solution.chunk_31 h32 + have h30 : HaltsFrom Solution.tm (Solution.rootM 381601 739660069) := + Solution.runT_chk_step Solution.chunk_30 h31 + have h29 : HaltsFrom Solution.tm (Solution.rootM 368743 681612077) := + Solution.runT_chk_step Solution.chunk_29 h30 + have h28 : HaltsFrom Solution.tm (Solution.rootM 356222 763511141) := + Solution.runT_chk_step Solution.chunk_28 h29 + have h27 : HaltsFrom Solution.tm (Solution.rootM 343499 741364261) := + Solution.runT_chk_step Solution.chunk_27 h28 + have h26 : HaltsFrom Solution.tm (Solution.rootM 330603 565348416) := + Solution.runT_chk_step Solution.chunk_26 h27 + have h25 : HaltsFrom Solution.tm (Solution.rootM 317940 755141476) := + Solution.runT_chk_step Solution.chunk_25 h26 + have h24 : HaltsFrom Solution.tm (Solution.rootM 305363 4323711789) := + Solution.runT_chk_step Solution.chunk_24 h25 + have h23 : HaltsFrom Solution.tm (Solution.rootM 292798 679533316) := + Solution.runT_chk_step Solution.chunk_23 h24 + have h22 : HaltsFrom Solution.tm (Solution.rootM 280239 556030828) := + Solution.runT_chk_step Solution.chunk_22 h23 + have h21 : HaltsFrom Solution.tm (Solution.rootM 267535 10652420) := + Solution.runT_chk_step Solution.chunk_21 h22 + have h20 : HaltsFrom Solution.tm (Solution.rootM 254784 682935085) := + Solution.runT_chk_step Solution.chunk_20 h21 + have h19 : HaltsFrom Solution.tm (Solution.rootM 242036 1731955742471522852) := + Solution.runT_chk_step Solution.chunk_19 h20 + have h18 : HaltsFrom Solution.tm (Solution.rootM 229298 87033928) := + Solution.runT_chk_step Solution.chunk_18 h19 + have h17 : HaltsFrom Solution.tm (Solution.rootM 216710 738611813) := + Solution.runT_chk_step Solution.chunk_17 h18 + have h16 : HaltsFrom Solution.tm (Solution.rootM 203927 682803276) := + Solution.runT_chk_step Solution.chunk_16 h17 + have h15 : HaltsFrom Solution.tm (Solution.rootM 191204 699828256) := + Solution.runT_chk_step Solution.chunk_15 h16 + have h14 : HaltsFrom Solution.tm (Solution.rootM 178517 4524654600) := + Solution.runT_chk_step Solution.chunk_14 h15 + have h13 : HaltsFrom Solution.tm (Solution.rootM 165515 689178664) := + Solution.runT_chk_step Solution.chunk_13 h14 + have h12 : HaltsFrom Solution.tm (Solution.rootM 152712 20748) := + Solution.runT_chk_step Solution.chunk_12 h13 + have h11 : HaltsFrom Solution.tm (Solution.rootM 140058 35655045632) := + Solution.runT_chk_step Solution.chunk_11 h12 + have h10 : HaltsFrom Solution.tm (Solution.rootM 127285 537970789) := + Solution.runT_chk_step Solution.chunk_10 h11 + have h9 : HaltsFrom Solution.tm (Solution.rootM 114527 11847680) := + Solution.runT_chk_step Solution.chunk_9 h10 + have h8 : HaltsFrom Solution.tm (Solution.rootM 101756 1315396) := + Solution.runT_chk_step Solution.chunk_8 h9 + have h7 : HaltsFrom Solution.tm (Solution.rootM 88987 8819213) := + Solution.runT_chk_step Solution.chunk_7 h8 + have h6 : HaltsFrom Solution.tm (Solution.rootM 76241 353398852384) := + Solution.runT_chk_step Solution.chunk_6 h7 + have h5 : HaltsFrom Solution.tm (Solution.rootM 63532 2396997) := + Solution.runT_chk_step Solution.chunk_5 h6 + have h4 : HaltsFrom Solution.tm (Solution.rootM 50947 11829824) := + Solution.runT_chk_step Solution.chunk_4 h5 + have h3 : HaltsFrom Solution.tm (Solution.rootM 37998 10754093) := + Solution.runT_chk_step Solution.chunk_3 h4 + have h2 : HaltsFrom Solution.tm (Solution.rootM 25235 11704360) := + Solution.runT_chk_step Solution.chunk_2 h3 + have h1 : HaltsFrom Solution.tm (Solution.rootM 12593 8818796) := + Solution.runT_chk_step Solution.chunk_1 h2 + have h0 : HaltsFrom Solution.tm (Solution.rootM 0 1) := Solution.runT_chk_step Solution.chunk_0 h1 + exact Solution.halt_of_rootM01 h0 + +end + +end BusyBeaver.M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH diff --git a/BusyBeaver/BB6/NonHalt/M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA.lean b/BusyBeaver/BB6/NonHalt/M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA.lean new file mode 100644 index 00000000..b1b2f3c5 --- /dev/null +++ b/BusyBeaver/BB6/NonHalt/M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA.lean @@ -0,0 +1,10654 @@ +/- +Copyright (c) 2026 Google LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +-/ +module + +import BusyBeaver.Basic +public import BusyBeaver.Bridge + +open Relation Nat Turing BusyBeaver SixState + +namespace BusyBeaver.M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA + +@[expose] public section + +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA" + +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB + +end + +section + +abbrev target_tm : Machine (Fin 2) (Fin 6) := target + +local notation "zB" => ListBlank (Fin 2) +local notation "zF" => List (Fin 2) +local infixr:67 " ::ᵇ " => Turing.ListBlank.cons + +abbrev A : Fin 6 := 0 +abbrev B : Fin 6 := 1 +abbrev C : Fin 6 := 2 +abbrev E : Fin 6 := 4 +abbrev F : Fin 6 := 5 + +@[simp] theorem list_append_inj (xs l1 l2 : List Nat) : (xs ++ l1 = xs ++ l2) ↔ l1 = l2 := + List.append_right_inj xs + +structure Sim where + q : Fin 6 + dir : Dir + l : zF + r : zF + +def Sim.toCfg (x : Sim) (l₀ r₀ : zB) : Cfg (Fin 2) (Fin 6) := + match x.dir with + | .left => (x.l +> l₀) <{{x.q}} (x.r +> r₀) + | .right => (x.l +> l₀) {{x.q}}> (x.r +> r₀) + +def simStep (x : Sim) : Option Sim := + match x.dir with + | .left => + match x.l with + | [] => none + | a :: l' => + match target_tm x.q a with + | some (some q', Stmt.write w .left) => some ⟨q', .left, l', w :: x.r⟩ + | some (some q', Stmt.write w .right) => some ⟨q', .right, w :: l', x.r⟩ + | _ => none + | .right => + match x.r with + | [] => none + | a :: r' => + match target_tm x.q a with + | some (some q', Stmt.write w .left) => some ⟨q', .left, x.l, w :: r'⟩ + | some (some q', Stmt.write w .right) => some ⟨q', .right, w :: x.l, r'⟩ + | _ => none + +theorem simStep_sound (x x' : Sim) (h : simStep x = some x') (l₀ r₀ : zB) : + (x.toCfg l₀ r₀) [target_tm]⊢ (x'.toCfg l₀ r₀) := by + rcases x with ⟨q, _ | _, l, r⟩ + · rcases l with _ | ⟨a, l'⟩ + · cases h + · dsimp [simStep] at h + rcases hM : target_tm q a with _ | ⟨_ | q', ⟨w, _ | _⟩⟩ <;> rw [hM] at h <;> cases h <;> + simp [Sim.toCfg, step, hM, Tape.write, Tape.move] + · rcases r with _ | ⟨a, r'⟩ + · cases h + · dsimp [simStep] at h + rcases hM : target_tm q a with _ | ⟨_ | q', ⟨w, _ | _⟩⟩ <;> rw [hM] at h <;> cases h <;> + simp [Sim.toCfg, step, hM, Tape.write, Tape.move] + +def simSteps : Nat → Sim → Option Sim + | 0, x => some x + | n + 1, x => (simStep x).bind (simSteps n) + +theorem simSteps_sound : ∀ (n : Nat) (x x' : Sim), + simSteps n x = some x' → ∀ (l₀ r₀ : zB), (x.toCfg l₀ r₀) [target_tm]⊢^{n} (x'.toCfg l₀ r₀) + | 0, x, x', h, l₀, r₀ => by cases h; rfl + | n + 1, x, x', h, l₀, r₀ => by + dsimp [simSteps] at h + rcases hs : simStep x with _ | y <;> rw [hs] at h + · cases h + · have h1 : (x.toCfg l₀ r₀) [target_tm]⊢^{1} (y.toCfg l₀ r₀) := simStep_sound x y hs l₀ r₀ + have h2 := simSteps_sound n y x' h l₀ r₀ + rw [Nat.add_comm n 1] + exact multiStep_trans h1 h2 + +theorem simSteps_star {n : Nat} {x x' : Sim} (h : simSteps n x = some x') (l₀ r₀ : zB) : + (x.toCfg l₀ r₀) [target_tm]⊢* (x'.toCfg l₀ r₀) := + ⟨n, simSteps_sound n x x' h l₀ r₀⟩ + +theorem simSteps_star_ex (n : Nat) (x x' : Sim) (h : simSteps n x = some x') (l₀ r₀ : zB) : + (x.toCfg l₀ r₀) [target_tm]⊢* (x'.toCfg l₀ r₀) := + ⟨n, simSteps_sound n x x' h l₀ r₀⟩ + +theorem pow_comm_append (w : zF) (n : Nat) (s : zB) : + (w ^ n) +> (w +> s) = (w ^ (n + 1)) +> s := by + rw [← listblank_append_right_assoc, ← list_pow_succ' w n] + +theorem shiftL_gen {k : Nat} {q : Fin 6} {x x' d : zF} + (h : simSteps k ⟨q, .left, x, d⟩ = some ⟨q, .left, [], d ++ x'⟩) + (n : Nat) (l₀ r₀ : zB) : + (((x ^ n) +> l₀) <{{q}} (d +> r₀)) [target_tm]⊢* (l₀ <{{q}} (d +> ((x' ^ n) +> r₀))) := by + induction n generalizing r₀ with + | zero => exact ⟨0, rfl⟩ + | succ n ih => + rw [list_pow_succ, listblank_append_right_assoc] + have h1 := simSteps_star h ((x ^ n) +> l₀) r₀ + dsimp only [Sim.toCfg] at h1 + rw [listblank_append_nil, listblank_append_right_assoc] at h1 + have h2 := ih (x' +> r₀) + rw [pow_comm_append] at h2 + exact ReachesStar.trans h1 h2 + +theorem shiftR_gen {k : Nat} {q : Fin 6} {x x' d : zF} + (h : simSteps k ⟨q, .right, d, x⟩ = some ⟨q, .right, d ++ x', []⟩) + (n : Nat) (l₀ r₀ : zB) : + ((d +> l₀) {{q}}> ((x ^ n) +> r₀)) [target_tm]⊢* ((d +> ((x' ^ n) +> l₀)) {{q}}> r₀) := by + induction n generalizing l₀ with + | zero => exact ⟨0, rfl⟩ + | succ n ih => + rw [list_pow_succ, listblank_append_right_assoc] + have h1 := simSteps_star h l₀ ((x ^ n) +> r₀) + dsimp only [Sim.toCfg] at h1 + rw [listblank_append_nil, listblank_append_right_assoc] at h1 + have h2 := ih (x' +> l₀) + rw [pow_comm_append] at h2 + exact ReachesStar.trans h1 h2 + +theorem pow_add_1 (w : zF) (n : Nat) : w ^ (1 + n) = w ++ w ^ n := by + rw [Nat.add_comm 1 n]; rfl +theorem pow_add_2 (w : zF) (n : Nat) : w ^ (2 + n) = w ++ (w ++ w ^ n) := by + rw [Nat.add_comm 2 n]; rfl +theorem pow_add_3 (w : zF) (n : Nat) : w ^ (3 + n) = w ++ (w ++ (w ++ w ^ n)) := by + rw [Nat.add_comm 3 n]; rfl +theorem pow_add_4 (w : zF) (n : Nat) : w ^ (4 + n) = w ++ (w ++ (w ++ (w ++ w ^ n))) := by + rw [Nat.add_comm 4 n]; rfl +theorem pow_add_5 (w : zF) (n : Nat) : w ^ (5 + n) = w ++ (w ++ (w ++ (w ++ (w ++ w ^ n)))) := by + rw [Nat.add_comm 5 n]; rfl + +theorem pow_double3 (a b c : Fin 2) (n : Nat) : + ([a, b, c, a, b, c] : zF) ^ n = ([a, b, c] : zF) ^ (n * 2) := by + induction n with + | zero => rfl + | succ n ih => + have h : (n + 1) * 2 = n * 2 + 1 + 1 := by omega + rw [list_pow_succ, ih, h, list_pow_succ, list_pow_succ] + rfl + +theorem lpow_shift (a : Fin 2) (x : zF) (n : Nat) (s : zB) : + (((a :: x) ^ n) +> (a ::ᵇ s)) = a ::ᵇ (((x ++ [a]) ^ n) +> s) := by + induction n generalizing s with + | zero => rfl + | succ n ih => + rw [list_pow_succ, List.cons_append, listblank_append_cons, listblank_append_right_assoc, ih] + rw [list_pow_succ] + simp only [listblank_append_right_assoc, listblank_append_cons, listblank_append_nil] + +theorem shift2 (a b : Fin 2) (n : Nat) (s : zB) : + (([a, b] : zF) ^ n) +> (a ::ᵇ s) = a ::ᵇ ((([b, a] : zF) ^ n) +> s) := + lpow_shift a [b] n s + +theorem shift3 (a b c : Fin 2) (n : Nat) (s : zB) : + (([a, b, c] : zF) ^ n) +> (a ::ᵇ s) = a ::ᵇ ((([b, c, a] : zF) ^ n) +> s) := + lpow_shift a [b, c] n s + +theorem shift6 (a b c d e f : Fin 2) (n : Nat) (s : zB) : + (([a, b, c, d, e, f] : zF) ^ n) +> (a ::ᵇ s) = a ::ᵇ ((([b, c, d, e, f, a] : zF) ^ n) +> s) := + lpow_shift a [b, c, d, e, f] n s + +theorem shift2_0 (n : Nat) : + (([0, 1] : zF) ^ n) +> default = (0 : Fin 2) ::ᵇ ((([1, 0] : zF) ^ n) +> default) := by + conv_lhs => rw [← ListBlank.cons_zero_default] + exact shift2 0 1 n default + +theorem shift3_0_1 (c : Fin 2) (n : Nat) : + (([0, 1, c] : zF) ^ n) +> default = (0 : Fin 2) ::ᵇ ((([1, c, 0] : zF) ^ n) +> default) := by + conv_lhs => rw [← ListBlank.cons_zero_default] + exact shift3 0 1 c n default + +theorem shift3_0_01 (n : Nat) : + (([0, 0, 1] : zF) ^ n) +> default = (0 : Fin 2) ::ᵇ (0 : Fin 2) ::ᵇ ((([1, 0, 0] : zF) ^ n) + +> default) := by + conv_lhs => rw [← ListBlank.cons_zero_default] + rw [shift3 0 0 1 n default] + congr 1 + exact shift3_0_1 0 n + +theorem shift6_0_1 (c d e f : Fin 2) (n : Nat) : + (([0, 1, c, d, e, f] : zF) ^ n) +> default = (0 : Fin 2) ::ᵇ ((([1, c, d, e, f, 0] : zF) ^ n) + +> default) := by + conv_lhs => rw [← ListBlank.cons_zero_default] + exact shift6 0 1 c d e f n default + +theorem shift6_0_01 (d e f : Fin 2) (n : Nat) : + (([0, 0, 1, d, e, f] : zF) ^ n) +> default = + (0 : Fin 2) ::ᵇ (0 : Fin 2) ::ᵇ ((([1, d, e, f, 0, 0] : zF) ^ n) +> default) := by + conv_lhs => rw [← ListBlank.cons_zero_default] + rw [shift6 0 0 1 d e f n default] + congr 1 + exact shift6_0_1 d e f 0 n + +theorem pow_merge (w : zF) (m n : Nat) (s : zB) : + (w ^ m) +> ((w ^ n) +> s) = (w ^ (m + n)) +> s := by + rw [← listblank_append_right_assoc, ← list_pow_add] + +theorem step_bridge {c₁ c₁' c₂ c₃ : Cfg (Fin 2) (Fin 6)} + (h : c₁' [target_tm]⊢* c₂) (heq : c₁ = c₁') (hrest : c₂ [target_tm]⊢* c₃) : + c₁ [target_tm]⊢* c₃ := by + rw [heq]; exact ReachesStar.trans h hrest + +theorem step_end {c₁ c₁' c₂ c₂' : Cfg (Fin 2) (Fin 6)} + (h : c₁' [target_tm]⊢* c₂') (heq₁ : c₁ = c₁') (heq₂ : c₂' = c₂) : + c₁ [target_tm]⊢* c₂ := by + rw [heq₁, ← heq₂]; exact h + +-- 16 Shift Rules +theorem sr_0 (n : Nat) (l₀ r₀ : zB) : + ((([] : zF) +> l₀) {{A}}> ((([0, 0, 1, 1, 0, 1] : zF) ^ n) +> r₀)) [target_tm]⊢* + ((([] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) ^ n) +> l₀)) {{A}}> r₀) := + shiftR_gen (k := 6) rfl n l₀ r₀ + +theorem sr_1 (n : Nat) (l₀ r₀ : zB) : + ((([] : zF) +> l₀) {{A}}> ((([0, 1] : zF) ^ n) +> r₀)) [target_tm]⊢* + ((([] : zF) +> ((([0, 1] : zF) ^ n) +> l₀)) {{A}}> r₀) := + shiftR_gen (k := 2) rfl n l₀ r₀ + +theorem sr_2 (n : Nat) (l₀ r₀ : zB) : + ((((([1, 0] : zF) ^ n) +> l₀) <{{A}} (([] : zF) +> r₀))) [target_tm]⊢* + (l₀ <{{A}} (([] : zF) +> ((([1, 0] : zF) ^ n) +> r₀))) := + shiftL_gen (k := 4) rfl n l₀ r₀ + +theorem sr_3 (n : Nat) (l₀ r₀ : zB) : + ((((([1, 1, 0, 1, 1, 0] : zF) ^ n) +> l₀) <{{A}} (([] : zF) +> r₀))) [target_tm]⊢* + (l₀ <{{A}} (([] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ n) +> r₀))) := + shiftL_gen (k := 14) rfl n l₀ r₀ + +theorem sr_4 (n : Nat) (l₀ r₀ : zB) : + ((((([0, 1, 1, 0, 1, 1] : zF) ^ n) +> l₀) <{{E}} (([] : zF) +> r₀))) [target_tm]⊢* + (l₀ <{{E}} (([] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ n) +> r₀))) := + shiftL_gen (k := 14) rfl n l₀ r₀ + +theorem sr_5 (n : Nat) (l₀ r₀ : zB) : + ((((([1, 1, 0] : zF) ^ n) +> l₀) <{{C}} (([0, 1] : zF) +> r₀))) [target_tm]⊢* + (l₀ <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) ^ n) +> r₀))) := + shiftL_gen (k := 17) rfl n l₀ r₀ + +theorem sr_6 (n : Nat) (l₀ r₀ : zB) : + ((((([1, 1, 0, 1, 1, 0] : zF) ^ n) +> l₀) <{{C}} (([0, 1] : zF) +> r₀))) [target_tm]⊢* + (l₀ <{{C}} (([0, 1] : zF) +> ((([0, 1, 0, 0, 1, 0] : zF) ^ n) +> r₀))) := + shiftL_gen (k := 34) rfl n l₀ r₀ + +theorem sr_7 (n : Nat) (l₀ r₀ : zB) : + ((((([0, 1, 1, 0, 1, 1] : zF) ^ n) +> l₀) <{{A}} (([1, 0, 1, 1] : zF) +> r₀))) [target_tm]⊢* + (l₀ <{{A}} (([1, 0, 1, 1] : zF) +> ((([0, 1, 0, 0, 1, 0] : zF) ^ n) +> r₀))) := + shiftL_gen (k := 34) rfl n l₀ r₀ + +theorem sr_8 (n : Nat) (l₀ r₀ : zB) : + ((([] : zF) +> l₀) {{B}}> ((([1, 0, 0, 1, 1, 0] : zF) ^ n) +> r₀)) [target_tm]⊢* + ((([] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ n) +> l₀)) {{B}}> r₀) := + shiftR_gen (k := 6) rfl n l₀ r₀ + +theorem sr_9 (n : Nat) (l₀ r₀ : zB) : + ((([] : zF) +> l₀) {{B}}> ((([1, 0] : zF) ^ n) +> r₀)) [target_tm]⊢* + ((([] : zF) +> ((([1, 0] : zF) ^ n) +> l₀)) {{B}}> r₀) := + shiftR_gen (k := 2) rfl n l₀ r₀ + +theorem sr_10 (n : Nat) (l₀ r₀ : zB) : + ((((([1, 1, 0, 1, 1, 0] : zF) ^ n) +> l₀) <{{B}} (([1] : zF) +> r₀))) [target_tm]⊢* + (l₀ <{{B}} (([1] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ n) +> r₀))) := + shiftL_gen (k := 14) rfl n l₀ r₀ + +theorem sr_11 (n : Nat) (l₀ r₀ : zB) : + ((((([0, 1, 1, 0, 1, 1] : zF) ^ n) +> l₀) <{{C}} (([0] : zF) +> r₀))) [target_tm]⊢* + (l₀ <{{C}} (([0] : zF) +> ((([1, 0, 0, 1, 1, 0] : zF) ^ n) +> r₀))) := + shiftL_gen (k := 14) rfl n l₀ r₀ + +theorem sr_12 (n : Nat) (l₀ r₀ : zB) : + ((((([0, 1] : zF) ^ n) +> l₀) <{{C}} (([0] : zF) +> r₀))) [target_tm]⊢* + (l₀ <{{C}} (([0] : zF) +> ((([1, 0] : zF) ^ n) +> r₀))) := + shiftL_gen (k := 4) rfl n l₀ r₀ + +theorem sr_13 (n : Nat) (l₀ r₀ : zB) : + ((((([1, 0, 1, 1, 0, 1] : zF) ^ n) +> l₀) <{{A}} (([] : zF) +> r₀))) [target_tm]⊢* + (l₀ <{{A}} (([] : zF) +> ((([1, 0, 0, 1, 1, 0] : zF) ^ n) +> r₀))) := + shiftL_gen (k := 14) rfl n l₀ r₀ + +theorem sr_14 (n : Nat) (l₀ r₀ : zB) : + ((((([1, 0, 1, 1, 0, 1] : zF) ^ n) +> l₀) <{{C}} (([0] : zF) +> r₀))) [target_tm]⊢* + (l₀ <{{C}} (([0] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ n) +> r₀))) := + shiftL_gen (k := 14) rfl n l₀ r₀ + +theorem sr_15 (n : Nat) (l₀ r₀ : zB) : + ((([] : zF) +> l₀) {{C}}> ((([1, 1, 0, 1, 0, 0] : zF) ^ n) +> r₀)) [target_tm]⊢* + ((([] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ n) +> l₀)) {{C}}> r₀) := + shiftR_gen (k := 6) rfl n l₀ r₀ + + +theorem pow_add_right_2 (w : zF) (n : Nat) : w ^ (n + 2) = w ++ (w ++ w ^ n) := rfl +theorem pow_add_right_3 (w : zF) (n : Nat) : w ^ (n + 3) = w ++ (w ++ (w ++ w ^ n)) := rfl +theorem pow_add_right_4 (w : zF) (n : Nat) : w ^ (n + 4) = w ++ (w ++ (w ++ (w ++ w ^ n))) := rfl +theorem pow_add_right_5 (w : zF) (n : Nat) : w ^ (n + 5) + = w ++ (w ++ (w ++ (w ++ (w ++ w ^ n)))) := rfl + +theorem simSteps_plus (n : Nat) (hn : n > 0) (x x' : Sim) (h : simSteps n x = some x') + (l₀ r₀ : zB) : + (x.toCfg l₀ r₀) [target_tm]⊢⁺ (x'.toCfg l₀ r₀) := + ⟨n, hn, simSteps_sound n x x' h l₀ r₀⟩ + +theorem step_end_plus {c₁ c₁' c₂ c₂' : Cfg (Fin 2) (Fin 6)} + (h : c₁' [target_tm]⊢⁺ c₂') (heq₁ : c₁ = c₁') (heq₂ : c₂' = c₂) : + c₁ [target_tm]⊢⁺ c₂ := by + rw [heq₁, ← heq₂]; exact h + +abbrev w10 : zF := [1, 0] +abbrev w110 : zF := [1, 1, 0] + +def section_side : List Nat → Bool → zB + | [], _ => default + | a :: xs, true => (w10 ^ a) +> section_side xs false + | a :: xs, false => (w110 ^ a) +> section_side xs true + +def section_481 (xs : List Nat) : Cfg (Fin 2) (Fin 6) := + (section_side xs true) {{B}}> default + +def S (l r : zB) (a b c d : Nat) : Cfg (Fin 2) (Fin 6) := + ((([1, 0] : zF) ^ a) +> l) <{{B}} + (([1] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ b) +> ((([1, 0] : zF) ^ c) +> (([0] : zF) + +> ((([1, 0, 0] : zF) ^ d) +> r))))) + +def P (a : Nat) : Prop := + ∀ l : zB, (((([1, 0] : zF) ^ a) +> l) {{B}}> default) [target_tm]⊢* + (l <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) ^ a) +> default))) + +def PP (a : Nat) : Prop := + ∀ l : zB, (((([1, 0] : zF) ^ a) +> l) {{B}}> default) [target_tm]⊢* + (l <{{E}} (([0, 1, 1] : zF) +> ((([0, 1, 0] : zF) ^ a) +> default))) + +def rootW (r : zB) (a : Nat) (w : zF) (c d : Nat) : Cfg (Fin 2) (Fin 6) := + default <{{A}} ((([1, 0] : zF) ^ (1 + a)) +> (w +> ((([1, 0] : zF) ^ c) +> (([1, 0, 1] : zF) + +> ((([0, 1, 0] : zF) ^ d) +> r))))) + +def crossW (l r : zB) (a : Nat) (w : zF) (c d : Nat) : Cfg (Fin 2) (Fin 6) := + ((([1, 0] : zF) ^ a) +> l) <{{B}} (([1, 0, 1] : zF) +> (w +> ((([1, 0] : zF) ^ c) + +> (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ d) +> r))))) + +def crossZ (l r : zB) (a b c e : Nat) : Cfg (Fin 2) (Fin 6) := + ((([1, 0] : zF) ^ a) +> l) <{{B}} (([1, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ b) + +> ((([1, 0] : zF) ^ c) +> (([0] : zF) +> ((([1, 0] : zF) ^ e) +> r))))) + +def rootZ (r : zB) (a b c e : Nat) : Cfg (Fin 2) (Fin 6) := + default <{{A}} ((([1, 0] : zF) ^ (1 + a)) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ b) +> ((([1, 0] : zF) + ^ c) +> (([0] : zF) +> ((([1, 0] : zF) ^ e) +> r))))) + +def crossV (l r : zB) (a b c e : Nat) : Cfg (Fin 2) (Fin 6) := + ((([1, 0] : zF) ^ a) +> l) <{{B}} (([1, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ b) + +> ((([1, 0] : zF) ^ c) +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ e) + +> r))))) + +def rootV (r : zB) (a b c e : Nat) : Cfg (Fin 2) (Fin 6) := + default <{{A}} ((([1, 0] : zF) ^ (1 + a)) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ b) +> ((([1, 0] : zF) + ^ c) +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ e) +> r))))) + +def seed (a b c d : Nat) : Cfg (Fin 2) (Fin 6) := + default <{{A}} ((([1, 0] : zF) ^ (2 + a)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (1 + b)) + +> ((([1, 0] : zF) ^ (c * 2)) +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ d) +> default))))) + +def final_scan (t m : Nat) : Cfg (Fin 2) (Fin 6) := + ((([1, 0] : zF) ^ t) +> default) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) ^ m) +> default)) + +def scan_root (a d : Nat) : Cfg (Fin 2) (Fin 6) := + default <{{A}} (([1] : zF) +> ((([0, 1] : zF) ^ a) +> ((([0, 1, 0] : zF) ^ d) +> default))) + +def rootT (a b c d : Nat) : Cfg (Fin 2) (Fin 6) := + default <{{A}} ((([1, 0] : zF) ^ (1 + a)) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + b)) + +> ((([1, 0] : zF) ^ c) +> (([1, 0, 1] : zF) +> ((([0, 0, 1] : zF) ^ d) +> default))))) + +def scan_left (r : zB) (a d : Nat) : Cfg (Fin 2) (Fin 6) := + default <{{A}} (([1] : zF) +> ((([0, 1] : zF) ^ a) +> ((([0, 1, 0] : zF) ^ d) +> r))) + +def scanW (l r : zB) (w : zF) (c d : Nat) : Cfg (Fin 2) (Fin 6) := + l <{{C}} (([0, 1, 0, 1, 0, 0, 1] : zF) +> (w +> ((([1, 0] : zF) ^ c) +> (([1, 0, 1] : zF) + +> ((([0, 1, 0] : zF) ^ d) +> r))))) + +macro "norm_cfg" : tactic => + `(tactic| ( + try dsimp only [Sim.toCfg, + S, rootW, crossW, crossZ, rootZ, crossV, rootV, seed, final_scan, scan_root, + rootT, scan_left, scanW, section_481, section_side, w10, w110] + try simp only + [Nat.add_assoc, Nat.add_zero, Nat.zero_add, Nat.add_mul, Nat.mul_add, Nat.one_mul, + Nat.mul_one, + list_pow_zero, list_pow_succ, + pow_add_1, pow_add_2, pow_add_3, pow_add_4, pow_add_5, + pow_add_right_2, pow_add_right_3, pow_add_right_4, pow_add_right_5, + pow_double3, + List.nil_append, List.cons_append, List.append_assoc, + listblank_append_nil, listblank_append_cons, listblank_append_right_assoc, + shift2, shift3, shift6, + shift2_0, shift3_0_1, shift3_0_01, shift6_0_1, shift6_0_01, + pow_merge, ListBlank.cons_zero_default] + try ac_rfl)) + + +theorem edge1 (l : zB) (r : zB) (b : Nat) (c : Nat) : + (((([1, 0] : zF) +> l) <{{B}} (([1] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0] : zF) +> r)))))) + [target_tm]⊢* ((l <{{C}} (([0, 1, 0, 1] : zF) +> ((([0, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> r)))))) := by + refine step_bridge (simSteps_star_ex 7 ⟨B, .left, [1, 0], [1]⟩ ⟨A, .right, [0, 1], + [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0] : zF) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1] : zF) +> l) (([0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0] : zF) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> l)) + (([0, 0, 1, 0] : zF) +> r)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> l)) r) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> l)) + (([1, 0, 1, 0, 1] : zF) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> l) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> r))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .left, [1], [1, 0, 1, 0]⟩ ⟨C, .left, [], + [0, 1, 0, 1, 0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> r)))) (by norm_cfg) (by norm_cfg) + +theorem edge2 (l : zB) (r : zB) (b : Nat) (c : Nat) : + (((([1, 0, 1, 0] : zF) +> l) <{{B}} (([1] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0] : zF) +> r)))))) + [target_tm]⊢* ((l <{{B}} (([1, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> r)))))) := by + refine step_bridge (simSteps_star_ex 7 ⟨B, .left, [1, 0, 1, 0], [1]⟩ ⟨A, .right, [0, 1, 1, 0], + [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0] : zF) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0] : zF) +> l) (([0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0] : zF) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l)) + (([0, 0, 1, 0, 0] : zF) +> r)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l))) r) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l)) + (([1, 0, 1, 0, 1, 0] : zF) +> r)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 4 ⟨A, .left, [1, 1, 0], [1, 0, 1, 0, 1, 0]⟩ ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l) ((([1, 0] : zF) ^ (c)) + +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> l) (([0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> r))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], [0, 1, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> r)))) (by norm_cfg) (by norm_cfg) + +theorem Inc1 (l : zB) (r : zB) (a : Nat) (b : Nat) (c : Nat) (d : Nat) : + (S (l) (r) (2+a) (b) (c) (2+d)) [target_tm]⊢* (S (l) (r) (a) (1+b) (2+c) (d)) := by + refine step_bridge (simSteps_star_ex 7 ⟨B, .left, [1, 0, 1, 0], [1]⟩ ⟨A, .right, [0, 1, 1, 0], + [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) + ^ (c)) +> (([0, 1, 0, 0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) (([0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (a)) +> l))) (([0, 0, 1, 0, 0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) + ^ (d)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0, 0, 1, 0, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)))) + ((([1, 0, 0] : zF) ^ (d)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (a)) +> l))) (([1, 0, 1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) + ^ (d)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 4 ⟨A, .left, [1, 1, 0], [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨E, .left, + [0], [0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) + ^ (a)) +> l)) ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0, 0] : zF) ^ (d)) +> r))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], [0, 1, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0, 0] : zF) + ^ (d)) +> r)))))) (by norm_cfg) (by norm_cfg) + +theorem pass_011 (l : zB) (r : zB) (n : Nat) : + ((((([1, 1, 0] : zF) ^ (n)) +> l) <{{C}} (([0, 1] : zF) +> r))) + [target_tm]⊢* ((l <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (n)) +> r)))) := by + exact step_end (sr_5 (n) l r) (by norm_cfg) (by norm_cfg) + +theorem P3 : + P 3 := by + intro l + exact step_end (simSteps_star_ex 77 ⟨B, .right, [1, 0, 1, 0, 1, 0], [0, 0, 0, 0, 0, 0]⟩ ⟨C, .left, + [], [0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0]⟩ rfl l default) (by norm_cfg) (by norm_cfg) + +theorem close (l : zB) (a : Nat) (b : Nat) : + ((((([1, 1, 0, 1, 1, 0] : zF) ^ (a)) +> (([1] : zF) +> l)) <{{C}} (([0, 1] : zF) + +> ((([0, 1, 0] : zF) ^ (b)) +> default)))) [target_tm]⊢* ((l <{{E}} (([0, 1, 1] : zF) + +> ((([0, 1, 0] : zF) ^ (a*2+b)) +> default)))) := by + refine step_bridge (sr_6 (a) (([1] : zF) +> l) ((([0, 1, 0] : zF) ^ (b)) +> default)) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 3 ⟨C, .left, [1], [0, 1]⟩ ⟨E, .left, [], + [0, 1, 1]⟩ rfl l ((([0, 1, 0, 0, 1, 0] : zF) ^ (a)) +> ((([0, 1, 0] : zF) ^ (b)) +> default))) + (by norm_cfg) (by norm_cfg) + +theorem close_odd (l : zB) (a : Nat) (b : Nat) : + (((([1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (a)) +> l)) <{{C}} (([0, 1] : zF) + +> ((([0, 1, 0] : zF) ^ (b)) +> default)))) [target_tm]⊢* ((l <{{C}} (([0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ (a*2+b)) +> default)))) := by + refine step_bridge (simSteps_star_ex 4 ⟨C, .left, [1, 1, 0], [0, 1]⟩ ⟨A, .left, [0], + [1, 0, 1, 1]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (a)) +> l) ((([0, 1, 0] : zF) ^ (b)) + +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_7 (a) (([0] : zF) +> l) ((([0, 1, 0] : zF) ^ (b)) +> default)) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 13 ⟨A, .left, [0], [1, 0, 1, 1]⟩ ⟨C, .left, [], + [0, 1, 0, 1, 0]⟩ rfl l ((([0, 1, 0, 0, 1, 0] : zF) ^ (a)) +> ((([0, 1, 0] : zF) ^ (b)) + +> default))) (by norm_cfg) (by norm_cfg) + +theorem root_end0 (a : Nat) (b : Nat) (c : Nat) : + (rootW default (a) (([1, 0, 1, 0, 0, 1] : zF) ^ (1+b)) (c) (0)) [target_tm]⊢* (((([1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> default)))))) + {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1, 1, 0, 1] : zF) + +> ((([0, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([0, 1] : zF) ^ (c)) +> default))))) + (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0, 0, 1, 1, 0, 1] : zF) + +> ((([0, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([0, 1] : zF) ^ (c)) +> default)))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0, 0, 1, 1, 0, 1]⟩ ⟨B, + .right, [1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [1]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([0, 1] : zF) ^ (c)) +> default))) (by norm_cfg) + ?_ + refine step_bridge (sr_8 (b) (([1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([1] : zF) +> default)) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 2 ⟨B, .right, [1], [1, 0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))))) default) + (by norm_cfg) (by norm_cfg) + +theorem root_end1 (a : Nat) (b : Nat) (c : Nat) : + (rootW default (a) (([1, 0, 1, 0, 0, 1] : zF) ^ (1+b)) (c) (1)) + [target_tm]⊢* (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (a)) +> default)))))) {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> default)))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> default))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 6 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (a)) +> default)) (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) ((([1, 0] : zF) ^ (c)) + +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([0] : zF) + +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1, 0, 1], [0]⟩ ⟨B, .right, [1, 0, 1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))))) default) + (by norm_cfg) (by norm_cfg) + +theorem crossZ_step (l : zB) (r : zB) (a : Nat) (b : Nat) (c : Nat) (e : Nat) : + (crossZ (l) (r) (4+a) (b) (3+c) (2+e)) [target_tm]⊢* (crossZ (l) (r) (a) (2+b) (3+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0], + [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (a)) +> l)) (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l))) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([0, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))))) ((([1, 0] : zF) ^ (e)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))) ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 3 ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) + ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) (([1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 13 ⟨B, .right, [1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)))) ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) + ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) + (([1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 32 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1, 0, 1, 0, 1, 0]⟩ ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 1, 0, 1, 1, 0] : + zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) + +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) (by norm_cfg) + +theorem rootZ_step (r : zB) (a : Nat) (b : Nat) (c : Nat) (e : Nat) : + (rootZ (r) (a) (b) (3+c) (2+e)) [target_tm]⊢* (rootZ (r) (4+a) (b) (3+c) (e)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1], [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default))) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([0, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) ((([1, 0] : zF) + ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨A, .left, [1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 3 ⟨A, .right, [0, 1], [0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1], [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) + ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 13 ⟨B, .right, [1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) (by norm_cfg) + +theorem crossV_step (l : zB) (r : zB) (a : Nat) (b : Nat) (c : Nat) (e : Nat) : + (crossV (l) (r) (4+a) (b) (3+c) (1+e)) [target_tm]⊢* (crossV (l) (r) (a) (2+b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0], + [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (a)) +> l)) (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l))) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], + [0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))))) + ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))) ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) + ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) + (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) + (([1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)))) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) + (([1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 32 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl + ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) ((([1, 0] : zF) + ^ (c)) +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) + +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) + (by norm_cfg) (by norm_cfg) + +theorem rootV_step (r : zB) (a : Nat) (b : Nat) (c : Nat) (e : Nat) : + (rootV (r) (a) (b) (3+c) (1+e)) [target_tm]⊢* (rootV (r) (4+a) (b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1], [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default))) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], + [0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (a)) +> default)))) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨A, .left, [1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) + (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1], [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 0, 1], [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) + ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (a)) +> default)))) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) (by norm_cfg) + ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) + (by norm_cfg) (by norm_cfg) + +theorem even_root (a : Nat) (d : Nat) : + (S default default (1) (1+a) (a*2) (1+d)) [target_tm]⊢* (rootW default (0) + (([1, 0, 1, 0, 0, 1] : zF) ^ (1+a)) (1+a*2) (d)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (a)) + +> ((([1, 0] : zF) ^ (a*2)) +> (([0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) + +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (a) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([1, 0] : zF) ^ (a*2)) +> (([0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) + +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a*2) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (a)) +> default)) (([0, 0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> default))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a*2)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (a)) +> default))) ((([1, 0, 0] : zF) ^ (d)) +> default)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (a*2) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (a)) + +> default)) (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> default))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], [1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (a)) + +> default) ((([1, 0] : zF) ^ (a*2)) +> ((([1, 0, 0] : zF) ^ (d)) +> default))) + (by norm_cfg) ?_ + refine step_bridge (sr_3 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a*2)) +> ((([1, 0, 0] : zF) ^ (d)) +> default)))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, + [], [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (a)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (a*2)) +> ((([1, 0, 0] : zF) ^ (d)) +> default))))) + (by norm_cfg) (by norm_cfg) + +theorem even_end (a : Nat) : + (S default default (1) (1+a) (a*2) (0)) [target_tm]⊢* (((([1, 0] : zF) +> ((([1, 0] : zF) + ^ (a*2)) +> (([1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (a)) + +> (([1, 0] : zF) +> default))))) {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (a)) + +> ((([1, 0] : zF) ^ (a*2)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (a) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([1, 0] : zF) ^ (a*2)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a*2) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (a)) +> default)) (([0] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1], [0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (a*2)) +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (a)) +> default))) default) (by norm_cfg) (by norm_cfg) + +theorem odd_seed (a : Nat) (b : Nat) (c : Nat) (d : Nat) : + (((([1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) + +> default))) <{{B}} (([1, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (a)) + +> ((([1, 0] : zF) ^ (a*2)) +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) + +> default))))))) [target_tm]⊢* (seed (c) (b+a) (a) (d)) := by + refine step_bridge (simSteps_star_ex 6 ⟨B, .left, [1, 1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨C, .left, + [0], [0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) + ^ (c)) +> default)) ((([0, 1, 1, 0, 1, 0] : zF) ^ (a)) +> ((([1, 0] : zF) ^ (a*2)) + +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_11 (b) (([0] : zF) +> ((([1, 0] : zF) ^ (c)) +> default)) + (([1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (a)) +> ((([1, 0] : zF) + ^ (a*2)) +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> default)))))) (by norm_cfg) ?_ + refine step_bridge (sr_12 (c) (([0] : zF) +> default) (([1, 0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (a)) +> ((([1, 0] : zF) + ^ (a*2)) +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> default))))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 3 ⟨C, .left, [0], [0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (c)) +> (([0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (a)) + +> ((([1, 0] : zF) ^ (a*2)) +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) + +> default)))))))) (by norm_cfg) (by norm_cfg) + +theorem seed_root (a : Nat) (b : Nat) (c : Nat) (d : Nat) : + (seed (a) (b) (c) (1+d)) [target_tm]⊢* (rootW default (1+a) (([1, 0, 1, 0, 0, 1] : zF) ^ (1+b)) + (1+c*2) (d)) := by + refine step_bridge (simSteps_star_ex 4 ⟨A, .left, [0], [1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1], + [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c*2)) +> (([0, 1, 0, 0] : zF) + +> ((([1, 0, 0] : zF) ^ (d)) +> default))))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1] : zF) +> default) (([0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c*2)) +> (([0, 1, 0, 0] : zF) + +> ((([1, 0, 0] : zF) ^ (d)) +> default)))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 6 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1], [0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c*2)) +> (([0, 1, 0, 0] : zF) + +> ((([1, 0, 0] : zF) ^ (d)) +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([0] : zF) +> ((([1, 0] : zF) ^ (c*2)) +> (([0, 1, 0, 0] : zF) + +> ((([1, 0, 0] : zF) ^ (d)) +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c*2) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([0, 0, 1, 0, 0] : zF) + +> ((([1, 0, 0] : zF) ^ (d)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c*2)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default))))) ((([1, 0, 0] : zF) ^ (d)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c*2) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0, 0] : zF) ^ (d)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], [1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) ((([1, 0] : zF) ^ (c*2)) + +> ((([1, 0, 0] : zF) ^ (d)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c*2)) +> ((([1, 0, 0] : zF) + ^ (d)) +> default)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 4 ⟨A, .left, [1, 0, 1], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c*2)) + +> ((([1, 0, 0] : zF) ^ (d)) +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c*2)) + +> ((([1, 0, 0] : zF) ^ (d)) +> default)))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c*2)) + +> ((([1, 0, 0] : zF) ^ (d)) +> default))))))) (by norm_cfg) (by norm_cfg) + +theorem seed_zero (a : Nat) (b : Nat) (c : Nat) : + (seed (a) (b) (c) (0)) [target_tm]⊢* (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (c*2)) + +> (([1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> default)))))) {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 4 ⟨A, .left, [0], [1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1], + [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c*2)) +> default))))) + (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1] : zF) +> default) (([0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c*2)) +> default)))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 6 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1], [0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c*2)) +> default))) (by norm_cfg) + ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([0] : zF) +> ((([1, 0] : zF) ^ (c*2)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c*2) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([0] : zF) +> default)) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1], [0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c*2)) +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))))) default) (by norm_cfg) + (by norm_cfg) + +theorem even_exit (l : zB) (a : Nat) : + (S (l) default (1) (1+a) (a*2) (0)) [target_tm]⊢* (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (a*2)) + +> (([1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (a)) +> (([1] : zF) +> l))))) + {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (a)) +> ((([1, 0] : zF) + ^ (a*2)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (a) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> l) (([0] : zF) +> ((([1, 0] : zF) + ^ (a*2)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a*2) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (a)) +> l)) (([0] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1], [0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (a*2)) +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (a)) +> l))) default) (by norm_cfg) (by norm_cfg) + +theorem lone_one (b : Nat) (l : zB) (r : zB) : + (((([1] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> l))) + <{{C}} (([0, 1] : zF) +> r))) [target_tm]⊢* ((l <{{C}} (([0] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> r))))) := by + refine step_bridge (simSteps_star_ex 4 ⟨C, .left, [1, 1], [0, 1]⟩ ⟨A, .left, [], + [1, 0, 1, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0] : zF) +> l)) r) (by norm_cfg) ?_ + refine step_bridge (sr_13 (b) (([0] : zF) +> l) (([1, 0, 1, 1] : zF) +> r)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .left, [0], [1, 0]⟩ ⟨A, .right, [0, 1], + [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 1] : zF) +> r))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1] : zF) +> l) (([0, 1, 1] : zF) +> r)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 1, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> l) r) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> l) (([1, 0, 1, 0] : zF) +> r)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .left, [1], [1, 0, 1, 0]⟩ ⟨C, .left, [], + [0, 1, 0, 1, 0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> r)) (by norm_cfg) (by norm_cfg) + +theorem cross_to_Z (l : zB) (r : zB) (a : Nat) (b : Nat) (c : Nat) : + (crossW (l) (([0, 1, 1, 0, 1, 0, 1, 0] : zF) +> r) (2+a) (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) (3+c) + (0)) [target_tm]⊢* (crossZ (l) (r) (a) (1+b) (5+c) (2)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> (([1, 0, 1, 0, 1, 0] : zF) +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l)) (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> r)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 7 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) + ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 1, 0] : zF) +> r))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) + (([1, 1, 0, 1, 0, 1, 0] : zF) +> r)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 21 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (a)) +> l)))) r) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0] : zF) + +> r)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 18 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 1, 0] : zF) +> r))) (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 1, 0] : zF) +> r)))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, + .left, [], [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 1, 0] : zF) +> r))))) (by norm_cfg) (by norm_cfg) + +theorem odd_block (l : zB) (r : zB) (b : Nat) : + (((([1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l)) <{{B}} (([1] : zF) +> r))) + [target_tm]⊢* ((l <{{A}} (([1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> r)))) := by + refine step_bridge (simSteps_star_ex 6 ⟨B, .left, [1, 1, 0], [1]⟩ ⟨C, .left, [0], + [0, 1, 0]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l) r) (by norm_cfg) ?_ + refine step_bridge (sr_11 (b) (([0] : zF) +> l) (([1, 0] : zF) +> r)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 3 ⟨C, .left, [0], [0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> r)) (by norm_cfg) (by norm_cfg) + +theorem even_block (l : zB) (r : zB) (b : Nat) : + ((((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l) <{{B}} (([1] : zF) +> r))) + [target_tm]⊢* ((l <{{B}} (([1] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> r)))) := by + exact step_end (sr_10 (b) l r) (by norm_cfg) (by norm_cfg) + +theorem S_exit0 (l : zB) (a : Nat) (b : Nat) (c : Nat) : + (S (l) default (2+a) (1+b) (c) (0)) [target_tm]⊢* (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (a)) +> l))))) {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) +> default))) (by norm_cfg) + ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l)) (([0] : zF) +> ((([1, 0] : zF) ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) (([0] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1], [0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)))) default) + (by norm_cfg) (by norm_cfg) + +theorem S_exit1 (l : zB) (a : Nat) (b : Nat) (c : Nat) : + (S (l) default (4+a) (1+b) (c) (1)) [target_tm]⊢* (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))))) + {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0], + [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (a)) +> l)) (([0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1] : zF) +> default)))) + (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([0, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l))))) default) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) (([1, 0, 1, 0, 1] : zF) + +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))) ((([0, 1] : zF) ^ (c)) + +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 1 ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1]⟩ ⟨B, .right, + [1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [1]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) ((([0, 1] : zF) ^ (c)) +> default)) + (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) (([1] : zF) + +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 2 ⟨B, .right, [1, 0, 1], [1, 0]⟩ ⟨B, .right, [1, 0, 1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)))) default) + (by norm_cfg) (by norm_cfg) + +theorem S_root1 (b : Nat) (c : Nat) (d : Nat) : + (S default default (1) (1+b) (c) (1+d)) [target_tm]⊢* (rootW default (0) + (([1, 0, 1, 0, 0, 1] : zF) ^ (1+b)) (1+c) (d)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) + +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> default))))) + (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default)) (([0, 0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> default))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default))) ((([1, 0, 0] : zF) ^ (d)) +> default)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default)) (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> default))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], [1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (c)) +> ((([1, 0, 0] : zF) ^ (d)) +> default))) + (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> ((([1, 0, 0] : zF) ^ (d)) +> default)))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, + [], [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> ((([1, 0, 0] : zF) ^ (d)) +> default))))) + (by norm_cfg) (by norm_cfg) + +theorem into_S (l : zB) (r : zB) (a : Nat) (d : Nat) : + (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) <{{C}} (([0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ (d)) +> (([0, 1] : zF) +> r))))) [target_tm]⊢* (S (l) (([1] : zF) + +> r) (a) (1) (0) (d)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0], [0, 1, 0, 1, 0, 0, 1]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([0, 0, 1] : zF) ^ (d)) +> r)) + (by norm_cfg) (by norm_cfg) + +theorem crossV_end (l : zB) (r : zB) (a : Nat) (b : Nat) (c : Nat) (e : Nat) : + (crossV (l) (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)) (4+a) (b) (3+c) (0)) + [target_tm]⊢* (crossZ (l) (r) (a) (2+b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0], + [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (a)) +> l)) (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l))) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([0, 0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 0, 1, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))))) ((([1, 0] : zF) ^ (e)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))) ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) + ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) + (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) (([1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)))) ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) + ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) + (([1, 0, 1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 32 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl + ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) ((([1, 0] : zF) + ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) + +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) + (by norm_cfg) + +theorem cross_to_V (l : zB) (r : zB) (a : Nat) (b : Nat) (c : Nat) (n : Nat) : + (crossW (l) (([0, 1, 1, 0, 1, 0, 0, 1, 1] : zF) +> ((([0, 1, 0, 0, 1, 1] : zF) ^ (n)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (n*2)) +> (([0] : zF) +> r))))) + (2+a) (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) (3+c) (0)) [target_tm]⊢* (crossV (l) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r)) (a) (1+b) + (5+c) (n)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r)))))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l)) (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 7 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) + ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) +> (([1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (n*2)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) + (([1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 21 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (a)) +> l)))) ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (n*2)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 18 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r)))))) + (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r))))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, + .left, [], [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r)))))))) + (by norm_cfg) (by norm_cfg) + +theorem S_short1 (l : zB) (b : Nat) (c : Nat) : + (S (l) default (3) (1+b) (c) (1)) [target_tm]⊢* (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) + +> (([1] : zF) +> l))))) {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0], [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0] : zF) +> l) (([0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0] : zF) +> l))) (([0, 0, 1] : zF) +> default)) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0] : zF) +> l)))) default) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0] : zF) +> l))) (([1, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0] : zF) +> l)) ((([0, 1] : zF) ^ (c)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1, 0] : zF) +> l) (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> l) + (([0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 1 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1]⟩ ⟨B, .right, [1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> l) ((([0, 1] : zF) ^ (c)) +> default)) + (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> l)) (([1] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 2 ⟨B, .right, [1, 0, 1], [1, 0]⟩ ⟨B, .right, [1, 0, 1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> l))) default) (by norm_cfg) (by norm_cfg) + +theorem lone_S (l : zB) (r : zB) (a : Nat) (b : Nat) (m : Nat) : + (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) <{{C}} (([0] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (m)) + +> (([0, 1] : zF) +> r))))))) [target_tm]⊢* (S (l) (([1] : zF) +> r) (a) (1+b) (0) + (m)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0], [0, 1, 0, 1, 0, 0, 1]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([1, 0, 1, 0, 0, 1] : zF) + ^ (b)) +> ((([0, 0, 1] : zF) ^ (m)) +> r))) (by norm_cfg) (by norm_cfg) + +theorem crossW_one (r : zB) (b : Nat) (c : Nat) (d : Nat) : + (crossW default (r) (1) (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) (c) (2+d)) [target_tm]⊢* (rootW (r) + (0) (([1, 0, 1, 0, 0, 1] : zF) ^ (1+b)) (2+c) (d)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0] : zF) +> ((([0, 1, 0] : zF) + ^ (d)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) (([0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default)) (([0, 0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default))) ((([0, 1, 0] : zF) ^ (d)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default)) (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([0, 1] : zF) ^ (c)) +> ((([0, 1, 0] : zF) ^ (d)) +> r))) (by norm_cfg) + ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> ((([0, 1, 0] : zF) ^ (d)) +> r)))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, + [], [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> ((([0, 1, 0] : zF) ^ (d)) +> r))))) + (by norm_cfg) (by norm_cfg) + +theorem root_to_Z (r : zB) (a : Nat) (b : Nat) (c : Nat) : + (rootW (([0, 1, 1, 0, 1, 0, 1, 0] : zF) +> r) (a) (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) (3+c) (0)) + [target_tm]⊢* (rootZ (r) (2+a) (b) (5+c) (2)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> (([1, 0, 1, 0, 1, 0] : zF) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 1, 0] : zF) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 7 ⟨A, .right, [0, 1], [0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 0, 1, 0, 1], [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> r))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 1, 0, 1, 0, 1, 0] : zF) +> r)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 21 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (a)) +> default)))) r) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0] : zF) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨A, .left, [1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 1, 0] : zF) +> r)))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> r)))))) (by norm_cfg) (by norm_cfg) + +theorem cross_to_Z_one (r : zB) (b : Nat) (c : Nat) : + (crossW default (([0, 1, 1, 0, 1, 0, 1, 0] : zF) +> r) (1) (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) + (3+c) (0)) [target_tm]⊢* (rootZ (r) (0) (1+b) (5+c) (2)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 1, 0] : zF) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 1, 0] : zF) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 7 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> r))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([1, 1, 0, 1, 0, 1, 0] : zF) +> r)) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 21 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default))) r) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0] : zF) +> r)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> r))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 1, 0] : zF) +> r)))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, + [], [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) + +> r))))) (by norm_cfg) (by norm_cfg) + +theorem root_to_V (r : zB) (a : Nat) (b : Nat) (c : Nat) (n : Nat) : + (rootW (([0, 1, 1, 0, 1, 0, 0, 1, 1] : zF) +> ((([0, 1, 0, 0, 1, 1] : zF) ^ (n)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (n*2)) +> (([0] : zF) +> r))))) (a) + (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) (3+c) (0)) + [target_tm]⊢* (rootV (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (n*2)) +> r)) (2+a) (b) (5+c) (n)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r))))))))) + (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r))))))))) (by norm_cfg) + ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 7 ⟨A, .right, [0, 1], [0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 0, 1, 0, 1], [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r)))))) (by norm_cfg) + ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 21 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (a)) +> default)))) ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (n*2)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨A, .left, [1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r)))))))) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r))))))))) (by norm_cfg) + ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r))))))))) + (by norm_cfg) (by norm_cfg) + +theorem cross_to_V_one (r : zB) (b : Nat) (c : Nat) (n : Nat) : + (crossW default (([0, 1, 1, 0, 1, 0, 0, 1, 1] : zF) +> ((([0, 1, 0, 0, 1, 1] : zF) ^ (n)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (n*2)) +> (([0] : zF) +> r))))) (1) + (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) (3+c) (0)) + [target_tm]⊢* (rootV (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (n*2)) +> r)) (0) (1+b) (5+c) (n)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r)))))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 7 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r)))))) (by norm_cfg) + ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (n*2)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 21 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default))) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) +> (([1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (n*2)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (n*2)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) +> (([1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (n*2)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r))))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, + [], [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (n)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> r)))))))) + (by norm_cfg) (by norm_cfg) + +theorem rootV_end (r : zB) (a : Nat) (b : Nat) (c : Nat) (e : Nat) : + (rootV (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)) (a) (b) (3+c) (0)) + [target_tm]⊢* (rootZ (r) (4+a) (b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1], [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default))) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([0, 0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 0, 1, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)))) ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) + ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨A, .left, [1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1], [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 0, 1], [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) + ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 0, 1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) (by norm_cfg) + +theorem crossV_one (r : zB) (b : Nat) (c : Nat) (e : Nat) : + (crossV default (r) (1) (b) (3+c) (1+e)) [target_tm]⊢* (rootV (r) (2) (1+b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) (([0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default)) (([0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], + [0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default))) + ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> default)) + ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> default))) + (([1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> default)))) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> default))) (([1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> default)) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) + ?_ + exact step_end (simSteps_star_ex 12 ⟨A, .left, [1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) (by norm_cfg) (by norm_cfg) + +theorem crossV_three (r : zB) (b : Nat) (c : Nat) (e : Nat) : + (crossV default (r) (3) (b) (3+c) (1+e)) [target_tm]⊢* (rootV (r) (0) (2+b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) + (([0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], + [0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default))) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default) ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> default) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default))) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) + (([1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 28 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : + zF) ^ (b)) +> default) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) + ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) + (by norm_cfg) (by norm_cfg) + +theorem crossVend_one (r : zB) (b : Nat) (c : Nat) (e : Nat) : + (crossV default (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)) (1) (b) (3+c) (0)) + [target_tm]⊢* (rootZ (r) (2) (1+b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) (([0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default)) (([0, 0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 0, 1, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> default)) + ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> default))) (([1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> default)))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> default))) (([1, 0, 1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> default)) ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 12 ⟨A, .left, [1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) (by norm_cfg) + +theorem crossVend_three (r : zB) (b : Nat) (c : Nat) (e : Nat) : + (crossV default (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)) (3) (b) (3+c) (0)) + [target_tm]⊢* (rootZ (r) (0) (2+b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([0, 0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 0, 1, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> default) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default))) ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 28 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : + zF) ^ (b)) +> default) ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) (by norm_cfg) + +theorem crossZ_one' (r : zB) (b : Nat) (c : Nat) (e : Nat) : + (crossZ default (r) (1) (b) (3+c) (2+e)) [target_tm]⊢* (rootZ (r) (2) (1+b) (3+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) (([0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default)) (([0, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default))) ((([1, 0] : zF) ^ (e)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default)) (([1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 3 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1, 0, 1]⟩ ⟨B, + .right, [1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1], [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> default)) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> default))) (([1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 13 ⟨B, .right, [1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> default)))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> default))) (([1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], [1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> default)) ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 12 ⟨A, .left, [1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))))) (by norm_cfg) (by norm_cfg) + +theorem crossZ_three' (r : zB) (b : Nat) (c : Nat) (e : Nat) : + (crossZ default (r) (3) (b) (3+c) (2+e)) [target_tm]⊢* (rootZ (r) (0) (2+b) (3+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([0, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default)) (([1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> default) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 3 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 13 ⟨B, .right, [1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default))) ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([1, 0, 1, 0, 1, 0, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 28 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default) ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) (by norm_cfg) + +theorem S_root1' (r : zB) (b : Nat) (c : Nat) (d : Nat) : + (S default (r) (1) (1+b) (c) (1+d)) [target_tm]⊢* (rootW (([0] : zF) +> r) (0) + (([1, 0, 1, 0, 0, 1] : zF) ^ (1+b)) (1+c) (d)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default)) (([0, 0, 1, 0, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> r))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default))) ((([1, 0, 0] : zF) ^ (d)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default)) (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0, 0] : zF) ^ (d)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], [1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (c)) +> ((([1, 0, 0] : zF) ^ (d)) +> r))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> ((([1, 0, 0] : zF) ^ (d)) +> r)))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, + [], [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> ((([1, 0, 0] : zF) ^ (d)) +> r))))) + (by norm_cfg) (by norm_cfg) + +theorem S_short0 (l : zB) (b : Nat) (c : Nat) : + (S (l) default (1) (1+b) (c) (0)) [target_tm]⊢* (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> l))))) + {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) + ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> l) (([0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> l)) (([0] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1], [0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> l))) default) (by norm_cfg) (by norm_cfg) + +theorem crossV_step_block (l : zB) (r : zB) (a : Nat) (vB : Nat) (b : Nat) (c : Nat) (e : Nat) : + (crossV ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l))) (r) (2) (b) (3+c) (1+e)) [target_tm]⊢* (crossV (l) (r) (a) (2+vB+b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))))) + (([0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], + [0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (a)) +> l)))))) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l))))) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (a)) +> l)))) ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (sr_10 (vB) (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (vB)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (vB) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> ((([1, 0] : zF) ^ (a)) +> l))) + (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) + +> ((([1, 0] : zF) ^ (a)) +> l))) ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) + (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) + +> ((([1, 0] : zF) ^ (a)) +> l)))) (([1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> ((([1, 0] : zF) ^ (a)) +> l))))) + ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) + +> ((([1, 0] : zF) ^ (a)) +> l)))) (([1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 32 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl + ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) + +> ((([1, 0] : zF) ^ (a)) +> l))) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> ((([1, 0] : zF) + ^ (a)) +> l))) (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_4 (vB) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) + +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (vB)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) (by norm_cfg) (by norm_cfg) + +theorem crossZ_step_block (l : zB) (r : zB) (a : Nat) (vB : Nat) (b : Nat) (c : Nat) (e : Nat) : + (crossZ ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l))) (r) (2) (b) (3+c) (2+e)) [target_tm]⊢* (crossZ (l) (r) (a) (2+vB+b) (3+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))))) (([0, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l)))))) ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l))))) (([1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l)))) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (vB) (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (vB)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (vB) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> ((([1, 0] : zF) ^ (a)) +> l))) (([0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 3 ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) + +> ((([1, 0] : zF) ^ (a)) +> l))) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) + +> ((([1, 0] : zF) ^ (a)) +> l)))) (([1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 13 ⟨B, .right, [1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> ((([1, 0] : zF) ^ (a)) +> l))))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) + +> ((([1, 0] : zF) ^ (a)) +> l)))) (([1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 32 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1, 0, 1, 0, 1, 0]⟩ ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 1, 0, 1, 1, 0] : + zF) ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> ((([1, 0] : zF) ^ (a)) +> l))) + ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> ((([1, 0] : zF) + ^ (a)) +> l))) (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) + ?_ + refine step_bridge (sr_4 (vB) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) + +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (vB)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))))) (by norm_cfg) (by norm_cfg) + +theorem crossVend_block (l : zB) (r : zB) (a : Nat) (vB : Nat) (b : Nat) (c : Nat) (e : Nat) : + (crossV ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l))) (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)) (2) (b) (3+c) (0)) + [target_tm]⊢* (crossZ (l) (r) (a) (2+vB+b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) + ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))))) (([0, 0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 0, 1, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l)))))) ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l))))) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (a)) +> l)))) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (vB) (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (vB)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (vB) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> ((([1, 0] : zF) ^ (a)) +> l))) + (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) + +> ((([1, 0] : zF) ^ (a)) +> l))) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) + (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) + +> ((([1, 0] : zF) ^ (a)) +> l)))) (([1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> ((([1, 0] : zF) ^ (a)) +> l))))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) + +> ((([1, 0] : zF) ^ (a)) +> l)))) (([1, 0, 1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 32 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl + ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) + +> ((([1, 0] : zF) ^ (a)) +> l))) ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> ((([1, 0] : zF) + ^ (a)) +> l))) (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) + ?_ + refine step_bridge (sr_4 (vB) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) + +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (vB)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) (by norm_cfg) + +theorem crossV_step_block_root (r : zB) (vB : Nat) (b : Nat) (c : Nat) (e : Nat) : + (crossV ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> (([1, 0] : zF) +> default)) (r) (2) (b) (3+c) + (1+e)) [target_tm]⊢* (rootV (r) (0) (2+vB+b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> default) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) (([0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> default)) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default))) + (([0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], + [0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)))) ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default))) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (sr_10 (vB) (([1] : zF) +> default) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (vB)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (vB) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) (([0, 1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> default)) ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default))) + (([1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)))) ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default))) + (([1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 28 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : + zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) + ?_ + refine step_bridge (sr_3 (vB) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (vB)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))))) (by norm_cfg) (by norm_cfg) + +theorem crossZ_step_block_root (r : zB) (vB : Nat) (b : Nat) (c : Nat) (e : Nat) : + (crossZ ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> (([1, 0] : zF) +> default)) (r) (2) (b) (3+c) + (2+e)) [target_tm]⊢* (rootZ (r) (0) (2+vB+b) (3+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> default) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) (([0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> default)) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default))) + (([0, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)))) ((([1, 0] : zF) ^ (e)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default))) + (([1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (vB) (([1] : zF) +> default) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (vB)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (vB) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 3 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> default)) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default))) + (([1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 13 ⟨B, .right, [1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)))) ((([1, 0] : zF) ^ (e)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default))) + (([1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 28 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (vB) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (vB)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))))) (by norm_cfg) (by norm_cfg) + +theorem crossVend_block_root (r : zB) (vB : Nat) (b : Nat) (c : Nat) (e : Nat) : + (crossV ((([1, 1, 0, 1, 1, 0] : zF) ^ (vB)) +> (([1, 0] : zF) +> default)) (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)) (2) (b) (3+c) (0)) [target_tm]⊢* (rootZ (r) (0) (2+vB+b) + (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> default) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) (([0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> default)) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default))) + (([0, 0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 0, 1, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)))) ((([1, 0] : zF) ^ (e)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default))) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (vB) (([1] : zF) +> default) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (vB)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (vB) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) (([0, 1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) + +> default)) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default))) + (([1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)))) ((([1, 0] : zF) ^ (e)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default))) + (([1, 0, 1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 28 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : + zF) ^ (b)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (vB)) +> default)) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (vB) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (vB)) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))))) (by norm_cfg) (by norm_cfg) + +theorem crossW_finish0 (l : zB) (a : Nat) (b : Nat) (c : Nat) : + (crossW (l) default (2+a) (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) (c) (0)) + [target_tm]⊢* (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (a)) +> l))))) {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 12 ⟨B, .left, [1, 0, 1, 0], [1, 0, 1, 1, 0, 1]⟩ ⟨B, .right, + [1, 1, 0, 1, 1, 0, 1, 1, 0], [1]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([0, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> ((([0, 1] : zF) ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_8 (b) (([1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) (([1] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 2 ⟨B, .right, [1], [1, 0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)))) default) + (by norm_cfg) (by norm_cfg) + +theorem crossW_finish1 (l : zB) (a : Nat) (b : Nat) (c : Nat) : + (crossW (l) default (2+a) (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) (c) (1)) + [target_tm]⊢* (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (a)) +> l))))) {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l)) (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (a)) +> l)) ((([1, 0] : zF) ^ (c)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) (([0] : zF) + +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1, 0, 1], [0]⟩ ⟨B, .right, [1, 0, 1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)))) default) + (by norm_cfg) (by norm_cfg) + +theorem crossW_short0 (l : zB) (b : Nat) (c : Nat) : + (crossW (l) default (1) (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) (c) (0)) + [target_tm]⊢* (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> l))))) {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 12 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1]⟩ ⟨B, .right, + [1, 1, 0, 1, 1, 0, 1], [1]⟩ rfl l ((([0, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([0, 1] : zF) ^ (c)) + +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_8 (b) (([1, 1, 0, 1, 1, 0, 1] : zF) +> l) (([1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> l)) (([1] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 2 ⟨B, .right, [1], [1, 0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> l))) default) (by norm_cfg) (by norm_cfg) + +theorem crossW_short1 (l : zB) (b : Nat) (c : Nat) : + (crossW (l) default (1) (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) (c) (1)) + [target_tm]⊢* (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> l))))) {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> l) (([0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> l) + ((([1, 0] : zF) ^ (c)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> l)) (([0] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1, 0, 1], [0]⟩ ⟨B, .right, [1, 0, 1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> l))) default) (by norm_cfg) (by norm_cfg) + +theorem scan_root_step (a : Nat) (d : Nat) : + (scan_root (a) (2+d)) [target_tm]⊢* (scan_root (4+a) (d)) := by + refine step_bridge (simSteps_star_ex 4 ⟨A, .left, [0], [1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1], + [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) + +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1] : zF) +> default) (([0, 0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ (d)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) ((([0, 1, 0] : zF) ^ (d)) + +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1] : zF) + +> ((([0, 1, 0] : zF) ^ (d)) +> default))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0, 1]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl default ((([0, 1] : zF) ^ (a)) +> ((([0, 1, 0] : zF) ^ (d)) + +> default))) (by norm_cfg) (by norm_cfg) + +theorem bare_root (a : Nat) (b : Nat) (c : Nat) : + ((default <{{A}} (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> (([0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) +> default))))))) + [target_tm]⊢* (section_481 [1+c, 2+b*2, 2+a]) := by + refine step_bridge (simSteps_star_ex 4 ⟨A, .left, [0], [1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1], + [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) +> default))))) + (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1] : zF) +> default) (([0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) +> default)))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 6 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1], [0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) +> default))) (by norm_cfg) + ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([0] : zF) +> ((([1, 0] : zF) ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([0] : zF) +> default)) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1], [0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))))) default) (by norm_cfg) + (by norm_cfg) + +theorem unary_zero : + (section_481 [0]) [target_tm]⊢⁺ (section_481 [3]) := by + exact step_end_plus (simSteps_plus 13 (by decide) ⟨B, .right, [0, 0], [0, 0, 0]⟩ ⟨B, .right, + [1, 0, 1, 0, 1], []⟩ rfl default default) (by norm_cfg) (by norm_cfg) + +theorem unary_one : + (section_481 [1]) [target_tm]⊢⁺ (section_481 [5]) := by + exact step_end_plus (simSteps_plus 39 (by decide) ⟨B, .right, [1, 0, 0, 0, 0, 0], [0, 0, 0]⟩ ⟨B, + .right, [1, 0, 1, 0, 1, 0, 1, 0, 1], []⟩ rfl default default) (by norm_cfg) (by norm_cfg) + +theorem unary_two : + (section_481 [2]) [target_tm]⊢⁺ (section_481 [9]) := by + exact step_end_plus (simSteps_plus 142 (by decide) ⟨B, .right, [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], + []⟩ rfl default default) (by norm_cfg) (by norm_cfg) + +theorem pred_S (a : Nat) (b : Nat) (n : Nat) : + (((([1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> default)))) <{{E}} (([0, 1, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (n)) +> default)))) [target_tm]⊢* (S default default (a) (2+b) (0) (n)) := by + refine step_bridge (simSteps_star_ex 10 ⟨E, .left, [1, 1, 0, 1, 1, 0, 1], [0, 1, 1]⟩ ⟨B, .left, + [1], [1, 0, 1, 1, 0, 1, 0, 1, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> default))) ((([0, 1, 0] : zF) ^ (n)) +> default)) + (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> default)) + (([0, 1, 1, 0, 1, 0, 1, 1] : zF) +> ((([0, 1, 0] : zF) ^ (n)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 1] : zF) +> ((([0, 1, 0] : zF) ^ (n)) + +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> default)) (([0, 1, 1] : zF) +> ((([0, 1, 0] : zF) ^ (n)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 28 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1, 1]⟩ ⟨E, + .left, [0], [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (a)) +> default)) ((([0, 1, 0] : zF) ^ (n)) +> default)) + (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> default)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (n)) +> default))) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, + .left, [], [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([0, 1, 0] : zF) ^ (n)) +> default))) + (by norm_cfg) (by norm_cfg) + +theorem rootT_step (a : Nat) (b : Nat) (c : Nat) (d : Nat) : + (rootT (a) (b) (c) (2+d)) [target_tm]⊢* (rootT (2+a) (b) (2+c) (d)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1] : zF) + +> ((([0, 0, 1] : zF) ^ (d)) +> default))))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1] : zF) + +> ((([0, 0, 1] : zF) ^ (d)) +> default)))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 6 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1] : zF) + +> ((([0, 0, 1] : zF) ^ (d)) +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (a)) +> default)) (([0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1] : zF) + +> ((([0, 0, 1] : zF) ^ (d)) +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([0, 0, 1, 0, 0, 1] : zF) +> ((([0, 0, 1] : zF) ^ (d)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default))))) ((([0, 0, 1] : zF) ^ (d)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([1, 0, 1, 0, 1, 0, 1] : zF) + +> ((([0, 0, 1] : zF) ^ (d)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) ((([0, 1] : zF) ^ (c)) + +> ((([0, 0, 1] : zF) ^ (d)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> ((([0, 0, 1] : zF) ^ (d)) +> default)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨A, .left, [1, 0, 1, 0, 1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> ((([0, 0, 1] : zF) ^ (d)) +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) + (([1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> ((([0, 0, 1] : zF) ^ (d)) + +> default)))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> (([0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> ((([0, 0, 1] : zF) ^ (d)) +> default))))))) (by norm_cfg) + (by norm_cfg) + +theorem rootT_end0 (a : Nat) (b : Nat) (c : Nat) : + (rootT (a) (b) (c) (0)) [target_tm]⊢* (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> default)))))) + {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1, 1, 0, 1] : zF) + +> ((([0, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([0, 1] : zF) ^ (c)) +> default))))) + (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0, 0, 1, 1, 0, 1] : zF) + +> ((([0, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([0, 1] : zF) ^ (c)) +> default)))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0, 0, 1, 1, 0, 1]⟩ ⟨B, + .right, [1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [1]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 0, 1, 1, 0, 1] : zF) ^ (b)) +> ((([0, 1] : zF) ^ (c)) +> default))) (by norm_cfg) + ?_ + refine step_bridge (sr_8 (b) (([1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([1] : zF) +> default)) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 2 ⟨B, .right, [1], [1, 0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))))) default) + (by norm_cfg) (by norm_cfg) + +theorem rootT_end1 (a : Nat) (b : Nat) (c : Nat) : + (rootT (a) (b) (c) (1)) [target_tm]⊢* (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> default)))))) + {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1] : zF) + +> default)))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1] : zF) + +> default))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 6 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1] : zF) + +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (a)) +> default)) (([0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1] : zF) +> default)))) + (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([0, 0, 1] : zF) + +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default))))) default) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([1, 0, 1, 0, 1] : zF) + +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], [1, 0, 1, 0, 1]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) ((([0, 1] : zF) ^ (c)) + +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨A, .left, [1, 0, 1, 0, 1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) + (([1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> (([0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> default)))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 0, 1, 1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> default))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 6 ⟨A, .right, [0, 1, 0, 1, 0, 1, 0, 1, 0, 1], + [0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], + [0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (a)) +> default)) (([0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 1 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1]⟩ ⟨B, .right, + [1, 0, 1, 1, 0, 1, 1, 0, 1], [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) + ((([0, 1] : zF) ^ (c)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 2 ⟨B, .right, [1, 0, 1], [1, 0]⟩ ⟨B, .right, [1, 0, 1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))))) + default) (by norm_cfg) (by norm_cfg) + +theorem pred_root (b : Nat) (n : Nat) : + (((([1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) + +> default))) <{{E}} (([0, 1, 1] : zF) +> ((([0, 1, 0] : zF) ^ (n)) +> default)))) + [target_tm]⊢* (rootT (0) (b) (0) (n)) := by + refine step_bridge (simSteps_star_ex 10 ⟨E, .left, [1, 1, 0, 1, 1, 0, 1], [0, 1, 1]⟩ ⟨B, .left, + [1], [1, 0, 1, 1, 0, 1, 0, 1, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) + ((([0, 1, 0] : zF) ^ (n)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> default) (([0, 1, 1, 0, 1, 0, 1, 1] : zF) + +> ((([0, 1, 0] : zF) ^ (n)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 1] : zF) +> ((([0, 1, 0] : zF) ^ (n)) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) (([0, 1, 1] : zF) + +> ((([0, 1, 0] : zF) ^ (n)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 24 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1, 1]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) + ((([0, 1, 0] : zF) ^ (n)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ (n)) +> default))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, + [], [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> ((([0, 1, 0] : zF) ^ (n)) +> default))) (by norm_cfg) (by norm_cfg) + +theorem scan_left_step (r : zB) (a : Nat) (d : Nat) : + (scan_left (r) (a) (2+d)) [target_tm]⊢* (scan_left (r) (4+a) (d)) := by + refine step_bridge (simSteps_star_ex 4 ⟨A, .left, [0], [1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1], + [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1] : zF) +> default) (([0, 0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ (d)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) ((([0, 1, 0] : zF) ^ (d)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1] : zF) + +> ((([0, 1, 0] : zF) ^ (d)) +> r))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0, 1]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl default ((([0, 1] : zF) ^ (a)) +> ((([0, 1, 0] : zF) ^ (d)) + +> r))) (by norm_cfg) (by norm_cfg) + +theorem scan_left_entry (r : zB) (d : Nat) : + (((([1, 0] : zF) +> default) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r)))) + [target_tm]⊢* (scan_left (r) (3) (d)) := by + exact step_end (simSteps_star_ex 25 ⟨C, .left, [1, 0, 0, 0, 0], [0, 1]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1]⟩ rfl default ((([0, 1, 0] : zF) ^ (d)) +> r)) (by norm_cfg) + (by norm_cfg) + +theorem scanW_entry (l : zB) (r : zB) (a : Nat) (w : zF) (c : Nat) (d : Nat) : + (scanW (([1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) (r) (w) (c) (d)) + [target_tm]⊢* (crossW (l) (r) (a) (([1, 0, 1, 0, 0, 1] : zF) ++ w) (c) (d)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0], [0, 1, 0, 1, 0, 0, 1]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) (w +> (([1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> ((([0, 1, 0] : zF) ^ (d)) +> r))))) (by norm_cfg) + (by norm_cfg) + +theorem crossW_zero (r : zB) (w : zF) (c : Nat) (d : Nat) : + (crossW default (r) (0) (w) (c) (d)) [target_tm]⊢* (rootW (r) (2) (w) (c) (d)) := by + exact step_end (simSteps_star_ex 21 ⟨B, .left, [0, 0, 0], [1, 0, 1]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0]⟩ rfl default (w +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> ((([0, 1, 0] : zF) ^ (d)) +> r))))) (by norm_cfg) (by norm_cfg) + +theorem crossV_two (r : zB) (b : Nat) (c : Nat) (e : Nat) : + (crossV default (r) (2) (b) (3+c) (1+e)) [target_tm]⊢* (rootV (r) (4) (1+b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) +> default) (([0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1], [0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1], [0]⟩ rfl ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) + +> ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) +> default)) + (([0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], + [0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) +> default))) + ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) + ^ (b)) +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 15 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨C, .left, [1], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) + +> default) ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_14 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 41 ⟨C, .left, [1, 0, 0, 0, 0, 0], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], + [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) + +> default)) ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default))) + (([1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], + [1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default)))) ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default))) + (([1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default)) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) + ?_ + exact step_end (simSteps_star_ex 20 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) + (by norm_cfg) (by norm_cfg) + +theorem crossV_zero (r : zB) (b : Nat) (c : Nat) (e : Nat) : + (crossV default (r) (0) (b) (c) (e)) [target_tm]⊢* (rootV (r) (2) (b) (c) (e)) := by + exact step_end (simSteps_star_ex 21 ⟨B, .left, [0, 0, 0], [1, 0, 1]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) + (by norm_cfg) + +theorem crossZ_zero (r : zB) (b : Nat) (c : Nat) (e : Nat) : + (crossZ default (r) (0) (b) (c) (e)) [target_tm]⊢* (rootZ (r) (2) (b) (c) (e)) := by + exact step_end (simSteps_star_ex 21 ⟨B, .left, [0, 0, 0], [1, 0, 1]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) (by norm_cfg) + +theorem crossZ_two (r : zB) (b : Nat) (c : Nat) (e : Nat) : + (crossZ default (r) (2) (b) (3+c) (2+e)) [target_tm]⊢* (rootZ (r) (4) (1+b) (3+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) +> default) (([0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1], [0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1], [0]⟩ rfl ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) + +> ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) +> default)) (([0, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1, 1] : zF) + +> ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) +> default))) ((([1, 0] : zF) ^ (e)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) + ^ (b)) +> default)) (([1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 15 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1], + [1, 0, 1, 0, 1, 0, 1]⟩ ⟨C, .left, [1], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) + +> default) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_14 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 41 ⟨C, .left, [1, 0, 0, 0, 0, 0], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], + [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 3 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1, 0, 1]⟩ ⟨B, + .right, [1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1], [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default)) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default))) + (([1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 13 ⟨B, .right, [1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default)))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default))) (([1, 0, 1, 0, 1, 0, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], [1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default)) ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 20 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) (by norm_cfg) + +theorem crossVend_two (r : zB) (b : Nat) (c : Nat) (e : Nat) : + (crossV default (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)) (2) (b) (3+c) (0)) + [target_tm]⊢* (rootZ (r) (4) (1+b) (4+c) (e)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) +> default) (([0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1], [0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1], [0]⟩ rfl ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) + +> ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) +> default)) (([0, 0, 1, 0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .right, [0, 1, 0, 1], [0, 0, 1, 0, 0, 1, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) +> default))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) + ^ (b)) +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 15 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨C, .left, [1], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) + +> default) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_14 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 41 ⟨C, .left, [1, 0, 0, 0, 0, 0], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], + [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) + +> default)) ((([0, 1] : zF) ^ (c)) +> (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default))) + (([1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], [1, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default)))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default))) (([1, 0, 1, 0, 1, 0, 1, 0, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default)) ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 20 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))))) (by norm_cfg) (by norm_cfg) + +theorem crossZ_empty (l : zB) (a : Nat) (b : Nat) (c : Nat) : + (crossZ (l) (([1, 0, 1] : zF) +> default) (4+a) (b) (4+c) (0)) [target_tm]⊢* (crossW (l) + default (a) (([1, 0, 1, 0, 0, 1] : zF) ^ (2+b)) (2+c) (0)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0], + [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) + +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (a)) +> l)) (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) + +> default)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 4 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l))) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([0, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 18 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0, 0, 1, 0, 1]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))))) default) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)))) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))) ((([0, 1] : zF) ^ (c)) + +> (([1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> (([1] : zF) +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) + ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) + (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) (([1, 1] : zF) + +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], [1, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)))) default) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l))) + (([1, 0, 1, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 32 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], + [1, 0, 1, 0, 1, 0, 1]⟩ ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1]⟩ rfl + ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) ((([0, 1] : zF) + ^ (c)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> default))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) + +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> default)))) (by norm_cfg) (by norm_cfg) + +theorem rootZ_empty (a : Nat) (b : Nat) (c : Nat) : + (rootZ (([1, 0, 1] : zF) +> default) (a) (b) (4+c) (0)) [target_tm]⊢* (rootW default (4+a) + (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) (2+c) (0)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) + +> default)))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 1] : zF) +> default)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) +> default)))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 4 ⟨A, .right, [0, 1], [0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (a)) +> default))) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) + +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([0, 0, 1, 0, 1] : zF) + +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 18 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0, 0, 1, 0, 1]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)))) default) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default)))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨A, .left, [1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default))))) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1] : zF) +> default)))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1] : zF) +> default)))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1] : zF) +> default)))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1] : zF) + +> default)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1], [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 0, 1], [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) + ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) (([1, 1] : zF) + +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], [1, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) default) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)))) + (([1, 0, 1, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> default))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> default))))) (by norm_cfg) (by norm_cfg) + +theorem crossZ_empty_one (b : Nat) (c : Nat) : + (crossZ default (([1, 0, 1] : zF) +> default) (1) (b) (4+c) (0)) + [target_tm]⊢* (rootW default (2) (([1, 0, 1, 0, 0, 1] : zF) ^ (1+b)) (2+c) (0)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) +> default))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) (([0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 4 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([0, 0, 1, 0, 1] : zF) +> default)) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 18 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0, 0, 1, 0, 1]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default))) default) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1] : zF) + +> default)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default)))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> default)) + ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> default))) (([1, 1] : zF) + +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], [1, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) +> default)))) default) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> default))) (([1, 0, 1, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> default)) ((([0, 1] : zF) ^ (c)) +> default)) (by norm_cfg) + ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default))) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 12 ⟨A, .left, [1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default)))) (by norm_cfg) + (by norm_cfg) + +theorem crossZ_empty_three (b : Nat) (c : Nat) : + (crossZ default (([1, 0, 1] : zF) +> default) (3) (b) (4+c) (0)) + [target_tm]⊢* (rootW default (0) (([1, 0, 1, 0, 0, 1] : zF) ^ (2+b)) (2+c) (0)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) +> default))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) +> default)))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 4 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([0, 0, 1, 0, 1] : zF) +> default)) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 18 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0, 0, 1, 0, 1]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default))) + default) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default) ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default))) (by norm_cfg) + ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> default) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> (([1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1] : zF) + +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default)))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) ((([0, 1] : zF) ^ (c)) + +> (([1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([1, 1] : zF) +> default)) (by norm_cfg) + ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], [1, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default))) default) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default)) (([1, 0, 1, 0, 1, 0, 1] : zF) +> default)) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 28 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default) ((([0, 1] : zF) ^ (c)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> default))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> default)))) (by norm_cfg) (by norm_cfg) + +theorem crossZ_empty_two (b : Nat) (c : Nat) : + (crossZ default (([1, 0, 1] : zF) +> default) (2) (b) (4+c) (0)) + [target_tm]⊢* (rootW default (4) (([1, 0, 1, 0, 0, 1] : zF) ^ (1+b)) (2+c) (0)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) +> default))))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) +> default) + (([0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0, 1] : zF) +> default)))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 4 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1], + [0, 1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1], + [0]⟩ rfl ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) +> default) ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0, 1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) + +> ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) +> default)) (([0, 0, 1, 0, 1] : zF) +> default)) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 18 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0, 0, 1, 0, 1]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 1]⟩ rfl ((([0, 1] : zF) ^ (c)) + +> (([1, 0, 1, 1, 0, 1, 1] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) +> default))) + default) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1, 1] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) + ^ (b)) +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 15 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1], + [1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ ⟨C, .left, [1], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) + +> default) ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_14 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1] : zF) + +> default)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 41 ⟨C, .left, [1, 0, 0, 0, 0, 0], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], + [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default)))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 5 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 0, 1]⟩ ⟨B, .right, [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) + +> default)) ((([0, 1] : zF) ^ (c)) +> (([1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_9 (c) (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default))) + (([1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 17 ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], [1, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (c)) +> (([1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default)))) + default) (by norm_cfg) ?_ + refine step_bridge (sr_2 (c) (([1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default))) (([1, 0, 1, 0, 1, 0, 1] : zF) +> default)) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default)) ((([0, 1] : zF) ^ (c)) +> default)) + (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> default))) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 20 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> default)))) (by norm_cfg) (by norm_cfg) + +theorem scan_left_zero (r : zB) (d : Nat) : + ((default <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r)))) + [target_tm]⊢* (scan_left (r) (1) (d)) := by + exact step_end (simSteps_star_ex 3 ⟨C, .left, [0], [0, 1]⟩ ⟨A, .left, [], + [1, 0, 1]⟩ rfl default ((([0, 1, 0] : zF) ^ (d)) +> r)) (by norm_cfg) (by norm_cfg) + +theorem scanW_zero (r : zB) (w : zF) (c : Nat) (d : Nat) : + (scanW default (r) (w) (c) (d)) [target_tm]⊢* (rootW (r) (0) (([1, 0, 1, 0, 0, 1] : zF) ++ w) + (c) (d)) := by + exact step_end (simSteps_star_ex 3 ⟨C, .left, [0], [0, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1]⟩ rfl default (w +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> ((([0, 1, 0] : zF) ^ (d)) +> r))))) (by norm_cfg) (by norm_cfg) + +theorem cleanup_one_entry (l : zB) (a : Nat) (r : zB) : + (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) + +> r))) [target_tm]⊢* (crossV (l) (r) (a) (0) (2) (0)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0], [0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ ⟨B, .left, + [], [1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) r) (by norm_cfg) + (by norm_cfg) + +theorem cleanup_one_zero (r : zB) : + ((default <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) +> r))) [target_tm]⊢* (rootV (r) (0) (0) + (2) (0)) := by + exact step_end (simSteps_star_ex 3 ⟨C, .left, [0], [0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl default r) (by norm_cfg) (by norm_cfg) + +theorem crossV_low (l : zB) (r : zB) (a : Nat) (b : Nat) (e : Nat) : + (crossV (l) (r) (4+a) (b) (2) (1+e)) [target_tm]⊢* (crossV (l) (r) (a) (2+b) (3) (e)) := by + refine step_bridge (simSteps_star_ex 15 ⟨B, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨C, .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0], + [1]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) + +> (([0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_15 (b) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 27 ⟨C, .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl + ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> l))) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 48 ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨E, .left, + [0], [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl + ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) + ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) + +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) (by norm_cfg) + +theorem rootV_low (r : zB) (a : Nat) (b : Nat) (e : Nat) : + (rootV (r) (a) (b) (2) (1+e)) [target_tm]⊢* (rootV (r) (4+a) (b) (3) (e)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) +> (([0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) +> (([0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0, 0, 1]⟩ ⟨C, .right, + [1, 1, 0, 1, 0, 1, 0, 1], [1]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) +> (([0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_15 (b) (([1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨C, .right, [1, 1, 0, 1], + [1, 0, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) + ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨A, .left, [1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .right, [0, 1], [0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) + ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))))) (by norm_cfg) (by norm_cfg) + +theorem crossV_low_one (r : zB) (b : Nat) (e : Nat) : + (crossV default (r) (1) (b) (2) (1+e)) [target_tm]⊢* (rootV (r) (2) (1+b) (3) (e)) := by + refine step_bridge (simSteps_star_ex 15 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨C, + .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [1]⟩ rfl default ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) + +> (([0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_15 (b) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 22 ⟨C, .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 30 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1] : zF) +> default)) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 12 ⟨A, .left, [1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) + (by norm_cfg) (by norm_cfg) + +theorem crossV_low_three (r : zB) (b : Nat) (e : Nat) : + (crossV default (r) (3) (b) (2) (1+e)) [target_tm]⊢* (rootV (r) (0) (2+b) (3) (e)) := by + refine step_bridge (simSteps_star_ex 15 ⟨B, .left, [1, 0, 1, 0, 1], + [1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨C, .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl default ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) +> (([0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_15 (b) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 27 ⟨C, .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl + ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> default) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 44 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl + ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> default) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) (by norm_cfg) + +theorem crossV_low_two (r : zB) (b : Nat) (e : Nat) : + (crossV default (r) (2) (b) (2) (1+e)) [target_tm]⊢* (rootV (r) (4) (1+b) (3) (e)) := by + refine step_bridge (simSteps_star_ex 15 ⟨B, .left, [1, 0, 1], [1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨C, + .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1], [1]⟩ rfl default ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) + +> (([0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_15 (b) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) +> default) + (([1, 0, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 23 ⟨C, .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1], + [1, 0, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨C, .left, [1], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([0, 1, 1, 0, 1, 1] : + zF) ^ (b)) +> default) ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_14 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 41 ⟨C, .left, [1, 0, 0, 0, 0, 0], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], + [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 1, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 30 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default)) ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (e)) +> r))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 20 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0, 1, 0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (e)) +> r)))) (by norm_cfg) (by norm_cfg) + +theorem crossVend_low (l : zB) (r : zB) (a : Nat) (b : Nat) (e : Nat) : + (crossV (l) (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)) (4+a) (b) (2) (0)) + [target_tm]⊢* (crossZ (l) (r) (a) (2+b) (3) (e)) := by + refine step_bridge (simSteps_star_ex 15 ⟨B, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨C, .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0], + [1]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) + +> (([0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_15 (b) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 27 ⟨C, .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 0, 1, 1, 0]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))) ((([1, 0] : zF) ^ (e)) + +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 48 ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1, 0, 1, 1, 0]⟩ ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0]⟩ rfl + ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) ((([1, 0] : zF) + ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) + +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0] : zF) +> ((([1, 0] : zF) + ^ (e)) +> r)))) (by norm_cfg) (by norm_cfg) + +theorem rootVend_low (r : zB) (a : Nat) (b : Nat) (e : Nat) : + (rootV (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)) (a) (b) (2) (0)) [target_tm]⊢* (rootZ (r) + (4+a) (b) (3) (e)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (([0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) +> (([0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0, 0, 1] : zF) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) +> (([0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 2 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0, 0, 1]⟩ ⟨C, .right, + [1, 1, 0, 1, 0, 1, 0, 1], [1]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) +> (([0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_15 (b) (([1, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨C, .right, [1, 1, 0, 1], [1, 0, 0, 1, 1, 0]⟩ ⟨A, .left, + [1], [1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) ((([1, 0] : zF) ^ (e)) + +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨A, .left, [1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .right, [0, 1], [0, 1, 0, 1, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default))) + ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))))) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))))) (by norm_cfg) (by norm_cfg) + +theorem crossVend_low_one (r : zB) (b : Nat) (e : Nat) : + (crossV default (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)) (1) (b) (2) (0)) + [target_tm]⊢* (rootZ (r) (2) (1+b) (3) (e)) := by + refine step_bridge (simSteps_star_ex 15 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨C, + .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [1]⟩ rfl default ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) + +> (([0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_15 (b) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 22 ⟨C, .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 0, 1, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 30 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> default)) ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 12 ⟨A, .left, [1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) + (by norm_cfg) + +theorem crossVend_low_three (r : zB) (b : Nat) (e : Nat) : + (crossV default (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)) (3) (b) (2) (0)) + [target_tm]⊢* (rootZ (r) (0) (2+b) (3) (e)) := by + refine step_bridge (simSteps_star_ex 15 ⟨B, .left, [1, 0, 1, 0, 1], + [1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨C, .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl default ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) +> (([0, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_15 (b) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 27 ⟨C, .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 0, 1, 1, 0]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default) ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> default) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 44 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default) ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) (by norm_cfg) + +theorem crossVend_low_two (r : zB) (b : Nat) (e : Nat) : + (crossV default (([1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)) (2) (b) (2) (0)) + [target_tm]⊢* (rootZ (r) (4) (1+b) (3) (e)) := by + refine step_bridge (simSteps_star_ex 15 ⟨B, .left, [1, 0, 1], [1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ ⟨C, + .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1], [1]⟩ rfl default ((([1, 0, 1, 0, 0, 1] : zF) ^ (b)) + +> (([0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_15 (b) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) +> default) + (([1, 0, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 23 ⟨C, .right, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1], + [1, 0, 0, 1, 1, 0]⟩ ⟨C, .left, [1], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0]⟩ rfl ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) + +> default) ((([1, 0] : zF) ^ (e)) +> r)) (by norm_cfg) ?_ + refine step_bridge (sr_14 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 41 ⟨C, .left, [1, 0, 0, 0, 0, 0], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], + [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (e)) +> r)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 30 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default)) ((([1, 0] : zF) ^ (e)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) +> r))) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 20 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0] : zF) +> ((([1, 0] : zF) ^ (e)) + +> r)))) (by norm_cfg) (by norm_cfg) + +theorem crossZ_empty_low (l : zB) (a : Nat) (b : Nat) : + (crossZ (l) (([1, 0, 1] : zF) +> default) (4+a) (b) (3) (0)) [target_tm]⊢* (crossW (l) + default (a) (([1, 0, 1, 0, 0, 1] : zF) ^ (2+b)) (1) (0)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0], + [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 0, 1, 0, 1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (a)) +> l)) (([0, 1, 0, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 35 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> (([0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l))) default) (by norm_cfg) + ?_ + refine step_bridge (sr_10 (b) (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1] : zF) +> default))) (by norm_cfg) + ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) (([0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 48 ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1, 0, 1, 1]⟩ ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 1, 0, 1, 1, 0] : + zF) ^ (b)) +> ((([1, 0] : zF) ^ (a)) +> l)) default) (by norm_cfg) ?_ + refine step_bridge (sr_4 (b) (([0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) + ?_ + exact step_end (simSteps_star_ex 1 ⟨E, .left, [0], + [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) + +> l) ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> default))) (by norm_cfg) + (by norm_cfg) + +theorem rootZ_empty_low (a : Nat) (b : Nat) : + (rootZ (([1, 0, 1] : zF) +> default) (a) (b) (3) (0)) [target_tm]⊢* (rootW default (4+a) + (([1, 0, 1, 0, 0, 1] : zF) ^ (b)) (1) (0)) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 0, 1, 0, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 0, 1, 0, 1] : zF) +> default)))) + (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([0, 1, 0, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .right, [0, 1], [0, 1, 0, 0, 1, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (a)) +> default))) default) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) +> default)) + (([1, 0, 1, 0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 8 ⟨A, .left, [1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 14 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1] : zF) +> default)))) (by norm_cfg) + ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .right, [0, 1], [0, 1, 0, 1, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (a)) +> default))) default) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (a)) + +> default)) (([1, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> default)))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨A, + .left, [], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (a)) + +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> default)))) (by norm_cfg) + (by norm_cfg) + +theorem crossZ_empty_low_one (b : Nat) : + (crossZ default (([1, 0, 1] : zF) +> default) (1) (b) (3) (0)) [target_tm]⊢* (rootW default (2) + (([1, 0, 1, 0, 0, 1] : zF) ^ (1+b)) (1) (0)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 0, 1, 0, 1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 30 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 0, 1, 0, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> default) default) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 16 ⟨A, .left, [1, 0, 0], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 30 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1, 0, 1, 1]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1] : zF) +> default)) default) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 12 ⟨A, .left, [1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1] : zF) +> default))) (by norm_cfg) (by norm_cfg) + +theorem crossZ_empty_low_three (b : Nat) : + (crossZ default (([1, 0, 1] : zF) +> default) (3) (b) (3) (0)) [target_tm]⊢* (rootW default (0) + (([1, 0, 1, 0, 0, 1] : zF) ^ (2+b)) (1) (0)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 0, 1, 0, 1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 35 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default) default) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1] : zF) +> default) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1, 0, 1, 1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 44 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1, 0, 1, 1]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> default) default) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> default))) (by norm_cfg) + (by norm_cfg) + +theorem crossZ_empty_low_two (b : Nat) : + (crossZ default (([1, 0, 1] : zF) +> default) (2) (b) (3) (0)) [target_tm]⊢* (rootW default (4) + (([1, 0, 1, 0, 0, 1] : zF) ^ (1+b)) (1) (0)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1, 0, 0, 1, 0, 1] : zF) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) +> default) + (([0, 1, 0, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 31 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1], + [0, 1, 0, 0, 1, 0, 1]⟩ ⟨C, .left, [1], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1]⟩ rfl ((([0, 1, 1, 0, 1, 1] : zF) ^ (b)) + +> default) default) (by norm_cfg) ?_ + refine step_bridge (sr_14 (b) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 41 ⟨C, .left, [1, 0, 0, 0, 0, 0], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], + [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1, 0, 1, 1] : zF) + +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([0, 1, 0, 1, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 30 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1], [0, 1, 0, 1, 1]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default)) default) (by norm_cfg) ?_ + refine step_bridge (sr_3 (b) (([1, 0, 1, 0, 1, 0, 1, 0, 1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 20 ⟨A, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default + ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> default))) (by norm_cfg) + (by norm_cfg) + +theorem P_S_1 (l : zB) (b : Nat) : + (((([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (b*2)) +> l)) <{{C}} (([0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 0, 0, 1, 0] : zF) ^ (b)) +> default)))) [target_tm]⊢* (S (l) default (2+b*2) + (1) (0) (b*2)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0, 1, 0], [0, 1, 0, 1, 0]⟩ ⟨B, .left, + [1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (b*2)) +> l) + ((([0, 1, 0, 0, 1, 0] : zF) ^ (b)) +> default)) (by norm_cfg) (by norm_cfg) + +theorem P_S_2 (l : zB) (b : Nat) : + (S (l) default (2) (1+b) (b*2) (0)) [target_tm]⊢* (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (b*2)) + +> (([1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l)))) + {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (b*2)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> l) (([0] : zF) + +> ((([1, 0] : zF) ^ (b*2)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (b*2) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l)) (([0] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1], [0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (b*2)) +> (([1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l))) default) (by norm_cfg) (by norm_cfg) + +theorem P_S'_1 (l : zB) (b : Nat) : + (((([1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (b*2)) +> l)) + <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0] : zF) +> ((([0, 1, 0, 0, 1, 0] : zF) ^ (b)) +> default)))) + [target_tm]⊢* (S (l) default (4+b*2) (1) (0) (1+b*2)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1, 0], + [0, 1, 0, 1, 0, 0, 1, 0]⟩ ⟨B, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (b*2)) +> l) + ((([0, 1, 0, 0, 1, 0] : zF) ^ (b)) +> default)) (by norm_cfg) (by norm_cfg) + +theorem P_S'_2 (l : zB) (b : Nat) : + (S (l) default (4) (1+b) (b*2) (1)) [target_tm]⊢* (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (b*2)) +> (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l)))) {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0], + [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) ^ (b*2)) + +> (([0, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> l) (([0] : zF) + +> ((([1, 0] : zF) ^ (b*2)) +> (([0, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (b*2) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> l))) (([0, 0, 1] : zF) + +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (b*2)) +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> l)))) default) (by norm_cfg) + ?_ + refine step_bridge (sr_2 (b*2) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0, 1, 0] : zF) +> l))) (([1, 0, 1, 0, 1] : zF) + +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0, 1, 0] : zF) +> l)) ((([0, 1] : zF) ^ (b*2)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1, 0, 1, 0] : zF) +> l) + (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (b*2)) +> default))) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) + ^ (b)) +> (([1] : zF) +> ((([0, 1] : zF) ^ (b*2)) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> l) + (([0, 1] : zF) +> ((([0, 1] : zF) ^ (b*2)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 1 ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [0, 1]⟩ ⟨B, .right, + [1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0], [1]⟩ rfl ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> l) ((([0, 1] : zF) ^ (b*2)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_9 (b*2) (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l)) (([1] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 2 ⟨B, .right, [1, 0, 1], [1, 0]⟩ ⟨B, .right, [1, 0, 1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (b*2)) +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> l))) default) (by norm_cfg) (by norm_cfg) + +theorem return_odd_1 (l : zB) (b : Nat) (d : Nat) : + (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (b*2)) +> l)) <{{C}} (([0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ (b*2+d)) +> default)))) [target_tm]⊢* (S (l) default (b*2) (1) (0) + (b*2+d)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0], [0, 1, 0, 1, 0]⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (b*2)) +> l) ((([0, 1, 0] : zF) ^ (b*2+d)) + +> default)) (by norm_cfg) (by norm_cfg) + +theorem return_even_1 (l : zB) (b : Nat) (d : Nat) : + (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (b*2)) +> l)) + <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (b*2+d)) +> default)))) + [target_tm]⊢* (S (l) default (1+b*2) (1) (0) (1+b*2+d)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0], [0, 1, 0, 1, 0, 0, 1, 0]⟩ ⟨B, .left, + [1, 0], [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (b*2)) +> l) ((([0, 1, 0] : zF) + ^ (b*2+d)) +> default)) (by norm_cfg) (by norm_cfg) + +theorem return_last_1 (l : zB) (b : Nat) : + (((([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (b*2)) +> l)) + <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0] : zF) +> ((([0, 1, 0, 0, 1, 0] : zF) ^ (b)) +> default)))) + [target_tm]⊢* (S (l) default (2+b*2) (1) (0) (1+b*2)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0, 1, 0], [0, 1, 0, 1, 0, 0, 1, 0]⟩ ⟨B, + .left, [1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (b*2)) +> l) + ((([0, 1, 0, 0, 1, 0] : zF) ^ (b)) +> default)) (by norm_cfg) (by norm_cfg) + +theorem pred_odd_1 (l : zB) (b : Nat) : + (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (b*2)) +> l)) <{{C}} (([0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 0, 0, 1, 0] : zF) ^ (b)) +> default)))) [target_tm]⊢* (S (l) default (1+b*2) + (1) (0) (b*2)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0], [0, 1, 0, 1, 0]⟩ ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (b*2)) +> l) ((([0, 1, 0, 0, 1, 0] : zF) ^ (b)) + +> default)) (by norm_cfg) (by norm_cfg) + +theorem pred_odd_2 (l : zB) (b : Nat) : + (S (l) default (1) (1+b) (b*2) (0)) [target_tm]⊢* (((([1, 0] : zF) +> ((([1, 0] : zF) ^ (b*2)) + +> (([1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) ^ (b)) +> (([1] : zF) +> l))))) + {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) +> ((([1, 0] : zF) + ^ (b*2)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> l) (([0] : zF) +> ((([1, 0] : zF) + ^ (b*2)) +> default))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (b*2) (([0, 1, 1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> l)) (([0] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1], [0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (b*2)) +> (([1, 0, 1, 1, 0, 1] : zF) +> ((([1, 0, 1, 1, 0, 1] : zF) + ^ (b)) +> l))) default) (by norm_cfg) (by norm_cfg) + +theorem pred_even_1 (l : zB) (b : Nat) : + (((([1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (b*2)) +> l)) + <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0] : zF) +> ((([0, 1, 0, 0, 1, 0] : zF) ^ (b)) +> default)))) + [target_tm]⊢* (S (l) default (3+b*2) (1) (0) (1+b*2)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [0, 1, 0, 1, 0, 0, 1, 0]⟩ ⟨B, .left, [1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (b*2)) +> l) + ((([0, 1, 0, 0, 1, 0] : zF) ^ (b)) +> default)) (by norm_cfg) (by norm_cfg) + +theorem pred_even_2 (l : zB) (b : Nat) : + (S (l) default (3) (1+b) (b*2) (1)) [target_tm]⊢* (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (b*2)) +> (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 1, 0, 1, 1, 0] : zF) + ^ (b)) +> (([1] : zF) +> l))))) {{B}}> default)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, + .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0], [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> ((([1, 0] : zF) ^ (b*2)) +> (([0, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0] : zF) +> l) (([0] : zF) + +> ((([1, 0] : zF) ^ (b*2)) +> (([0, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (b*2) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0] : zF) +> l))) (([0, 0, 1] : zF) +> default)) + (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (b*2)) +> (([1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0] : zF) +> l)))) default) (by norm_cfg) ?_ + refine step_bridge (sr_2 (b*2) (([1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> (([0] : zF) +> l))) (([1, 0, 1, 0, 1] : zF) + +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1, 0, 1, 0, 1]⟩ ⟨B, .left, [1], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) + +> (([0] : zF) +> l)) ((([0, 1] : zF) ^ (b*2)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_10 (b) (([1, 0] : zF) +> l) (([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (b*2)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 19 ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], [0]⟩ rfl l ((([0, 1, 1, 0, 1, 0] : zF) ^ (b)) + +> (([1] : zF) +> ((([0, 1] : zF) ^ (b*2)) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (b) (([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) +> l) + (([0, 1] : zF) +> ((([0, 1] : zF) ^ (b*2)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 1 ⟨A, .right, [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [0, 1]⟩ ⟨B, .right, [1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1], + [1]⟩ rfl ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> l) ((([0, 1] : zF) ^ (b*2)) +> default)) + (by norm_cfg) ?_ + refine step_bridge (sr_9 (b*2) (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> l)) (([1] : zF) +> default)) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 2 ⟨B, .right, [1, 0, 1], [1, 0]⟩ ⟨B, .right, [1, 0, 1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (b*2)) +> (([1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1] : zF) + +> ((([1, 0, 1, 1, 0, 1] : zF) ^ (b)) +> l))) default) (by norm_cfg) (by norm_cfg) + +theorem Word_U_1 (l : zB) (r : zB) : + ((l {{B}}> (([1, 0] : zF) +> r))) [target_tm]⊢* (((([1, 0] : zF) +> l) {{B}}> r)) := by + exact step_end (simSteps_star_ex 2 ⟨B, .right, [], [1, 0]⟩ ⟨B, .right, [1, 0], []⟩ rfl l r) + (by norm_cfg) (by norm_cfg) + +theorem Word_U_2 (l : zB) (r : zB) : + (((([1, 0] : zF) +> l) <{{A}} r)) [target_tm]⊢* ((l <{{A}} (([1, 0] : zF) +> r))) := by + exact step_end (simSteps_star_ex 4 ⟨A, .left, [1, 0], []⟩ ⟨A, .left, [], [1, 0]⟩ rfl l r) + (by norm_cfg) (by norm_cfg) + +theorem Word_V_1 (l : zB) (r : zB) : + ((l {{B}}> (([1, 0, 0, 1, 1, 0] : zF) +> r))) [target_tm]⊢* (((([1, 1, 0, 1, 1, 0] : zF) +> l) + {{B}}> r)) := by + exact step_end (simSteps_star_ex 6 ⟨B, .right, [], [1, 0, 0, 1, 1, 0]⟩ ⟨B, .right, + [1, 1, 0, 1, 1, 0], []⟩ rfl l r) (by norm_cfg) (by norm_cfg) + +theorem Word_V_2 (l : zB) (r : zB) : + (((([1, 1, 0, 1, 1, 0] : zF) +> l) <{{A}} r)) + [target_tm]⊢* ((l <{{A}} (([1, 0, 1, 0, 0, 1] : zF) +> r))) := by + exact step_end (simSteps_star_ex 14 ⟨A, .left, [1, 1, 0, 1, 1, 0], []⟩ ⟨A, .left, [], + [1, 0, 1, 0, 0, 1]⟩ rfl l r) (by norm_cfg) (by norm_cfg) + +theorem rootW_step_1 (r : zB) (a : Nat) (w : zF) (c : Nat) (d : Nat) : + (rootW (r) (a) (w) (c) (2+d)) [target_tm]⊢* (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> default)) {{B}}> (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r))))))) := by + refine step_bridge (simSteps_star_ex 2 ⟨A, .left, [0], [1, 0]⟩ ⟨A, .right, [0, 1], + [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r))))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1] : zF) +> default) (([0] : zF) + +> (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ (d)) +> r))))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1], [0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r)))))) (by norm_cfg) + (by norm_cfg) + +theorem rootW_step_3 (l : zB) (r : zB) (c : Nat) (d : Nat) : + ((l {{B}}> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ (d)) +> r)))))) [target_tm]⊢* ((l <{{A}} (([1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (d)) + +> r)))))) := by + refine step_bridge (simSteps_star_ex 3 ⟨B, .right, [], [1, 0, 1, 0]⟩ ⟨A, .right, [0, 1, 0], + [0]⟩ rfl l ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r)))) + (by norm_cfg) ?_ + refine step_bridge (sr_1 (c) (([0, 1, 0] : zF) +> l) (([0, 0, 1, 0] : zF) +> ((([0, 1, 0] : zF) + ^ (d)) +> r))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 11 ⟨A, .right, [0, 1, 0], [0, 0, 1, 0]⟩ ⟨C, .left, [0], + [0, 1, 0, 1, 0, 1]⟩ rfl ((([1, 0] : zF) ^ (c)) +> l) ((([0, 1, 0] : zF) ^ (d)) +> r)) + (by norm_cfg) ?_ + refine step_bridge (sr_12 (c) (([0] : zF) +> l) (([1, 0, 1, 0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (d)) +> r))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 3 ⟨C, .left, [0], [0, 1, 0, 1, 0, 1]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1]⟩ rfl l ((([0, 1] : zF) ^ (c)) +> ((([0, 1, 0] : zF) ^ (d)) +> r))) + (by norm_cfg) (by norm_cfg) + +theorem rootW_step_4 (r : zB) (a : Nat) (w : zF) (c : Nat) (d : Nat) : + (((([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> default)) + <{{A}} (w +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([1, 0, 1] : zF) + +> ((([0, 1, 0] : zF) ^ (d)) +> r))))))) [target_tm]⊢* (rootW (r) (2+a) (w) (2+c) + (d)) := by + refine step_bridge (simSteps_star_ex 9 ⟨A, .left, [1, 0, 1, 0, 1, 0], []⟩ ⟨C, .left, [0], + [0, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a)) +> default) (w +> (([1, 0, 1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> ((([0, 1, 0] : zF) ^ (d)) +> r))))) (by norm_cfg) ?_ + refine step_bridge (sr_12 (a) (([0] : zF) +> default) (([1, 0, 1, 0] : zF) + +> (w +> (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> ((([0, 1, 0] : zF) ^ (d)) + +> r)))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 3 ⟨C, .left, [0], [0, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (w +> (([1, 0, 1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> ((([0, 1, 0] : zF) ^ (d)) +> r)))))) (by norm_cfg) + (by norm_cfg) + +theorem crossW_step_1 (l : zB) (r : zB) (a : Nat) (w : zF) (c : Nat) (d : Nat) : + (crossW (l) (r) (2+a) (w) (c) (2+d)) [target_tm]⊢* (((([0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) {{F}}> (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r))))))) := by + exact step_end (simSteps_star_ex 10 ⟨B, .left, [1, 0, 1, 0], [1, 0, 1]⟩ ⟨F, .right, + [0, 1, 1, 0, 1, 1, 0], []⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) (w +> (([1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r)))))) + (by norm_cfg) (by norm_cfg) + +theorem crossW_step_2 (l : zB) (r : zB) : + (((([0, 1, 1, 0, 1, 1, 0] : zF) +> l) {{F}}> (([1, 0] : zF) +> r))) + [target_tm]⊢* (((([1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> l) {{B}}> r)) := by + exact step_end (simSteps_star_ex 2 ⟨F, .right, [0, 1, 1, 0, 1, 1, 0], [1, 0]⟩ ⟨B, .right, + [1, 1, 0, 1, 1, 0, 1, 1, 0], []⟩ rfl l r) (by norm_cfg) (by norm_cfg) + +theorem crossW_step_4 (l : zB) (r : zB) (a : Nat) (w : zF) (c : Nat) (d : Nat) : + (((([1, 1, 0, 1, 1, 0, 1, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) +> l)) + <{{A}} (w +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([1, 0, 1] : zF) + +> ((([0, 1, 0] : zF) ^ (d)) +> r))))))) [target_tm]⊢* (crossW (l) (r) (a) + (([1, 0, 1, 0, 0, 1] : zF) ++ w) (2+c) (d)) := by + exact step_end (simSteps_star_ex 19 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1, 0], []⟩ ⟨B, .left, [], + [1, 0, 1, 1, 0, 1, 0, 0, 1]⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) + (w +> (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) +> ((([0, 1, 0] : zF) ^ (d)) + +> r))))) (by norm_cfg) (by norm_cfg) + +theorem normal_odd_root_1 (a : Nat) (d : Nat) : + (((([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a*2)) +> default)) + <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0] : zF) +> ((([0, 1, 0, 0, 1, 0] : zF) ^ (a+d)) + +> default)))) [target_tm]⊢* (S default default (2+a*2) (1) (0) (2+a*2+d*2)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0, 1, 0], + [0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0]⟩ ⟨B, .left, [1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a*2)) +> default) + ((([0, 1, 0, 0, 1, 0] : zF) ^ (a+d)) +> default)) (by norm_cfg) (by norm_cfg) + +theorem normal_odd_root_2 (a : Nat) (d : Nat) : + (S default default (0) (1+(a+1)) (2+a*2) (d*2)) [target_tm]⊢* (rootW default (2) + (([1, 0, 1, 0, 0, 1] : zF) ^ (1+a)) (1+a*2) (1+d*2)) := by + exact step_end (simSteps_star_ex 21 ⟨B, .left, [0, 0, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (a)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a*2)) +> (([0] : zF) + +> ((([1, 0, 0, 1, 0, 0] : zF) ^ (d)) +> default)))))) (by norm_cfg) (by norm_cfg) + +theorem normal_even_root_1 (a : Nat) (d : Nat) : + (((([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a*2)) +> default)) + <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0] : zF) +> ((([0, 1, 0, 0, 1, 0] : zF) ^ (a+d)) + +> default)))) [target_tm]⊢* (S default default (2+a*2) (1) (0) (1+a*2+d*2)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0, 1, 0], [0, 1, 0, 1, 0, 0, 1, 0]⟩ ⟨B, + .left, [1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a*2)) +> default) + ((([0, 1, 0, 0, 1, 0] : zF) ^ (a+d)) +> default)) (by norm_cfg) (by norm_cfg) + +theorem normal_even_root_2_d0 (a : Nat) : + (S default default (2) (a+1) (a*2) (1)) [target_tm]⊢* (rootW default (2) + (([1, 0, 1, 0, 0, 1] : zF) ^ (1+a)) (1+a*2) (0)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (a)) + +> ((([1, 0] : zF) ^ (a*2)) +> (([0, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (a) (([0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) +> default) (([0] : zF) + +> ((([1, 0] : zF) ^ (a*2)) +> (([0, 1] : zF) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a*2) (([0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) + ^ (a)) +> default)) (([0, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0]⟩ ⟨A, .left, [1], + [1, 0, 1, 0, 1]⟩ rfl ((([0, 1] : zF) ^ (a*2)) +> (([1, 0, 1, 1, 0, 1, 1] : zF) + +> ((([0, 1, 1, 0, 1, 1] : zF) ^ (a)) +> default))) default) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a*2) (([1, 1, 0, 1, 1, 0, 1, 1] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) + ^ (a)) +> default)) (([1, 0, 1, 0, 1] : zF) +> default)) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 15 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1], [1, 0, 1, 0, 1]⟩ ⟨C, + .left, [1], [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1]⟩ rfl ((([0, 1, 1, 0, 1, 1] : zF) ^ (a)) + +> default) ((([0, 1] : zF) ^ (a*2)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_14 (a) (([1] : zF) +> default) (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (a*2)) +> default))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 25 ⟨C, .left, [1, 0, 0, 0, 0], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (a)) +> (([1] : zF) +> ((([0, 1] : zF) ^ (a*2)) +> default)))) (by norm_cfg) + (by norm_cfg) + +theorem normal_even_root_2_dS (a : Nat) (d : Nat) : + (S default default (2) (a+1) (a*2) (1+(1+d)*2)) [target_tm]⊢* (rootW default (2) + (([1, 0, 1, 0, 0, 1] : zF) ^ (1+a)) (1+a*2) ((1+d)*2)) := by + refine step_bridge (simSteps_star_ex 13 ⟨B, .left, [1, 0, 1], [1, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 1, 0, 1, 1, 0, 1, 1], [0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) ^ (a)) + +> ((([1, 0] : zF) ^ (a*2)) +> (([0, 1, 0, 0, 1, 0, 0, 1, 0, 0] : zF) + +> ((([1, 0, 0, 1, 0, 0] : zF) ^ (d)) +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_0 (a) (([0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) +> default) (([0] : zF) + +> ((([1, 0] : zF) ^ (a*2)) +> (([0, 1, 0, 0, 1, 0, 0, 1, 0, 0] : zF) + +> ((([1, 0, 0, 1, 0, 0] : zF) ^ (d)) +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a*2) (([0, 1, 1, 0, 1, 1, 0, 1, 1] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) + ^ (a)) +> default)) (([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0] : zF) +> ((([1, 0, 0, 1, 0, 0] : zF) + ^ (d)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 10 ⟨A, .right, [0, 1], [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0]⟩ ⟨A, + .left, [1], [1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0]⟩ rfl ((([0, 1] : zF) ^ (a*2)) + +> (([1, 0, 1, 1, 0, 1, 1] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) ^ (a)) +> default))) + ((([1, 0, 0, 1, 0, 0] : zF) ^ (d)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_2 (a*2) (([1, 1, 0, 1, 1, 0, 1, 1] : zF) +> ((([0, 1, 1, 0, 1, 1] : zF) + ^ (a)) +> default)) (([1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0] : zF) + +> ((([1, 0, 0, 1, 0, 0] : zF) ^ (d)) +> default))) (by norm_cfg) ?_ + refine step_bridge (simSteps_star_ex 15 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 1], + [1, 0, 1, 0, 1, 0, 1, 0]⟩ ⟨C, .left, [1], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]⟩ rfl ((([0, 1, 1, 0, 1, 1] : zF) ^ (a)) + +> default) ((([1, 0] : zF) ^ (a*2)) +> (([0, 1, 0, 0] : zF) + +> ((([1, 0, 0, 1, 0, 0] : zF) ^ (d)) +> default)))) (by norm_cfg) ?_ + refine step_bridge (sr_14 (a) (([1] : zF) +> default) + (([1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a*2)) + +> (([0, 1, 0, 0] : zF) +> ((([1, 0, 0, 1, 0, 0] : zF) ^ (d)) +> default))))) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 25 ⟨C, .left, [1, 0, 0, 0, 0], + [0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0]⟩ rfl default ((([0, 1, 1, 0, 1, 0] : zF) + ^ (a)) +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a*2)) +> (([0, 1, 0, 0] : zF) + +> ((([1, 0, 0, 1, 0, 0] : zF) ^ (d)) +> default)))))) (by norm_cfg) (by norm_cfg) + +theorem even_left_even_1 (a : Nat) (d : Nat) : + (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a*2)) +> default)) + <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0] : zF) +> ((([0, 1, 0, 0, 1, 0] : zF) ^ (a+d)) + +> default)))) [target_tm]⊢* (S default default (1+a*2) (1) (0) (1+a*2+d*2)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0], [0, 1, 0, 1, 0, 0, 1, 0]⟩ ⟨B, .left, + [1, 0], [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a*2)) +> default) + ((([0, 1, 0, 0, 1, 0] : zF) ^ (a+d)) +> default)) (by norm_cfg) (by norm_cfg) + +theorem even_left_odd_1 (l : zB) (a : Nat) (m : Nat) : + (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a*2)) +> l)) <{{C}} (([0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ (a*2+m)) +> default)))) [target_tm]⊢* (S (l) default (1+a*2) (1) (0) + (a*2+m)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0], [0, 1, 0, 1, 0]⟩ ⟨B, .left, [1, 0], + [1, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a*2)) +> l) ((([0, 1, 0] : zF) ^ (a*2+m)) + +> default)) (by norm_cfg) (by norm_cfg) + +theorem left_overflow_odd_1 (l : zB) (a : Nat) (d : Nat) : + (((([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a+d*2)) +> l)) <{{C}} (([0, 1, 0, 1, 0] : zF) + +> ((([0, 1, 0, 0, 1, 0] : zF) ^ (d)) +> default)))) [target_tm]⊢* (S (l) default (2+a+d*2) + (1) (0) (d*2)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0, 1, 0], [0, 1, 0, 1, 0]⟩ ⟨B, .left, + [1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a+d*2)) +> l) + ((([0, 1, 0, 0, 1, 0] : zF) ^ (d)) +> default)) (by norm_cfg) (by norm_cfg) + +theorem left_overflow_even_1 (l : zB) (a : Nat) (d : Nat) : + (((([1, 0, 1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a+d*2)) +> l)) + <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0] : zF) +> ((([0, 1, 0, 0, 1, 0] : zF) ^ (d)) +> default)))) + [target_tm]⊢* (S (l) default (4+a+d*2) (1) (0) (1+d*2)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0, 1, 0, 1, 0, 1, 0], + [0, 1, 0, 1, 0, 0, 1, 0]⟩ ⟨B, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a+d*2)) +> l) + ((([0, 1, 0, 0, 1, 0] : zF) ^ (d)) +> default)) (by norm_cfg) (by norm_cfg) + +theorem border_even_1 (l : zB) (a : Nat) : + (((([1, 0, 1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a*2)) +> l)) + <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0] : zF) +> ((([0, 1, 0, 0, 1, 0] : zF) ^ (a)) +> default)))) + [target_tm]⊢* (S (l) default (3+a*2) (1) (0) (1+a*2)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0, 1, 0, 1, 0], + [0, 1, 0, 1, 0, 0, 1, 0]⟩ ⟨B, .left, [1, 0, 1, 0, 1, 0], + [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (a*2)) +> l) + ((([0, 1, 0, 0, 1, 0] : zF) ^ (a)) +> default)) (by norm_cfg) (by norm_cfg) + +theorem rootW_finish_word0_1 (a : Nat) (w : zF) (c : Nat) : + (rootW default (a) (w) (c) (0)) [target_tm]⊢* (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> default)) {{B}}> (w +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> default))))) := by + refine step_bridge (simSteps_star_ex 2 ⟨A, .left, [0], [1, 0]⟩ ⟨A, .right, [0, 1], + [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (w +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1] : zF) +> default) (([0] : zF) +> (w +> (([1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> default))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1], [0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) (w +> (([1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> default)))) (by norm_cfg) (by norm_cfg) + +theorem rootW_finish_word_end (l : zB) (n : Nat) : + ((l {{B}}> ((([1, 0] : zF) ^ (n)) +> default))) [target_tm]⊢* ((((([1, 0] : zF) ^ (n)) +> l) + {{B}}> default)) := by + exact step_end (sr_9 (n) l default) (by norm_cfg) (by norm_cfg) + +theorem crossW_finish_word0_1 (l : zB) (a : Nat) (w : zF) (c : Nat) : + (crossW (l) default (2+a) (w) (c) (0)) [target_tm]⊢* (((([0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) {{F}}> (w +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> default))))) := by + exact step_end (simSteps_star_ex 10 ⟨B, .left, [1, 0, 1, 0], [1, 0, 1]⟩ ⟨F, .right, + [0, 1, 1, 0, 1, 1, 0], []⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) (w +> (([1, 0, 1] : zF) + +> ((([0, 1] : zF) ^ (c)) +> default)))) (by norm_cfg) (by norm_cfg) + +theorem crossW_finish_word1_1 (l : zB) (a : Nat) (w : zF) (c : Nat) : + (crossW (l) default (2+a) (w) (c) (1)) [target_tm]⊢* (((([0, 1, 1, 0, 1, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (a)) +> l)) {{F}}> (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> default))))) := by + exact step_end (simSteps_star_ex 10 ⟨B, .left, [1, 0, 1, 0], [1, 0, 1]⟩ ⟨F, .right, + [0, 1, 1, 0, 1, 1, 0], []⟩ rfl ((([1, 0] : zF) ^ (a)) +> l) (w +> (([1, 0, 1, 0, 1, 0] : zF) + +> ((([1, 0] : zF) ^ (c)) +> default)))) (by norm_cfg) (by norm_cfg) + +theorem rootW_finish_word1_1 (a : Nat) (w : zF) (c : Nat) : + (rootW default (a) (w) (c) (1)) [target_tm]⊢* (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (a)) + +> default)) {{B}}> (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> default))))) := by + refine step_bridge (simSteps_star_ex 2 ⟨A, .left, [0], [1, 0]⟩ ⟨A, .right, [0, 1], + [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> default))))) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1] : zF) +> default) (([0] : zF) + +> (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> default))))) (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1], [0]⟩ ⟨B, .right, [1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> default)))) (by norm_cfg) (by norm_cfg) + +theorem final_zero_1 (m : Nat) : + (final_scan (0) (m)) [target_tm]⊢* (scan_root (1) (m)) := by + exact step_end (simSteps_star_ex 3 ⟨C, .left, [0], [0, 1]⟩ ⟨A, .left, [], + [1, 0, 1]⟩ rfl default ((([0, 1, 0] : zF) ^ (m)) +> default)) (by norm_cfg) (by norm_cfg) + +theorem final_one_1 (m : Nat) : + (final_scan (1) (m)) [target_tm]⊢* (scan_root (3) (m)) := by + exact step_end (simSteps_star_ex 25 ⟨C, .left, [1, 0, 0, 0, 0], [0, 1]⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 1]⟩ rfl default ((([0, 1, 0] : zF) ^ (m)) +> default)) (by norm_cfg) + (by norm_cfg) + +theorem final_even_2 (a : Nat) : + (scan_root (1+a) (0)) [target_tm]⊢* (section_481 [3+a]) := by + refine step_bridge (simSteps_star_ex 3 ⟨A, .left, [0], [1, 0, 1]⟩ ⟨B, .right, [1, 0, 1], + [1]⟩ rfl default ((([0, 1] : zF) ^ (a)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_9 (a) (([1, 0, 1] : zF) +> default) (([1] : zF) +> default)) (by norm_cfg) + ?_ + exact step_end (simSteps_star_ex 2 ⟨B, .right, [1, 0, 1], [1, 0]⟩ ⟨B, .right, [1, 0, 1, 0, 1], + []⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) default) (by norm_cfg) (by norm_cfg) + +theorem final_odd_2 (a : Nat) : + (scan_root (1+a) (1)) [target_tm]⊢* (section_481 [4+a]) := by + refine step_bridge (simSteps_star_ex 6 ⟨A, .left, [0], [1, 0, 1, 0, 1, 0]⟩ ⟨A, .right, + [0, 1, 0, 1, 0, 1], [0]⟩ rfl default ((([1, 0] : zF) ^ (a)) +> default)) (by norm_cfg) ?_ + refine step_bridge (sr_1 (a) (([0, 1, 0, 1, 0, 1] : zF) +> default) (([0] : zF) +> default)) + (by norm_cfg) ?_ + exact step_end (simSteps_star_ex 1 ⟨A, .right, [0, 1, 0, 1, 0, 1], [0]⟩ ⟨B, .right, + [1, 0, 1, 0, 1, 0, 1], []⟩ rfl ((([0, 1] : zF) ^ (a)) +> default) default) (by norm_cfg) + (by norm_cfg) + +theorem crossW_one_word_1 (r : zB) (w : zF) (c : Nat) (d : Nat) : + (crossW default (r) (1) (w) (c) (2+d)) [target_tm]⊢* (((([0, 1, 1, 0, 1] : zF) +> default) + {{F}}> (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ (d)) +> r))))))) := by + exact step_end (simSteps_star_ex 10 ⟨B, .left, [1, 0], [1, 0, 1]⟩ ⟨F, .right, [0, 1, 1, 0, 1], + []⟩ rfl default (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) + +> (([0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r)))))) (by norm_cfg) (by norm_cfg) + +theorem crossW_one_word_2 (l : zB) (r : zB) : + (((([0, 1, 1, 0, 1] : zF) +> l) {{F}}> (([1, 0] : zF) +> r))) + [target_tm]⊢* (((([1, 1, 0, 1, 1, 0, 1] : zF) +> l) {{B}}> r)) := by + exact step_end (simSteps_star_ex 2 ⟨F, .right, [0, 1, 1, 0, 1], [1, 0]⟩ ⟨B, .right, + [1, 1, 0, 1, 1, 0, 1], []⟩ rfl l r) (by norm_cfg) (by norm_cfg) + +theorem crossW_one_word_4 (r : zB) (w : zF) (c : Nat) (d : Nat) : + (((([1, 1, 0, 1, 1, 0, 1] : zF) +> default) <{{A}} (w +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r))))))) + [target_tm]⊢* (rootW (r) (0) (([1, 0, 1, 0, 0, 1] : zF) ++ w) (2+c) (d)) := by + exact step_end (simSteps_star_ex 18 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1, 0], []⟩ ⟨A, .left, [], + [1, 0, 1, 0, 1, 0, 0, 1]⟩ rfl default (w +> (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) + ^ (c)) +> ((([0, 1, 0] : zF) ^ (d)) +> r))))) (by norm_cfg) (by norm_cfg) + +theorem crossW_next_1 (l : zB) (r : zB) (w : zF) (c : Nat) (d : Nat) : + (crossW (l) (r) (1) (w) (c) (2+d)) [target_tm]⊢* (((([0, 1, 1, 0, 1] : zF) +> l) + {{F}}> (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ (d)) +> r))))))) := by + exact step_end (simSteps_star_ex 10 ⟨B, .left, [1, 0], [1, 0, 1]⟩ ⟨F, .right, [0, 1, 1, 0, 1], + []⟩ rfl l (w +> (([1, 0, 1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (c)) +> (([0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ (d)) +> r)))))) (by norm_cfg) (by norm_cfg) + +theorem crossW_next_4 (l : zB) (r : zB) (w : zF) (c : Nat) (d : Nat) : + (((([1, 1, 0, 1, 1, 0, 1] : zF) +> l) <{{A}} (w +> (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) + ^ (c)) +> (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r))))))) + [target_tm]⊢* (scanW (l) (r) (w) (2+c) (d)) := by + exact step_end (simSteps_star_ex 15 ⟨A, .left, [1, 1, 0, 1, 1, 0, 1], []⟩ ⟨C, .left, [], + [0, 1, 0, 1, 0, 0, 1]⟩ rfl l (w +> (([1, 0, 1, 0, 1, 0, 1] : zF) +> ((([0, 1] : zF) ^ (c)) + +> ((([0, 1, 0] : zF) ^ (d)) +> r))))) (by norm_cfg) (by norm_cfg) + +theorem scan_pair_1 (l : zB) (r : zB) (n : Nat) (d : Nat) : + (((([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ (n*2)) +> l)) + <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d+n*2)) +> r)))) + [target_tm]⊢* (S (l) (([1, 0] : zF) +> ((([0, 1, 0] : zF) ^ (d)) +> r)) (1+n*2) (1) (0) + (n*2)) := by + exact step_end (simSteps_star_ex 4 ⟨C, .left, [1, 0, 1, 0], [0, 1, 0, 1, 0, 0, 1, 0]⟩ ⟨B, .left, + [1, 0], [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]⟩ rfl ((([1, 0] : zF) ^ (n*2)) +> l) ((([0, 1, 0] : zF) + ^ (d+n*2)) +> r)) (by norm_cfg) (by norm_cfg) + +theorem init_tm1 : + ((default {{A}}> default)) [target_tm]⊢* (section_481 [1]) := by + exact step_end (simSteps_star_ex 1 ⟨A, .right, [], [0]⟩ ⟨B, .right, [1], []⟩ rfl default default) + (by norm_cfg) (by norm_cfg) + +def special (r : zB) : zB := + ([1, 0, 0, 1, 1, 0, 1, 0, 1, 0] : zF) +> r + +def specialN (n : Nat) (r : zB) : zB := + ([1] : zF) +> ((([0, 0, 1, 1, 0, 1] : zF) ^ (1 + n)) +> ((([0, 1] : zF) ^ (1 + n * 2)) + +> (([0] : zF) +> r))) + +def negativeN (l : zB) (p n d e : Nat) : Cfg (Fin 2) (Fin 6) := + ((([1, 0] : zF) ^ (p + 2 + n * 2)) +> ((([1, 1, 0] : zF) ^ (p + 4 + n * 2 + e)) +> ((([1, 0] : zF) + ^ (1 + d * 2)) +> l))) {{B}}> default + +def loneN (l : zB) (p n e : Nat) : Cfg (Fin 2) (Fin 6) := + ((([1, 0] : zF) ^ (p + 2 + n * 2)) +> ((([1, 1, 0] : zF) ^ (p + 3 + n * 2 + e)) +> (([1] : zF) + +> l))) {{B}}> default + +def flow_tail (n : Nat) (r : zB) : zB := + ([0, 1, 1] : zF) +> ((([0, 1, 0, 0, 1, 1] : zF) ^ n) +> ((([0, 1] : zF) ^ (2 + n * 2)) + +> (([0] : zF) +> r))) + +def short_suffix (n d : Nat) : zB := + ([0, 1] : zF) +> ((([0, 0, 1, 1, 0, 1] : zF) ^ (1 + n)) +> ((([0, 1] : zF) ^ (1 + n * 2)) + +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ d) +> default)))) + +theorem fold2 (a b : Fin 2) (n : Nat) (s : zB) : + a ::ᵇ (b ::ᵇ ((([a, b] : zF) ^ n) +> s)) = ((([a, b] : zF) ^ (1 + n)) +> s) := by + rw [pow_add_1, List.cons_append, List.cons_append, List.nil_append, listblank_append_cons, + listblank_append_cons] + +theorem fold3 (a b c : Fin 2) (n : Nat) (s : zB) : + a ::ᵇ (b ::ᵇ (c ::ᵇ ((([a, b, c] : zF) ^ n) +> s))) = ((([a, b, c] : zF) ^ (1 + n)) +> s) := by + rw [pow_add_1, List.cons_append, List.cons_append, List.cons_append, List.nil_append, + listblank_append_cons, listblank_append_cons, listblank_append_cons] + +theorem fold6 (a b c d e f : Fin 2) (n : Nat) (s : zB) : + a ::ᵇ (b ::ᵇ (c ::ᵇ (d ::ᵇ (e ::ᵇ (f ::ᵇ ((([a, b, c, d, e, f] : zF) ^ n) +> s)))))) = + ((([a, b, c, d, e, f] : zF) ^ (1 + n)) +> s) := by + rw [pow_add_1, List.cons_append, List.cons_append, List.cons_append, List.cons_append, + List.cons_append, List.cons_append, List.nil_append, + listblank_append_cons, listblank_append_cons, listblank_append_cons, listblank_append_cons, + listblank_append_cons, listblank_append_cons] + +theorem cfg_left_congr {q : Fin 6} {l₁ l₂ r₁ r₂ : zB} (hl : l₁ = l₂) (hr : r₁ = r₂) : + (l₁ <{{q}} r₁) = (l₂ <{{q}} r₂) := by rw [hl, hr] + +theorem cfg_right_congr {q : Fin 6} {l₁ l₂ r₁ r₂ : zB} (hl : l₁ = l₂) (hr : r₁ = r₂) : + (l₁ {{q}}> r₁) = (l₂ {{q}}> r₂) := by rw [hl, hr] + +theorem app2_congr {α : Type} {f : Nat → Nat → α} {a₁ a₂ b₁ b₂ : Nat} + (ha : a₁ = a₂) (hb : b₁ = b₂) : f a₁ b₁ = f a₂ b₂ := by rw [ha, hb] + +theorem app3_congr {α : Type} {f : zB → Nat → Nat → α} {l₁ l₂ : zB} {a₁ a₂ b₁ b₂ : Nat} + (hl : l₁ = l₂) (ha : a₁ = a₂) (hb : b₁ = b₂) : f l₁ a₁ b₁ = f l₂ a₂ b₂ := by rw [hl, ha, hb] + +theorem cons_congr {a : Fin 2} {s₁ s₂ : zB} (hs : s₁ = s₂) : + (a ::ᵇ s₁) = (a ::ᵇ s₂) := by rw [hs] + +theorem same_pow_congr {w : zF} {n₁ n₂ : Nat} {s₁ s₂ : zB} (hn : n₁ = n₂) (hs : s₁ = s₂) : + ((w ^ n₁) +> s₁) = ((w ^ n₂) +> s₂) := by rw [hn, hs] + +theorem same_word_congr {w : zF} {s₁ s₂ : zB} (hs : s₁ = s₂) : + (w +> s₁) = (w +> s₂) := by rw [hs] + +theorem pow_zero_left {w : zF} {n : Nat} {s₁ s₂ : zB} (hn : n = 0) (hs : s₁ = s₂) : + ((w ^ n) +> s₁) = s₂ := by + rw [hn, list_pow_zero, listblank_append_nil, hs] + +theorem pow_zero_right {w : zF} {n : Nat} {s₁ s₂ : zB} (hn : 0 = n) (hs : s₁ = s₂) : + s₁ = ((w ^ n) +> s₂) := by + rw [← hn, list_pow_zero, listblank_append_nil, hs] + +theorem pow2_succ_left {a b : Fin 2} {n : Nat} {s₁ s₂ : zB} + (hn : n ≥ 1) (hs : s₁ = ((([a, b] : zF) ^ (n - 1)) +> s₂)) : + (a ::ᵇ (b ::ᵇ s₁)) = ((([a, b] : zF) ^ n) +> s₂) := by + have h1 : n = 1 + (n - 1) := by omega + rw [h1, ← fold2, hs] + +theorem pow2_succ_right {a b : Fin 2} {n : Nat} {s₁ s₂ : zB} + (hn : n ≥ 1) (hs : ((([a, b] : zF) ^ (n - 1)) +> s₁) = s₂) : + ((([a, b] : zF) ^ n) +> s₁) = (a ::ᵇ (b ::ᵇ s₂)) := by + have h1 : n = 1 + (n - 1) := by omega + rw [h1, ← fold2, hs] + +theorem pow3_succ_left {a b c : Fin 2} {n : Nat} {s₁ s₂ : zB} + (hn : n ≥ 1) (hs : s₁ = ((([a, b, c] : zF) ^ (n - 1)) +> s₂)) : + (a ::ᵇ (b ::ᵇ (c ::ᵇ s₁))) = ((([a, b, c] : zF) ^ n) +> s₂) := by + have h1 : n = 1 + (n - 1) := by omega + rw [h1, ← fold3, hs] + +theorem pow3_succ_right {a b c : Fin 2} {n : Nat} {s₁ s₂ : zB} + (hn : n ≥ 1) (hs : ((([a, b, c] : zF) ^ (n - 1)) +> s₁) = s₂) : + ((([a, b, c] : zF) ^ n) +> s₁) = (a ::ᵇ (b ::ᵇ (c ::ᵇ s₂))) := by + have h1 : n = 1 + (n - 1) := by omega + rw [h1, ← fold3, hs] + +theorem pow6_succ_left {a b c d e f : Fin 2} {n : Nat} {s₁ s₂ : zB} + (hn : n ≥ 1) (hs : s₁ = ((([a, b, c, d, e, f] : zF) ^ (n - 1)) +> s₂)) : + (a ::ᵇ (b ::ᵇ (c ::ᵇ (d ::ᵇ (e ::ᵇ (f ::ᵇ s₁)))))) = ((([a, b, c, d, e, f] : zF) ^ n) + +> s₂) := by + have h1 : n = 1 + (n - 1) := by omega + rw [h1, ← fold6, hs] + +theorem pow6_succ_right {a b c d e f : Fin 2} {n : Nat} {s₁ s₂ : zB} + (hn : n ≥ 1) (hs : ((([a, b, c, d, e, f] : zF) ^ (n - 1)) +> s₁) = s₂) : + ((([a, b, c, d, e, f] : zF) ^ n) +> s₁) + = (a ::ᵇ (b ::ᵇ (c ::ᵇ (d ::ᵇ (e ::ᵇ (f ::ᵇ s₂)))))) := by + have h1 : n = 1 + (n - 1) := by omega + rw [h1, ← fold6, hs] + +theorem pow_split_left {w : zF} {n₁ n₂ : Nat} {s₁ s₂ : zB} + (h : n₁ > n₂) (hs : ((w ^ (n₁ - n₂)) +> s₁) = s₂) : + ((w ^ n₁) +> s₁) = ((w ^ n₂) +> s₂) := by + have hn : n₁ = n₂ + (n₁ - n₂) := by omega + rw [hn, ← pow_merge, hs] + +theorem pow_split_right {w : zF} {n₁ n₂ : Nat} {s₁ s₂ : zB} + (h : n₂ > n₁) (hs : s₁ = ((w ^ (n₂ - n₁)) +> s₂)) : + ((w ^ n₁) +> s₁) = ((w ^ n₂) +> s₂) := by + have hn : n₂ = n₁ + (n₂ - n₁) := by omega + rw [hn, ← pow_merge, hs] + +macro "spine_step" : tactic => + `(tactic| first + | rfl + | apply cons_congr + | apply same_pow_congr (by omega) + | apply same_word_congr + | apply pow_zero_left (by omega) + | apply pow_zero_right (by omega) + | apply pow2_succ_left (by omega) + | apply pow2_succ_right (by omega) + | apply pow3_succ_left (by omega) + | apply pow3_succ_right (by omega) + | apply pow6_succ_left (by omega) + | apply pow6_succ_right (by omega) + | apply pow_split_left (by omega) + | apply pow_split_right (by omega)) + +macro "solve_spine" : tactic => + `(tactic| repeat' spine_step) + +macro "solve_cfg_spine" : tactic => + `(tactic| (first + | rfl + | apply app2_congr (by omega) (by omega) + | (apply app3_congr ?_ (by omega) (by omega); solve_spine; done) + | ((first | apply cfg_left_congr | apply cfg_right_congr) <;> (solve_spine; done)))) + +macro "cfg_eq" : tactic => + `(tactic| first + | rfl + | (try dsimp only [Sim.toCfg, special, specialN, flow_tail, short_suffix, negativeN, loneN, + S, rootW, crossW, crossZ, rootZ, crossV, rootV, seed, final_scan, scan_root, + rootT, scan_left, scanW, section_481, section_side, w10, w110] + try simp only + [Nat.add_assoc, Nat.add_zero, Nat.zero_add, Nat.add_mul, Nat.mul_add, Nat.one_mul, + Nat.mul_one, Nat.mul_zero, Nat.zero_mul, + list_pow_zero, list_pow_succ, list_pow_one, + pow_add_1, pow_add_2, pow_add_3, pow_add_4, pow_add_5, + pow_add_right_2, pow_add_right_3, pow_add_right_4, pow_add_right_5, + pow_double3, + List.nil_append, List.cons_append, List.append_assoc, + listblank_append_nil, listblank_append_cons, listblank_append_right_assoc, + shift2, shift3, shift6, + shift2_0, shift3_0_1, shift3_0_01, shift6_0_1, shift6_0_01, + pow_merge, ListBlank.cons_zero_default] + try ac_rfl + done) + | (try dsimp only [Sim.toCfg, special, specialN, flow_tail, short_suffix, negativeN, loneN, + S, rootW, crossW, crossZ, rootZ, crossV, rootV, seed, final_scan, scan_root, + rootT, scan_left, scanW, section_481, section_side, w10, w110] + try simp only [Nat.mul_zero, Nat.zero_mul, + List.nil_append, List.cons_append, List.append_assoc, + listblank_append_nil, listblank_append_cons, listblank_append_right_assoc, + list_pow_zero, + pow_double3, pow_merge, fold2, fold3, fold6, ListBlank.cons_zero_default] + first | done | (solve_cfg_spine; done)) + | (try dsimp only [Sim.toCfg, special, specialN, flow_tail, short_suffix, negativeN, loneN, + S, rootW, crossW, crossZ, rootZ, crossV, rootV, seed, final_scan, scan_root, + rootT, scan_left, scanW, section_481, section_side, w10, w110] + try simp only + [Nat.add_assoc, Nat.add_zero, Nat.zero_add, Nat.add_mul, Nat.mul_add, Nat.one_mul, + Nat.mul_one, Nat.mul_zero, Nat.zero_mul, + list_pow_zero, list_pow_succ, + pow_add_1, pow_add_2, pow_add_3, pow_add_4, pow_add_5, + pow_add_right_2, pow_add_right_3, pow_add_right_4, pow_add_right_5, + pow_double3, + List.nil_append, List.cons_append, List.append_assoc, + listblank_append_nil, listblank_append_cons, listblank_append_right_assoc, + shift2, shift3, shift6, + shift2_0, shift3_0_1, shift3_0_01, shift6_0_1, shift6_0_01, + pow_merge, ListBlank.cons_zero_default] + try simp only [fold2, fold3, fold6, pow_merge, ListBlank.cons_zero_default] + first | done | (solve_cfg_spine; done))) + +theorem step_eq {c₁ c₂ : Cfg (Fin 2) (Fin 6)} (h : c₁ = c₂) : c₁ [target_tm]⊢* c₂ := by + rw [h] + +theorem evstep_progress {c₁ c₂ : Cfg (Fin 2) (Fin 6)} (h : c₁ [target_tm]⊢* c₂) (hne : c₁ ≠ c₂) : + c₁ [target_tm]⊢⁺ c₂ := by + rcases h with ⟨_ | n, hn⟩ + · cases hn; contradiction + · exact ⟨n + 1, by omega, hn⟩ + +theorem evstep_progress_trans {c₁ c₂ c₃ : Cfg (Fin 2) (Fin 6)} + (h₁ : c₁ [target_tm]⊢* c₂) (h₂ : c₂ [target_tm]⊢⁺ c₃) : c₁ [target_tm]⊢⁺ c₃ := + ReachesStar.trans_plus h₁ h₂ + +theorem progress_evstep_trans {c₁ c₂ c₃ : Cfg (Fin 2) (Fin 6)} + (h₁ : c₁ [target_tm]⊢⁺ c₂) (h₂ : c₂ [target_tm]⊢* c₃) : c₁ [target_tm]⊢⁺ c₃ := + ReachesPlus.trans_star h₁ h₂ + +theorem progress_trans {c₁ c₂ c₃ : Cfg (Fin 2) (Fin 6)} + (h₁ : c₁ [target_tm]⊢⁺ c₂) (h₂ : c₂ [target_tm]⊢⁺ c₃) : c₁ [target_tm]⊢⁺ c₃ := + ReachesPlus.trans h₁ h₂ + +theorem step_end_plus_eq {c₁ c₁' c₂ c₂' : Cfg (Fin 2) (Fin 6)} + (h : c₁' [target_tm]⊢⁺ c₂') (heq₁ : c₁ = c₁') (heq₂ : c₂' = c₂) : + c₁ [target_tm]⊢⁺ c₂ := by + rw [heq₁, ← heq₂]; exact h + +theorem S_ne_section (l r : zB) (a b c d : Nat) (xs : List Nat) : + S l r (1 + a) b c d ≠ section_481 xs := by + intro h + rw [S, pow_add_1, List.cons_append, listblank_append_cons, section_481] at h + have ht := congrArg (fun x => x.tape.head) h + simp at ht + +macro "ne_cfg" : tactic => + `(tactic| first + | apply S_ne_section + | (intro h; have hq := congrArg Cfg.q h; dsimp + [final_scan, rootW, crossW, rootZ, crossZ, rootV, crossV, seed, section_481, S] at hq; + revert hq; decide)) + +theorem Incs1 (l r : zB) (a b c d n : Nat) : + (S l r (n * 2 + a) b c (n * 2 + d)) [target_tm]⊢* (S l r a (n + b) (n * 2 + c) d) := by + induction n generalizing a b c d with + | zero => exact step_eq (by cfg_eq) + | succ n ih => + refine step_bridge (Inc1 l r (n * 2 + a) b c (n * 2 + d)) (by cfg_eq) ?_ + exact step_end (ih a (1 + b) (2 + c) d) (by cfg_eq) (by cfg_eq) + +theorem P_S (b : Nat) (HP : P (1 + b * 2)) : P ((1 + b * 2) + (3 + b * 2)) := by + intro l + refine step_bridge (HP ((([1, 0] : zF) ^ (3 + b * 2)) +> l)) (by cfg_eq) ?_ + refine step_bridge (P_S_1 l b) (by cfg_eq) ?_ + refine step_bridge (Incs1 l default 2 1 0 0 b) (by cfg_eq) ?_ + refine step_bridge (P_S_2 l b) (by cfg_eq) ?_ + refine step_bridge (HP ((([1, 1, 0] : zF) ^ (3 + b * 2)) +> l)) (by cfg_eq) ?_ + exact step_end (close_odd l (1 + b) (1 + b * 2)) (by cfg_eq) (by cfg_eq) + +theorem P_S' (b : Nat) (HP : P (2 + b * 2)) : P ((2 + b * 2) + (5 + b * 2)) := by + intro l + refine step_bridge (HP ((([1, 0] : zF) ^ (5 + b * 2)) +> l)) (by cfg_eq) ?_ + refine step_bridge (P_S'_1 l b) (by cfg_eq) ?_ + refine step_bridge (Incs1 l default 4 1 0 1 b) (by cfg_eq) ?_ + refine step_bridge (P_S'_2 l b) (by cfg_eq) ?_ + refine step_bridge (HP ((([1, 1, 0] : zF) ^ (5 + b * 2)) +> l)) (by cfg_eq) ?_ + exact step_end (close_odd l (2 + b) (2 + b * 2)) (by cfg_eq) (by cfg_eq) + +theorem return_odd (l : zB) (b d : Nat) (HP : P (1 + b * 2 + d)) : + ((((([1, 0] : zF) ^ ((1 + b * 2 + d) + (1 + b * 2))) +> l) {{B}}> default)) [target_tm]⊢* + (l <{{B}} (([1] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (1 + b)) +> ((([1, 0] : zF) ^ (b * 2)) + +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ d) +> default)))))) := by + refine step_bridge (HP ((([1, 0] : zF) ^ (1 + b * 2)) +> l)) (by cfg_eq) ?_ + refine step_bridge (return_odd_1 l b d) (by cfg_eq) ?_ + exact step_end (Incs1 l default 0 1 0 d b) (by cfg_eq) (by cfg_eq) + +theorem return_even (l : zB) (b d : Nat) (HP : P (2 + b * 2 + d)) : + ((((([1, 0] : zF) ^ ((2 + b * 2 + d) + (2 + b * 2))) +> l) {{B}}> default)) [target_tm]⊢* + (l <{{C}} (([0, 1, 0, 1] : zF) +> ((([0, 0, 1, 1, 0, 1] : zF) ^ (1 + b)) +> ((([0, 1] : zF) + ^ (1 + b * 2)) +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ d) +> default)))))) := by + refine step_bridge (HP ((([1, 0] : zF) ^ (2 + b * 2)) +> l)) (by cfg_eq) ?_ + refine step_bridge (return_even_1 l b d) (by cfg_eq) ?_ + refine step_bridge (Incs1 l default 1 1 0 (1 + d) b) (by cfg_eq) ?_ + exact step_end (edge1 l (([0] : zF) +> ((([1, 0, 0] : zF) ^ d) +> default)) (1 + b) (b * 2)) + (by cfg_eq) (by cfg_eq) + +theorem return_last (l : zB) (b : Nat) (HP : P (2 + b * 2)) : + ((((([1, 0] : zF) ^ ((2 + b * 2) + (3 + b * 2))) +> l) {{B}}> default)) [target_tm]⊢* + (l <{{B}} (([1] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (2 + b)) +> ((([1, 0] : zF) + ^ (1 + b * 2)) +> default)))) := by + refine step_bridge (HP ((([1, 0] : zF) ^ (3 + b * 2)) +> l)) (by cfg_eq) ?_ + refine step_bridge (return_last_1 l b) (by cfg_eq) ?_ + refine step_bridge (Incs1 l default 2 1 0 1 b) (by cfg_eq) ?_ + exact step_end (edge2 l default (1 + b) (b * 2)) (by cfg_eq) (by cfg_eq) + +theorem pred_odd (b : Nat) (HP : P (1 + b * 2)) : PP ((1 + b * 2) + (2 + b * 2)) := by + intro l + refine step_bridge (HP ((([1, 0] : zF) ^ (2 + b * 2)) +> l)) (by cfg_eq) ?_ + refine step_bridge (pred_odd_1 l b) (by cfg_eq) ?_ + refine step_bridge (Incs1 l default 1 1 0 0 b) (by cfg_eq) ?_ + refine step_bridge (pred_odd_2 l b) (by cfg_eq) ?_ + refine step_bridge (HP ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> (([1] : zF) +> l))) (by cfg_eq) ?_ + exact step_end (close l (1 + b) (1 + b * 2)) (by cfg_eq) (by cfg_eq) + +theorem pred_even (b : Nat) (HP : P (2 + b * 2)) : PP ((2 + b * 2) + (4 + b * 2)) := by + intro l + refine step_bridge (HP ((([1, 0] : zF) ^ (4 + b * 2)) +> l)) (by cfg_eq) ?_ + refine step_bridge (pred_even_1 l b) (by cfg_eq) ?_ + refine step_bridge (Incs1 l default 3 1 0 1 b) (by cfg_eq) ?_ + refine step_bridge (pred_even_2 l b) (by cfg_eq) ?_ + refine step_bridge (HP ((([1, 1, 0] : zF) ^ (4 + b * 2)) +> (([1] : zF) +> l))) (by cfg_eq) ?_ + exact step_end (close l (2 + b) (2 + b * 2)) (by cfg_eq) (by cfg_eq) + +def Word (w x y : zF) : Prop := + w ++ [1, 0] = [1, 0] ++ x ∧ + (∀ l r : zB, (l {{B}}> (x +> r)) [target_tm]⊢* ((y.reverse +> l) {{B}}> r)) ∧ + (∀ l r : zB, ((y.reverse +> l) <{{A}} r) [target_tm]⊢* (l <{{A}} (w +> r))) + +theorem Word_nil : Word [] [] [] := + ⟨rfl, fun _ _ => ReachesStar.refl target_tm _, fun _ _ => ReachesStar.refl target_tm _⟩ + +theorem Word_U : Word [1, 0] [1, 0] [0, 1] := + ⟨rfl, Word_U_1, Word_U_2⟩ + +theorem Word_V : Word [1, 0, 1, 0, 0, 1] [1, 0, 0, 1, 1, 0] [0, 1, 1, 0, 1, 1] := + ⟨rfl, Word_V_1, Word_V_2⟩ + +theorem Word_app (w1 x1 y1 w2 x2 y2 : zF) (h1 : Word w1 x1 y1) (h2 : Word w2 x2 y2) : + Word (w1 ++ w2) (x1 ++ x2) (y1 ++ y2) := by + rcases h1 with ⟨e1, r1, l1⟩ + rcases h2 with ⟨e2, r2, l2⟩ + refine ⟨?_, ?_, ?_⟩ + · rw [List.append_assoc, e2, ← List.append_assoc, e1, List.append_assoc] + · intro l r + rw [List.reverse_append, listblank_append_right_assoc, listblank_append_right_assoc] + exact ReachesStar.trans (r1 l (x2 +> r)) (r2 (y1.reverse +> l) r) + · intro l r + rw [List.reverse_append, listblank_append_right_assoc, listblank_append_right_assoc] + exact ReachesStar.trans (l2 (y1.reverse +> l) r) (l1 l (w2 +> r)) + +theorem Word_pow (w x y : zF) (n : Nat) (h : Word w x y) : Word (w ^ n) (x ^ n) (y ^ n) := by + induction n with + | zero => exact Word_nil + | succ n ih => exact Word_app w x y (w ^ n) (x ^ n) (y ^ n) h ih + +theorem word_shift {w x : zF} (h : w ++ [1, 0] = [1, 0] ++ x) (s : zB) : + w +> (([1, 0] : zF) +> s) = ([1, 0] : zF) +> (x +> s) := by + rw [← listblank_append_right_assoc, h, listblank_append_right_assoc] + +theorem rootW_step (r : zB) (a : Nat) (w x y : zF) (c d : Nat) (hw : Word w x y) : + (rootW r a w c (2 + d)) [target_tm]⊢* (rootW r (2 + a) w (2 + c) d) := by + rcases hw with ⟨e, hr, hl⟩ + refine ReachesStar.trans (rootW_step_1 r a w c d) ?_ + have hws := word_shift e (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ c) +> (([0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ d) +> r)))) + refine step_bridge (Word_U_1 _ _) (by rw [← hws]; rfl) ?_ + refine ReachesStar.trans (hr _ _) ?_ + refine step_bridge (rootW_step_3 _ r c d) (by cfg_eq) ?_ + refine ReachesStar.trans (hl _ _) ?_ + exact step_end (rootW_step_4 r a w c d) (by cfg_eq) (by cfg_eq) + +theorem crossW_step (l r : zB) (a : Nat) (w x y : zF) (c d : Nat) (hw : Word w x y) : + (crossW l r (2 + a) w c (2 + d)) [target_tm]⊢* (crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ++ w) + (2 + c) d) := by + rcases hw with ⟨e, hr, hl⟩ + refine ReachesStar.trans (crossW_step_1 l r a w c d) ?_ + have hws := word_shift e (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ c) +> (([0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ d) +> r)))) + refine step_bridge (crossW_step_2 _ _) (by rw [← hws]; rfl) ?_ + refine ReachesStar.trans (hr _ _) ?_ + refine step_bridge (rootW_step_3 _ r c d) (by cfg_eq) ?_ + refine ReachesStar.trans (hl _ _) ?_ + exact step_end (crossW_step_4 l r a w c d) (by cfg_eq) (by cfg_eq) + +theorem rootsW (r : zB) (a : Nat) (w x y : zF) (c d n : Nat) (hw : Word w x y) : + (rootW r a w c (n * 2 + d)) [target_tm]⊢* (rootW r (n * 2 + a) w (n * 2 + c) d) := by + induction n generalizing a c d with + | zero => exact step_eq (by cfg_eq) + | succ n ih => + refine step_bridge (rootW_step r a w x y c (n * 2 + d) hw) (by cfg_eq) ?_ + exact step_end (ih (2 + a) (2 + c) d) (by cfg_eq) (by cfg_eq) + +theorem crossesZ (l r : zB) (a b c e n : Nat) : + (crossZ l r (n * 4 + a) b (3 + c) (n * 2 + e)) [target_tm]⊢* (crossZ l r a (n * 2 + b) (3 + c) + e) := by + induction n generalizing a b c e with + | zero => exact step_eq (by cfg_eq) + | succ n ih => + refine step_bridge (crossZ_step l r (n * 4 + a) b c (n * 2 + e)) (by cfg_eq) ?_ + exact step_end (ih a (2 + b) c e) (by cfg_eq) (by cfg_eq) + +theorem crossesV (l r : zB) (a b c e n : Nat) : + (crossV l r (n * 4 + a) b (3 + c) (n + e)) [target_tm]⊢* (crossV l r a (n * 2 + b) (3 + (n + c)) + e) := by + induction n generalizing a b c e with + | zero => exact step_eq (by cfg_eq) + | succ n ih => + refine step_bridge (crossV_step l r (n * 4 + a) b c (n + e)) (by cfg_eq) ?_ + exact step_end (ih a (2 + b) (1 + c) e) (by cfg_eq) (by cfg_eq) + +theorem normal_odd_root (a d : Nat) : + ((((([1, 0] : zF) ^ (3 + a * 2)) +> default) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (3 + a * 2 + d * 2)) +> default)))) [target_tm]⊢* + (rootW default 2 (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + a)) (1 + a * 2) (1 + d * 2)) := by + refine step_bridge (normal_odd_root_1 a d) (by cfg_eq) ?_ + refine step_bridge (Incs1 default default 2 1 0 (2 + d * 2) a) (by cfg_eq) ?_ + refine step_bridge (Inc1 default default 0 (a + 1) (a * 2) (d * 2)) (by cfg_eq) ?_ + exact step_end (normal_odd_root_2 a d) (by cfg_eq) (by cfg_eq) + +theorem normal_odd (a d : Nat) : + ((((([1, 0] : zF) ^ (3 + a * 2)) +> default) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (3 + a * 2 + d * 2)) +> default)))) [target_tm]⊢* + ((((([1, 0] : zF) ^ (3 + d * 2 + a * 2)) +> ((([1, 1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 0] : zF) + ^ (5 + d * 2)) +> default))) {{B}}> default)) := by + refine ReachesStar.trans (normal_odd_root a d) ?_ + refine step_bridge (rootsW default 2 _ _ _ (1 + a * 2) 1 d (Word_pow _ _ _ (1 + a) Word_V)) + (by cfg_eq) ?_ + exact step_end (root_end1 (d * 2 + 2) a (d * 2 + (1 + a * 2))) (by cfg_eq) (by cfg_eq) + +theorem normal_even_root (a d : Nat) : + ((((([1, 0] : zF) ^ (3 + a * 2)) +> default) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (2 + a * 2 + d * 2)) +> default)))) [target_tm]⊢* + (rootW default 2 (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + a)) (1 + a * 2) (d * 2)) := by + refine step_bridge (normal_even_root_1 a d) (by cfg_eq) ?_ + refine step_bridge (Incs1 default default 2 1 0 (1 + d * 2) a) (by cfg_eq) ?_ + rcases d with _ | d + · exact step_end (normal_even_root_2_d0 a) (by cfg_eq) (by cfg_eq) + · exact step_end (normal_even_root_2_dS a d) (by cfg_eq) (by cfg_eq) + +theorem normal_even (a d : Nat) : + ((((([1, 0] : zF) ^ (3 + a * 2)) +> default) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (2 + a * 2 + d * 2)) +> default)))) [target_tm]⊢* + ((((([1, 0] : zF) ^ (2 + d * 2 + a * 2)) +> ((([1, 1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 0] : zF) + ^ (5 + d * 2)) +> default))) {{B}}> default)) := by + refine ReachesStar.trans (normal_even_root a d) ?_ + refine step_bridge (rootsW default 2 _ _ _ (1 + a * 2) 0 d (Word_pow _ _ _ (1 + a) Word_V)) + (by cfg_eq) ?_ + exact step_end (root_end0 (d * 2 + 2) a (d * 2 + (1 + a * 2))) (by cfg_eq) (by cfg_eq) + +theorem even_left_even (a d : Nat) : + ((((([1, 0] : zF) ^ (2 + a * 2)) +> default) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (2 + a * 2 + d * 2)) +> default)))) [target_tm]⊢* + ((((([1, 0] : zF) ^ (2 + a * 2 + d * 2)) +> ((([1, 1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 0] : zF) + ^ (3 + d * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (even_left_even_1 a d) (by cfg_eq) ?_ + refine step_bridge (Incs1 default default 1 1 0 (1 + d * 2) a) (by cfg_eq) ?_ + refine step_bridge (even_root a (d * 2)) (by cfg_eq) ?_ + refine step_bridge (rootsW default 0 _ _ _ (1 + a * 2) 0 d (Word_pow _ _ _ (1 + a) Word_V)) + (by cfg_eq) ?_ + exact step_end (root_end0 (d * 2) a (d * 2 + (1 + a * 2))) (by cfg_eq) (by cfg_eq) + +theorem even_left_odd (a d : Nat) : + ((((([1, 0] : zF) ^ (2 + a * 2)) +> default) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (1 + a * 2 + d * 2)) +> default)))) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + a * 2 + d * 2)) +> ((([1, 1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 0] : zF) + ^ (1 + d * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (even_left_odd_1 default a (d * 2)) (by cfg_eq) ?_ + refine step_bridge (Incs1 default default 1 1 0 (d * 2) a) (by cfg_eq) ?_ + rcases d with _ | d + · exact step_end (even_end a) (by cfg_eq) (by cfg_eq) + · refine step_bridge (even_root a (1 + d * 2)) (by cfg_eq) ?_ + refine step_bridge (rootsW default 0 _ _ _ (1 + a * 2) 1 d (Word_pow _ _ _ (1 + a) Word_V)) + (by cfg_eq) ?_ + exact step_end (root_end1 (d * 2) a (d * 2 + (1 + a * 2))) (by cfg_eq) (by cfg_eq) + +theorem left_overflow_odd (l : zB) (a d : Nat) : + ((((([1, 0] : zF) ^ (3 + d * 2 + a)) +> l) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (1 + d * 2)) +> default)))) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + d * 2)) +> ((([1, 1, 0] : zF) ^ (3 + d * 2)) +> ((([1, 0] : zF) ^ a) + +> l))) {{B}}> default)) := by + refine step_bridge (left_overflow_odd_1 l a d) (by cfg_eq) ?_ + refine step_bridge (Incs1 l default (2 + a) 1 0 0 d) (by cfg_eq) ?_ + exact step_end (S_exit0 l a d (d * 2)) (by cfg_eq) (by cfg_eq) + +theorem left_overflow_even (l : zB) (a d : Nat) : + ((((([1, 0] : zF) ^ (5 + d * 2 + a)) +> l) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (2 + d * 2)) +> default)))) [target_tm]⊢* + ((((([1, 0] : zF) ^ (2 + d * 2)) +> ((([1, 1, 0] : zF) ^ (5 + d * 2)) +> ((([1, 0] : zF) ^ a) + +> l))) {{B}}> default)) := by + refine step_bridge (left_overflow_even_1 l a d) (by cfg_eq) ?_ + refine step_bridge (Incs1 l default (4 + a) 1 0 1 d) (by cfg_eq) ?_ + exact step_end (S_exit1 l a d (d * 2)) (by cfg_eq) (by cfg_eq) + +theorem seed_odd (a b c d : Nat) : + (seed a b c (1 + d * 2)) [target_tm]⊢* + ((((([1, 0] : zF) ^ (2 + c * 2 + d * 2)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> ((([1, 0] : zF) + ^ (4 + a + d * 2)) +> default))) {{B}}> default)) := by + refine ReachesStar.trans (seed_root a b c (d * 2)) ?_ + refine step_bridge (rootsW default (1 + a) _ _ _ (1 + c * 2) 0 d (Word_pow _ _ _ (1 + b) Word_V)) + (by cfg_eq) ?_ + exact step_end (root_end0 (d * 2 + (1 + a)) b (d * 2 + (1 + c * 2))) (by cfg_eq) (by cfg_eq) + +theorem seed_even (a b c d : Nat) : + (seed a b c (2 + d * 2)) [target_tm]⊢* + ((((([1, 0] : zF) ^ (3 + c * 2 + d * 2)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> ((([1, 0] : zF) + ^ (4 + a + d * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (seed_root a b c (1 + d * 2)) (by cfg_eq) ?_ + refine step_bridge (rootsW default (1 + a) _ _ _ (1 + c * 2) 1 d (Word_pow _ _ _ (1 + b) Word_V)) + (by cfg_eq) ?_ + exact step_end (root_end1 (d * 2 + (1 + a)) b (d * 2 + (1 + c * 2))) (by cfg_eq) (by cfg_eq) + +theorem border (l : zB) (a : Nat) : + ((((([1, 0] : zF) ^ (2 + a * 2)) +> l) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (1 + a * 2)) +> default)))) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + a * 2)) +> ((([1, 1, 0] : zF) ^ (2 + a * 2)) +> (([1] : zF) +> l))) + {{B}}> default)) := by + refine step_bridge (even_left_odd_1 l a 0) (by cfg_eq) ?_ + refine step_bridge (Incs1 l default 1 1 0 0 a) (by cfg_eq) ?_ + exact step_end (even_exit l a) (by cfg_eq) (by cfg_eq) + +theorem bridge4 (l r : zB) (a b c : Nat) : + (S l (special r) (4 + a) (1 + b) (2 + c) 0) [target_tm]⊢* (crossZ l r a (2 + b) (5 + c) 2) := by + refine step_bridge (crossW_step l (([0, 1, 1, 0, 1, 0, 1, 0] : zF) +> r) (2 + a) _ _ _ (1 + c) + 0 (Word_pow _ _ _ b Word_V)) (by cfg_eq) ?_ + exact step_end (cross_to_Z l r a (1 + b) c) (by cfg_eq) (by cfg_eq) + +theorem bridge8 (l r : zB) (a b c d : Nat) : + (S l (special ((([1, 0, 0] : zF) ^ d) +> r)) (8 + a) (1 + b) (2 + c) 0) + [target_tm]⊢* (S l r a (5 + b) (3 + c) d) := by + refine step_bridge (bridge4 l ((([1, 0, 0] : zF) ^ d) +> r) (4 + a) b c) (by cfg_eq) ?_ + exact step_end (crossZ_step l ((([1, 0, 0] : zF) ^ d) +> r) a (2 + b) (2 + c) 0) (by cfg_eq) + (by cfg_eq) + +theorem S_even_block (l r : zB) (b c d e : Nat) : + (S ((([1, 1, 0] : zF) ^ (e * 2)) +> l) r 0 b c d) [target_tm]⊢* (S l r 0 (e + b) c d) := by + exact step_end (even_block l ((([0, 1, 1, 0, 1, 0] : zF) ^ b) +> ((([1, 0] : zF) ^ c) + +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ d) +> r)))) e) (by cfg_eq) (by cfg_eq) + +theorem bridgeV (l r : zB) (a b c n : Nat) : + (S l (specialN (1 + n) r) (4 + a) (1 + b) (2 + c) 0) [target_tm]⊢* + (crossV l ((([1, 0] : zF) ^ (5 + n * 2)) +> r) a (2 + b) (5 + c) n) := by + refine step_bridge (crossW_step l (([0, 1, 1] : zF) +> ((([0, 1, 0, 0, 1, 1] : zF) ^ (1 + n)) + +> ((([0, 1] : zF) ^ (4 + n * 2)) +> (([0] : zF) +> r)))) (2 + a) _ _ _ (1 + c) + 0 (Word_pow _ _ _ b Word_V)) (by cfg_eq) ?_ + exact step_end (cross_to_V l r a (1 + b) c n) (by cfg_eq) (by cfg_eq) + +theorem bridges (l r : zB) (a b c d n : Nat) : + (S l (specialN n ((([1, 0, 0] : zF) ^ d) +> r)) (8 + n * 8 + a) (1 + b) (2 + c) 0) [target_tm]⊢* + (S l r a (5 + n * 4 + b) (3 + n + c) d) := by + rcases n with _ | n + · exact step_end (bridge8 l r a b c d) (by cfg_eq) (by cfg_eq) + · refine step_bridge (bridgeV l ((([1, 0, 0] : zF) ^ d) +> r) (12 + n * 8 + a) b c n) (by cfg_eq) + ?_ + refine step_bridge (crossesV l ((([1, 0] : zF) ^ (5 + n * 2)) +> ((([1, 0, 0] : zF) ^ d) +> r)) + (12 + n * 4 + a) (2 + b) (2 + c) 0 n) (by cfg_eq) ?_ + refine step_bridge (crossV_end l ((([1, 0, 0] : zF) ^ d) +> r) (8 + n * 4 + a) (2 + n * 2 + b) + (2 + n + c) (4 + n * 2)) (by cfg_eq) ?_ + exact step_end (crossesZ l ((([1, 0, 0] : zF) ^ d) +> r) a (4 + n * 2 + b) (3 + n + c) + 0 (2 + n)) (by cfg_eq) (by cfg_eq) + +theorem negativeN_first_odd (l : zB) (a n d : Nat) (HP : P (3 + a * 2)) : + ((((([1, 0] : zF) ^ (3 + a * 2)) +> ((([1, 1, 0] : zF) ^ (2 + n * 2)) +> ((([1, 0] : zF) + ^ (8 + a * 2 + n * 2 + d * 2)) +> l))) {{B}}> default)) [target_tm]⊢* + (negativeN l (3 + a * 2) n d 0) := by + refine step_bridge (HP ((([1, 1, 0] : zF) ^ (2 + n * 2)) +> ((([1, 0] : zF) + ^ (8 + a * 2 + n * 2 + d * 2)) +> l))) (by cfg_eq) ?_ + refine step_bridge (pass_011 ((([1, 0] : zF) ^ (8 + a * 2 + n * 2 + d * 2)) +> l) + ((([0, 1, 0] : zF) ^ (3 + a * 2)) +> default) (2 + n * 2)) (by cfg_eq) ?_ + exact step_end (left_overflow_odd l (1 + d * 2) (2 + a + n)) (by cfg_eq) (by cfg_eq) + +theorem negativeN_first_even (l : zB) (a n d : Nat) (HP : P (2 + a * 2)) : + ((((([1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 1, 0] : zF) ^ (2 + n * 2)) +> ((([1, 0] : zF) + ^ (8 + a * 2 + n * 2 + d * 2)) +> l))) {{B}}> default)) [target_tm]⊢* + (negativeN l (2 + a * 2) n d 1) := by + refine step_bridge (HP ((([1, 1, 0] : zF) ^ (2 + n * 2)) +> ((([1, 0] : zF) + ^ (8 + a * 2 + n * 2 + d * 2)) +> l))) (by cfg_eq) ?_ + refine step_bridge (pass_011 ((([1, 0] : zF) ^ (8 + a * 2 + n * 2 + d * 2)) +> l) + ((([0, 1, 0] : zF) ^ (2 + a * 2)) +> default) (2 + n * 2)) (by cfg_eq) ?_ + exact step_end (left_overflow_even l (1 + d * 2) (1 + a + n)) (by cfg_eq) (by cfg_eq) + +theorem negativeN_entry (l : zB) (p n d e d0 : Nat) (HP : P p) (E : p = 2 + n * 2 + d0) : + (negativeN l p n d e) [target_tm]⊢* + (S l (specialN n ((([1, 0, 0] : zF) ^ d0) +> default)) (d * 2) 1 0 (p + 3 + n * 2 + e)) := by + have HP' : P (2 + n * 2 + d0) := E ▸ HP + refine step_bridge (return_even ((([1, 1, 0] : zF) ^ (p + 4 + n * 2 + e)) +> ((([1, 0] : zF) + ^ (1 + d * 2)) +> l)) n d0 HP') (by cfg_eq) ?_ + refine step_bridge (pass_011 ((([1, 0] : zF) ^ (1 + d * 2)) +> l) (([0, 1] : zF) + +> ((([0, 0, 1, 1, 0, 1] : zF) ^ (1 + n)) +> ((([0, 1] : zF) ^ (1 + n * 2)) +> (([0] : zF) + +> ((([1, 0, 0] : zF) ^ d0) +> default))))) (p + 4 + n * 2 + e)) (by cfg_eq) ?_ + exact step_end (into_S l ((([0, 0, 1, 1, 0, 1] : zF) ^ (1 + n)) +> ((([0, 1] : zF) ^ (1 + n * 2)) + +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ d0) +> default)))) (d * 2) (p + 3 + n * 2 + e)) + (by cfg_eq) (by cfg_eq) + +theorem negativeN_cross (p n d e d0 b j a : Nat) (HP : P p) (E1 : p = 2 + n * 2 + d0) + (E2 : p + 3 + n * 2 + e = d * 2 + j * 2) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ (j * 2 + 8 + n * 8 + a)) + +> default)) p n d e) [target_tm]⊢* + (S default default a (5 + n * 4 + b + d + j) (1 + n + d * 2 + j * 2) d0) := by + refine step_bridge (negativeN_entry ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) + ^ (j * 2 + 8 + n * 8 + a)) +> default)) p n d e d0 HP E1) (by cfg_eq) ?_ + refine step_bridge (Incs1 ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) + ^ (j * 2 + 8 + n * 8 + a)) +> default)) (specialN n ((([1, 0, 0] : zF) ^ d0) +> default)) + 0 1 0 (j * 2) d) (by cfg_eq) ?_ + refine step_bridge (S_even_block ((([1, 0] : zF) ^ (j * 2 + 8 + n * 8 + a)) +> default) + (specialN n ((([1, 0, 0] : zF) ^ d0) +> default)) (1 + d) (d * 2) (j * 2) b) (by cfg_eq) ?_ + refine step_bridge (Incs1 default (specialN n ((([1, 0, 0] : zF) ^ d0) +> default)) + (8 + n * 8 + a) (b + (1 + d)) (d * 2) 0 j) (by cfg_eq) ?_ + exact step_end (bridges default default a (b + d + j) (d * 2 + j * 2 - 2) d0 n) (by cfg_eq) + (by cfg_eq) + +theorem negativeN_bounded_odd (a n d b j r u t : Nat) + (HP : P (3 + a * 2)) (E1 : a = n + r) (E2 : a + n + 3 = d + j) (E3 : d * 2 = b + n * 4 + 3 + u) + (E4 : t + b * 2 = 13 + a * 4 + d * 2) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (3 + a * 2) n d 0) + [target_tm]⊢* + ((((([1, 0] : zF) ^ (9 + a * 4 + n)) +> ((([1, 1, 0] : zF) ^ (19 + a * 4 + n * 8 + b * 2)) + +> ((([1, 0] : zF) ^ (1 + u * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (negativeN_cross (3 + a * 2) n d 0 (1 + r * 2) b j (5 + r * 2 + u * 2) HP + (by omega) (by omega)) (by cfg_eq) ?_ + refine step_bridge (Incs1 default default (5 + u * 2) (8 + a + n * 5 + b) (7 + a * 2 + n * 3) 1 r) + (by cfg_eq) ?_ + exact step_end (S_exit1 default (1 + u * 2) (7 + a * 2 + n * 4 + b) (7 + a * 4 + n)) (by cfg_eq) + (by cfg_eq) + +theorem negativeN_bounded_even (a n d b j r u t : Nat) + (HP : P (2 + a * 2)) (E1 : a = n + r) (E2 : a + n + 3 = d + j) (E3 : d * 2 = b + n * 4 + 2 + u) + (E4 : t + b * 2 = 13 + a * 4 + d * 2) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (2 + a * 2) n d 1) + [target_tm]⊢* + ((((([1, 0] : zF) ^ (8 + a * 4 + n)) +> ((([1, 1, 0] : zF) ^ (17 + a * 4 + n * 8 + b * 2)) + +> ((([1, 0] : zF) ^ (1 + u * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (negativeN_cross (2 + a * 2) n d 1 (r * 2) b j (3 + r * 2 + u * 2) HP + (by omega) (by omega)) (by cfg_eq) ?_ + refine step_bridge (Incs1 default default (3 + u * 2) (8 + a + n * 5 + b) (7 + a * 2 + n * 3) 0 r) + (by cfg_eq) ?_ + exact step_end (S_exit0 default (1 + u * 2) (7 + a * 2 + n * 4 + b) (7 + a * 4 + n)) (by cfg_eq) + (by cfg_eq) + +theorem S_root_exit0 (b c v w : Nat) : + (S default default (1 + v * 2) (1 + b) c (1 + v * 2 + w * 2)) [target_tm]⊢* + ((((([1, 0] : zF) ^ (2 + c + v * 2 + w * 2)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2 + v * 2)) + +> ((([1, 0] : zF) ^ (3 + w * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (Incs1 default default 1 (1 + b) c (1 + w * 2) v) (by cfg_eq) ?_ + refine step_bridge (S_root1 (b + v) (c + v * 2) (w * 2)) (by cfg_eq) ?_ + refine step_bridge (rootsW default 0 _ _ _ (1 + (c + v * 2)) 0 w (Word_pow _ _ _ (1 + (b + v)) + Word_V)) (by cfg_eq) ?_ + exact step_end (root_end0 (w * 2) (b + v) (1 + (c + v * 2) + w * 2)) (by cfg_eq) (by cfg_eq) + +theorem S_root_exit1 (b c v w : Nat) : + (S default default (1 + v * 2) (1 + b) c (2 + v * 2 + w * 2)) [target_tm]⊢* + ((((([1, 0] : zF) ^ (3 + c + v * 2 + w * 2)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2 + v * 2)) + +> ((([1, 0] : zF) ^ (3 + w * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (Incs1 default default 1 (1 + b) c (2 + w * 2) v) (by cfg_eq) ?_ + refine step_bridge (S_root1 (b + v) (c + v * 2) (1 + w * 2)) (by cfg_eq) ?_ + refine step_bridge (rootsW default 0 _ _ _ (1 + (c + v * 2)) 1 w (Word_pow _ _ _ (1 + (b + v)) + Word_V)) (by cfg_eq) ?_ + exact step_end (root_end1 (w * 2) (b + v) (1 + (c + v * 2) + w * 2)) (by cfg_eq) (by cfg_eq) + +theorem negativeN_positive_odd (a n d b j u v t : Nat) + (HP : P (3 + a * 2)) (E1 : a = n + u + v) (E2 : a + n + 3 = d + j) + (E3 : b + n * 4 + 1 = d * 2 + u) (E4 : t + b * 2 = 13 + a * 4 + d * 2) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (3 + a * 2) n d 0) + [target_tm]⊢* + ((((([1, 0] : zF) ^ (9 + a * 4 + n)) +> ((([1, 1, 0] : zF) ^ (14 + a * 4 + d * 4)) + +> ((([1, 0] : zF) ^ (3 + u * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (negativeN_cross (3 + a * 2) n d 0 (1 + v * 2 + u * 2) b j (1 + v * 2) HP + (by omega) (by omega)) (by cfg_eq) ?_ + exact step_end (S_root_exit0 (7 + a + n * 5 + b) (7 + a * 2 + n * 3) v u) (by cfg_eq) (by cfg_eq) + +theorem negativeN_positive_even (a n d b j u v t : Nat) + (HP : P (2 + a * 2)) (E1 : a = 1 + n + u + v) (E2 : a + n + 3 = d + j) + (E3 : b + n * 4 = d * 2 + u) (E4 : t + b * 2 = 13 + a * 4 + d * 2) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (2 + a * 2) n d 1) + [target_tm]⊢* + ((((([1, 0] : zF) ^ (8 + a * 4 + n)) +> ((([1, 1, 0] : zF) ^ (14 + a * 4 + d * 4)) + +> ((([1, 0] : zF) ^ (3 + u * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (negativeN_cross (2 + a * 2) n d 1 (2 + v * 2 + u * 2) b j (1 + v * 2) HP + (by omega) (by omega)) (by cfg_eq) ?_ + exact step_end (S_root_exit1 (7 + a + n * 5 + b) (7 + a * 2 + n * 3) v u) (by cfg_eq) (by cfg_eq) + +theorem border_even (l : zB) (a : Nat) : + ((((([1, 0] : zF) ^ (4 + a * 2)) +> l) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (2 + a * 2)) +> default)))) [target_tm]⊢* + ((((([1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 1, 0] : zF) ^ (4 + a * 2)) +> (([1] : zF) +> l))) + {{B}}> default)) := by + refine step_bridge (border_even_1 l a) (by cfg_eq) ?_ + refine step_bridge (Incs1 l default 3 1 0 1 a) (by cfg_eq) ?_ + exact step_end (S_short1 l a (a * 2)) (by cfg_eq) (by cfg_eq) + +theorem loneN_first_odd (l : zB) (a n : Nat) (HP : P (3 + a * 2)) : + ((((([1, 0] : zF) ^ (3 + a * 2)) +> ((([1, 1, 0] : zF) ^ (2 + n * 2)) +> ((([1, 0] : zF) + ^ (6 + a * 2 + n * 2)) +> l))) {{B}}> default)) [target_tm]⊢* + (loneN l (3 + a * 2) n 0) := by + refine step_bridge (HP ((([1, 1, 0] : zF) ^ (2 + n * 2)) +> ((([1, 0] : zF) ^ (6 + a * 2 + n * 2)) + +> l))) (by cfg_eq) ?_ + refine step_bridge (pass_011 ((([1, 0] : zF) ^ (6 + a * 2 + n * 2)) +> l) ((([0, 1, 0] : zF) + ^ (3 + a * 2)) +> default) (2 + n * 2)) (by cfg_eq) ?_ + exact step_end (border l (2 + a + n)) (by cfg_eq) (by cfg_eq) + +theorem loneN_first_even (l : zB) (a n : Nat) (HP : P (2 + a * 2)) : + ((((([1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 1, 0] : zF) ^ (2 + n * 2)) +> ((([1, 0] : zF) + ^ (6 + a * 2 + n * 2)) +> l))) {{B}}> default)) [target_tm]⊢* + (loneN l (2 + a * 2) n 1) := by + refine step_bridge (HP ((([1, 1, 0] : zF) ^ (2 + n * 2)) +> ((([1, 0] : zF) ^ (6 + a * 2 + n * 2)) + +> l))) (by cfg_eq) ?_ + refine step_bridge (pass_011 ((([1, 0] : zF) ^ (6 + a * 2 + n * 2)) +> l) ((([0, 1, 0] : zF) + ^ (2 + a * 2)) +> default) (2 + n * 2)) (by cfg_eq) ?_ + exact step_end (border_even l (1 + a + n)) (by cfg_eq) (by cfg_eq) + +theorem loneN_entry (p n e d0 b t : Nat) (HP : P p) (E : p = 2 + n * 2 + d0) : + (loneN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ (2 + t)) +> default)) p n e) + [target_tm]⊢* + (S default (specialN n ((([1, 0, 0] : zF) ^ d0) +> default)) t (1 + b) + 0 (p + 3 + n * 2 + e)) := by + have HP' : P (2 + n * 2 + d0) := E ▸ HP + refine step_bridge (return_even ((([1, 1, 0] : zF) ^ (p + 3 + n * 2 + e)) +> (([1] : zF) + +> ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ (2 + t)) +> default)))) n d0 HP') + (by cfg_eq) ?_ + refine step_bridge (pass_011 (([1] : zF) +> ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) + ^ (2 + t)) +> default))) (([0, 1] : zF) +> ((([0, 0, 1, 1, 0, 1] : zF) ^ (1 + n)) + +> ((([0, 1] : zF) ^ (1 + n * 2)) +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ d0) + +> default))))) (p + 3 + n * 2 + e)) (by cfg_eq) ?_ + refine step_bridge (lone_one b ((([1, 0] : zF) ^ (1 + t)) +> default) ((([0, 1, 0] : zF) + ^ (p + 3 + n * 2 + e)) +> (([0, 1] : zF) +> ((([0, 0, 1, 1, 0, 1] : zF) ^ (1 + n)) + +> ((([0, 1] : zF) ^ (1 + n * 2)) +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ d0) + +> default))))))) (by cfg_eq) ?_ + exact step_end (lone_S default ((([0, 0, 1, 1, 0, 1] : zF) ^ (1 + n)) +> ((([0, 1] : zF) + ^ (1 + n * 2)) +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ d0) +> default)))) + t b (p + 3 + n * 2 + e)) (by cfg_eq) (by cfg_eq) + +theorem loneN_cross (p n e d0 b h a : Nat) (HP : P p) (E1 : p = 2 + n * 2 + d0) + (E2 : p + 3 + n * 2 + e = h * 2) : + (loneN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ (10 + h * 2 + n * 8 + a)) +> default)) + p n e) [target_tm]⊢* + (S default default a (5 + n * 4 + b + h) (1 + n + h * 2) d0) := by + refine step_bridge (loneN_entry p n e d0 b (8 + h * 2 + n * 8 + a) HP E1) (by cfg_eq) ?_ + refine step_bridge (Incs1 default (specialN n ((([1, 0, 0] : zF) ^ d0) +> default)) + (8 + n * 8 + a) (1 + b) 0 0 h) (by cfg_eq) ?_ + exact step_end (bridges default default a (b + h) (h * 2 - 2) d0 n) (by cfg_eq) (by cfg_eq) + +theorem loneN_odd (a n b v t : Nat) + (HP : P (3 + a * 2)) (E1 : a = 3 + n * 5 + b + v) (E2 : t + b * 2 = 11 + a * 4) : + (loneN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (3 + a * 2) n 0) + [target_tm]⊢* + ((((([1, 0] : zF) ^ (9 + a * 4 + n)) +> ((([1, 1, 0] : zF) ^ (10 + a * 4)) +> ((([1, 0] : zF) + ^ (9 + n * 8 + b * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (loneN_cross (3 + a * 2) n 0 (1 + v * 2 + (3 + n * 4 + b) * 2) b (a + n + 3) + (1 + v * 2) HP (by omega) (by omega)) (by cfg_eq) ?_ + exact step_end (S_root_exit0 (7 + a + n * 5 + b) (7 + a * 2 + n * 3) v (3 + n * 4 + b)) + (by cfg_eq) (by cfg_eq) + +theorem loneN_even (a n b v t : Nat) + (HP : P (2 + a * 2)) (E1 : a = 3 + n * 5 + b + v) (E2 : t + b * 2 = 11 + a * 4) : + (loneN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (2 + a * 2) n 1) + [target_tm]⊢* + ((((([1, 0] : zF) ^ (8 + a * 4 + n)) +> ((([1, 1, 0] : zF) ^ (10 + a * 4)) +> ((([1, 0] : zF) + ^ (7 + n * 8 + b * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (loneN_cross (2 + a * 2) n 1 (2 + v * 2 + (2 + n * 4 + b) * 2) b (a + n + 3) + (1 + v * 2) HP (by omega) (by omega)) (by cfg_eq) ?_ + exact step_end (S_root_exit1 (7 + a + n * 5 + b) (7 + a * 2 + n * 3) v (2 + n * 4 + b)) + (by cfg_eq) (by cfg_eq) + +theorem rootZ_end (r : zB) (a b c d : Nat) : + (rootZ ((([1, 0, 0] : zF) ^ d) +> r) a b (3 + c) 0) [target_tm]⊢* + (rootW (([0] : zF) +> r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (1 + d)) := + step_eq (by cfg_eq) + +structure Flow (C : zB → Nat → Nat → Cfg (Fin 2) (Fin 6)) (R : Nat → Nat → Cfg (Fin 2) (Fin 6)) + (D : zB → Nat → Nat → Cfg (Fin 2) (Fin 6)) (T : Nat → Nat → Cfg (Fin 2) (Fin 6)) + (n : Nat) : Prop where + flow_cross : ∀ l a b, (C l (n * 2 + a) b) [target_tm]⊢* (D l a (n + b)) + flow_root : ∀ a b, (R a b) [target_tm]⊢* (T (n * 2 + a) b) + flow_border : ∀ s v b, s + v + 1 = n → (C default (1 + s * 2) b) [target_tm]⊢* (T (v * 2) + (1 + s + b)) + +theorem Flow_id (C : zB → Nat → Nat → Cfg (Fin 2) (Fin 6)) (R : Nat → Nat → Cfg (Fin 2) (Fin 6)) : + Flow C R C R 0 := by + refine ⟨fun l a b => step_eq (by cfg_eq), fun a b => step_eq (by cfg_eq), fun s v b h => by omega⟩ + +theorem Flow_trans {C R D T F U} {n m : Nat} (h1 : Flow C R D T n) (h2 : Flow D T F U m) : + Flow C R F U (n + m) := by + refine ⟨?_, ?_, ?_⟩ + · intro l a b + refine step_bridge (h1.flow_cross l (m * 2 + a) b) (by cfg_eq) ?_ + exact step_end (h2.flow_cross l a (n + b)) (by cfg_eq) (by cfg_eq) + · intro a b + refine ReachesStar.trans (h1.flow_root a b) ?_ + exact step_end (h2.flow_root (n * 2 + a) b) (by cfg_eq) (by cfg_eq) + · intro s v b hsv + by_cases hle : n ≤ s + · refine step_bridge (h1.flow_cross default (1 + (s - n) * 2) b) (by cfg_eq) ?_ + exact step_end (h2.flow_border (s - n) v (n + b) (by omega)) (by cfg_eq) (by cfg_eq) + · refine ReachesStar.trans (h1.flow_border s (n - s - 1) b (by omega)) ?_ + exact step_end (h2.flow_root ((n - s - 1) * 2) (1 + s + b)) (by cfg_eq) (by cfg_eq) + +theorem Flow_W (r : zB) (c d : Nat) : + Flow (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (2 + d)) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (2 + d)) + (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c) d) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c) d) 1 := by + refine ⟨?_, ?_, ?_⟩ + · intro l a b + exact step_end (crossW_step l r a _ _ _ c d (Word_pow _ _ _ b Word_V)) (by cfg_eq) (by cfg_eq) + · intro a b + exact step_end (rootW_step r a _ _ _ c d (Word_pow _ _ _ b Word_V)) (by cfg_eq) (by cfg_eq) + · intro s v b hsv + exact step_end (crossW_one r b c d) (by cfg_eq) (by cfg_eq) + +theorem Flow_to_Z (r : zB) (c : Nat) : + Flow (fun l a b => crossW l (([0, 1, 1, 0, 1, 0, 1, 0] : zF) +> r) a (([1, 0, 1, 0, 0, 1] : zF) + ^ b) (3 + c) 0) + (fun a b => rootW (([0, 1, 1, 0, 1, 0, 1, 0] : zF) +> r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) + (3 + c) 0) + (fun l a b => crossZ l r a b (5 + c) 2) + (fun a b => rootZ r a b (5 + c) 2) 1 := by + refine ⟨?_, ?_, ?_⟩ + · intro l a b; exact step_end (cross_to_Z l r a b c) (by cfg_eq) (by cfg_eq) + · intro a b; exact step_end (root_to_Z r a b c) (by cfg_eq) (by cfg_eq) + · intro s v b hsv; exact step_end (cross_to_Z_one r b c) (by cfg_eq) (by cfg_eq) + +theorem Flow_to_V (r : zB) (c n : Nat) : + Flow (fun l a b => crossW l (([0, 1, 1] : zF) +> ((([0, 1, 0, 0, 1, 1] : zF) ^ (1 + n)) + +> ((([0, 1] : zF) ^ (4 + n * 2)) +> (([0] : zF) +> r)))) + a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (3 + c) 0) + (fun a b => rootW (([0, 1, 1] : zF) +> ((([0, 1, 0, 0, 1, 1] : zF) ^ (1 + n)) + +> ((([0, 1] : zF) ^ (4 + n * 2)) +> (([0] : zF) +> r)))) + a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (3 + c) 0) + (fun l a b => crossV l ((([1, 0] : zF) ^ (5 + n * 2)) +> r) a b (5 + c) n) + (fun a b => rootV ((([1, 0] : zF) ^ (5 + n * 2)) +> r) a b (5 + c) n) 1 := by + refine ⟨?_, ?_, ?_⟩ + · intro l a b; exact step_end (cross_to_V l r a b c n) (by cfg_eq) (by cfg_eq) + · intro a b; exact step_end (root_to_V r a b c n) (by cfg_eq) (by cfg_eq) + · intro s v b hsv; exact step_end (cross_to_V_one r b c n) (by cfg_eq) (by cfg_eq) + +theorem Flow_V (r : zB) (c e : Nat) : + Flow (fun l a b => crossV l r a b (3 + c) (1 + e)) + (fun a b => rootV r a b (3 + c) (1 + e)) + (fun l a b => crossV l r a b (4 + c) e) + (fun a b => rootV r a b (4 + c) e) 2 := by + refine ⟨?_, ?_, ?_⟩ + · intro l a b; exact step_end (crossV_step l r a b c e) (by cfg_eq) (by cfg_eq) + · intro a b; exact step_end (rootV_step r a b c e) (by cfg_eq) (by cfg_eq) + · intro s v b hsv + rcases s with _ | _ | s + · exact step_end (crossV_one r b c e) (by cfg_eq) (by cfg_eq) + · exact step_end (crossV_three r b c e) (by cfg_eq) (by cfg_eq) + · omega + +theorem Flow_Z (r : zB) (c e : Nat) : + Flow (fun l a b => crossZ l r a b (3 + c) (2 + e)) + (fun a b => rootZ r a b (3 + c) (2 + e)) + (fun l a b => crossZ l r a b (3 + c) e) + (fun a b => rootZ r a b (3 + c) e) 2 := by + refine ⟨?_, ?_, ?_⟩ + · intro l a b; exact step_end (crossZ_step l r a b c e) (by cfg_eq) (by cfg_eq) + · intro a b; exact step_end (rootZ_step r a b c e) (by cfg_eq) (by cfg_eq) + · intro s v b hsv + rcases s with _ | _ | s + · exact step_end (crossZ_one' r b c e) (by cfg_eq) (by cfg_eq) + · exact step_end (crossZ_three' r b c e) (by cfg_eq) (by cfg_eq) + · omega + +theorem Flow_V_end (r : zB) (c e : Nat) : + Flow (fun l a b => crossV l ((([1, 0] : zF) ^ (1 + e)) +> r) a b (3 + c) 0) + (fun a b => rootV ((([1, 0] : zF) ^ (1 + e)) +> r) a b (3 + c) 0) + (fun l a b => crossZ l r a b (4 + c) e) + (fun a b => rootZ r a b (4 + c) e) 2 := by + refine ⟨?_, ?_, ?_⟩ + · intro l a b; exact step_end (crossV_end l r a b c e) (by cfg_eq) (by cfg_eq) + · intro a b; exact step_end (rootV_end r a b c e) (by cfg_eq) (by cfg_eq) + · intro s v b hsv + rcases s with _ | _ | s + · exact step_end (crossVend_one r b c e) (by cfg_eq) (by cfg_eq) + · exact step_end (crossVend_three r b c e) (by cfg_eq) (by cfg_eq) + · omega + +theorem Flow_eq {C1 R1 D1 T1 C2 R2 D2 T2} {n1 n2 : Nat} + (h : Flow C1 R1 D1 T1 n1) + (hC : ∀ l a b, C1 l a b = C2 l a b) + (hR : ∀ a b, R1 a b = R2 a b) + (hD : ∀ l a b, D1 l a b = D2 l a b) + (hT : ∀ a b, T1 a b = T2 a b) + (hn : n1 = n2) : + Flow C2 R2 D2 T2 n2 := by + have eC : C1 = C2 := by funext l a b; exact hC l a b + have eR : R1 = R2 := by funext a b; exact hR a b + have eD : D1 = D2 := by funext l a b; exact hD l a b + have eT : T1 = T2 := by funext a b; exact hT a b + subst eC; subst eR; subst eD; subst eT; subst hn; exact h + +theorem Flow_Vs (r : zB) (c e n : Nat) : + Flow (fun l a b => crossV l r a b (3 + c) (e + n)) + (fun a b => rootV r a b (3 + c) (e + n)) + (fun l a b => crossV l r a b (3 + c + n) e) + (fun a b => rootV r a b (3 + c + n) e) (n * 2) := by + induction n generalizing c e with + | zero => + exact Flow_eq (Flow_id _ _) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by omega) + | succ n ih => + have h1 : Flow (fun l a b => crossV l r a b (3 + c) (e + (n + 1))) + (fun a b => rootV r a b (3 + c) (e + (n + 1))) + (fun l a b => crossV l r a b (3 + (1 + c)) (e + n)) + (fun a b => rootV r a b (3 + (1 + c)) (e + n)) 2 := + Flow_eq (Flow_V r c (e + n)) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) rfl + exact Flow_eq (Flow_trans h1 (ih (1 + c) e)) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) (by omega) + +theorem Flow_Zs (r : zB) (c e n : Nat) : + Flow (fun l a b => crossZ l r a b (3 + c) (e + n * 2)) + (fun a b => rootZ r a b (3 + c) (e + n * 2)) + (fun l a b => crossZ l r a b (3 + c) e) + (fun a b => rootZ r a b (3 + c) e) (n * 2) := by + induction n generalizing e with + | zero => + exact Flow_eq (Flow_id _ _) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by omega) + | succ n ih => + have h1 : Flow (fun l a b => crossZ l r a b (3 + c) (e + (n + 1) * 2)) + (fun a b => rootZ r a b (3 + c) (e + (n + 1) * 2)) + (fun l a b => crossZ l r a b (3 + c) (e + n * 2)) + (fun a b => rootZ r a b (3 + c) (e + n * 2)) 2 := + Flow_eq (Flow_Z r c (e + n * 2)) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) rfl + exact Flow_eq (Flow_trans h1 (ih e)) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by omega) + +theorem Flow_tail (r : zB) (c n : Nat) : + Flow (fun l a b => crossW l (flow_tail n r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + c) 2) + (fun a b => rootW (flow_tail n r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + c) 2) + (fun l a b => crossZ l r a b (5 + c + n) 0) + (fun a b => rootZ r a b (5 + c + n) 0) (4 + n * 4) := by + have hw := Flow_W (flow_tail n r) (1 + c) 0 + rcases n with _ | n + · have h1 : Flow (fun l a b => crossW l (flow_tail 0 r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) + (2 + (1 + c)) 0) + (fun a b => rootW (flow_tail 0 r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + (1 + c)) + 0) + (fun l a b => crossZ l r a b (3 + (2 + c)) (2 + 0)) + (fun a b => rootZ r a b (3 + (2 + c)) (2 + 0)) 1 := + Flow_eq (Flow_to_Z r c) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) rfl + have h2 := Flow_Z r (2 + c) 0 + exact Flow_eq (Flow_trans hw (Flow_trans h1 h2)) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) (by omega) + · have h1 : Flow (fun l a b => crossW l (flow_tail (n + 1) r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) + (2 + (1 + c)) 0) + (fun a b => rootW (flow_tail (n + 1) r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) + (2 + (1 + c)) 0) + (fun l a b => crossV l ((([1, 0] : zF) ^ (5 + n * 2)) +> r) a b (3 + (2 + c)) + (0 + n)) + (fun a b => rootV ((([1, 0] : zF) ^ (5 + n * 2)) +> r) a b (3 + (2 + c)) (0 + n)) + 1 := + Flow_eq (Flow_to_V r c n) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) rfl + have h2 := Flow_Vs ((([1, 0] : zF) ^ (5 + n * 2)) +> r) (2 + c) 0 n + have h3 : Flow (fun l a b => crossV l ((([1, 0] : zF) ^ (5 + n * 2)) +> r) a b (3 + (2 + c) + n) + 0) + (fun a b => rootV ((([1, 0] : zF) ^ (5 + n * 2)) +> r) a b (3 + (2 + c) + n) 0) + (fun l a b => crossZ l r a b (3 + (3 + c + n)) (0 + (2 + n) * 2)) + (fun a b => rootZ r a b (3 + (3 + c + n)) (0 + (2 + n) * 2)) 2 := + Flow_eq (Flow_V_end r (2 + c + n) (4 + n * 2)) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) rfl + have h4 := Flow_Zs r (3 + c + n) 0 (2 + n) + exact Flow_eq (Flow_trans hw (Flow_trans h1 (Flow_trans h2 (Flow_trans h3 h4)))) + (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) (by omega) + +theorem bridges_root (n s v b c d : Nat) (E : s + v = 3 + n * 4) : + (S default (specialN n ((([1, 0, 0] : zF) ^ d) +> default)) (1 + s * 2) (1 + b) (2 + c) 0) + [target_tm]⊢* + (rootW default (v * 2) (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + s + b)) (2 + c + n) (1 + d)) := by + refine step_bridge ((Flow_tail ((([1, 0, 0] : zF) ^ d) +> default) c n).flow_border s v b + (by omega)) (by cfg_eq) ?_ + exact step_end (rootZ_end default (v * 2) (1 + s + b) (2 + c + n) d) (by cfg_eq) (by cfg_eq) + +theorem root_tail_entry (n : Nat) (r : zB) (a b c : Nat) : + (rootW (([0] : zF) +> specialN n r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c 1) [target_tm]⊢* + (rootW (flow_tail n r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c 2) := + step_eq (by cfg_eq) + +theorem S_tail_root (n s v b c j d : Nat) (E1 : 1 <= c + j) (E2 : s + v + 1 = j + 4 + n * 4) : + (S default (specialN n ((([1, 0, 0] : zF) ^ d) +> default)) (1 + s * 2) (1 + b) (c * 2) (j * 2)) + [target_tm]⊢* + (rootW default (v * 2) (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + b + s)) ((c + j) * 2 + n) + (1 + d)) := by + by_cases hle : j ≤ s + · refine step_bridge (Incs1 default (specialN n ((([1, 0, 0] : zF) ^ d) +> default)) (1 + (s - j) + * 2) (1 + b) (c * 2) 0 j) (by cfg_eq) ?_ + exact step_end (bridges_root n (s - j) v (b + j) ((c + j) * 2 - 2) d (by omega)) (by cfg_eq) + (by cfg_eq) + · refine step_bridge (Incs1 default (specialN n ((([1, 0, 0] : zF) ^ d) +> default)) 1 (1 + b) + (c * 2) (2 + (j - s - 1) * 2) s) (by cfg_eq) ?_ + refine step_bridge (S_root1' (specialN n ((([1, 0, 0] : zF) ^ d) +> default)) (b + s) ((c + s) + * 2) (1 + (j - s - 1) * 2)) (by cfg_eq) ?_ + refine step_bridge (rootsW (([0] : zF) +> specialN n ((([1, 0, 0] : zF) ^ d) +> default)) + 0 _ _ _ (1 + (c + s) * 2) 1 (j - s - 1) (Word_pow _ _ _ (1 + b + s) Word_V)) (by cfg_eq) ?_ + refine step_bridge (root_tail_entry n ((([1, 0, 0] : zF) ^ d) +> default) ((j - s - 1) * 2) + (1 + b + s) ((c + j) * 2 - 1)) (by cfg_eq) ?_ + refine step_bridge ((Flow_tail ((([1, 0, 0] : zF) ^ d) +> default) ((c + j) * 2 - 2) + n).flow_root ((j - s - 1) * 2) (1 + b + s)) (by cfg_eq) ?_ + exact step_end (rootZ_end default (v * 2) (1 + b + s) ((c + j) * 2 + n) d) (by cfg_eq) + (by cfg_eq) + +theorem negativeN_absorb (p n d e d0 b j t : Nat) (HP : P p) (E1 : p = 2 + n * 2 + d0) + (E2 : p + 3 + n * 2 + e = d * 2 + j * 2) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) p n d e) + [target_tm]⊢* + (S default (specialN n ((([1, 0, 0] : zF) ^ d0) +> default)) t (1 + b + d) (d * 2) + (j * 2)) := by + refine step_bridge (negativeN_entry ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) + +> default)) p n d e d0 HP E1) (by cfg_eq) ?_ + refine step_bridge (Incs1 ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) + (specialN n ((([1, 0, 0] : zF) ^ d0) +> default)) 0 1 0 (j * 2) d) (by cfg_eq) ?_ + exact step_end (S_even_block ((([1, 0] : zF) ^ t) +> default) (specialN n ((([1, 0, 0] : zF) ^ d0) + +> default)) (1 + d) (d * 2) (j * 2) b) (by cfg_eq) (by cfg_eq) + +theorem negativeN_root (p n d e d0 b j s v : Nat) + (HP : P p) (E1 : p = 2 + n * 2 + d0) (E2 : p + 3 + n * 2 + e = d * 2 + j * 2) (E3 : 1 <= d + j) + (E4 : s + v + 1 = j + 4 + n * 4) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ (1 + s * 2)) +> default)) p n d e) + [target_tm]⊢* + (rootW default (v * 2) (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + b + d + s)) ((d + j) * 2 + n) + (1 + d0)) := by + refine step_bridge (negativeN_absorb p n d e d0 b j (1 + s * 2) HP E1 E2) (by cfg_eq) ?_ + exact step_end (S_tail_root n s v (b + d) d j d0 E3 E4) (by cfg_eq) (by cfg_eq) + +theorem negativeN_root_odd (a n d b j r s v : Nat) + (HP : P (3 + a * 2)) (E1 : a = n + r) (E2 : a + n + 3 = d + j) (E3 : s + b = 6 + a * 2 + d) + (E4 : s + v + 1 = j + 4 + n * 4) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ (1 + s * 2)) +> default)) + (3 + a * 2) n d 0) [target_tm]⊢* + ((((([1, 0] : zF) ^ (9 + a * 4 + n)) +> ((([1, 1, 0] : zF) ^ (14 + a * 4 + d * 4)) + +> ((([1, 0] : zF) ^ (5 + v * 2 + r * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (negativeN_root (3 + a * 2) n d 0 (1 + r * 2) b j s v HP (by omega) (by omega) + (by omega) E4) (by cfg_eq) ?_ + refine step_bridge (rootsW default (v * 2) _ _ _ ((d + j) * 2 + n) 0 (1 + r) + (Word_pow _ _ _ (1 + b + d + s) Word_V)) (by cfg_eq) ?_ + exact step_end (root_end0 (2 + v * 2 + r * 2) (b + d + s) (2 + (d + j) * 2 + n + r * 2)) + (by cfg_eq) (by cfg_eq) + +theorem negativeN_root_even (a n d b j r s v : Nat) + (HP : P (2 + a * 2)) (E1 : a = n + r) (E2 : a + n + 3 = d + j) (E3 : s + b = 6 + a * 2 + d) + (E4 : s + v + 1 = j + 4 + n * 4) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ (1 + s * 2)) +> default)) + (2 + a * 2) n d 1) [target_tm]⊢* + ((((([1, 0] : zF) ^ (8 + a * 4 + n)) +> ((([1, 1, 0] : zF) ^ (14 + a * 4 + d * 4)) + +> ((([1, 0] : zF) ^ (3 + v * 2 + r * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (negativeN_root (2 + a * 2) n d 1 (r * 2) b j s v HP (by omega) (by omega) + (by omega) E4) (by cfg_eq) ?_ + refine step_bridge (rootsW default (v * 2) _ _ _ ((d + j) * 2 + n) + 1 r (Word_pow _ _ _ (1 + b + d + s) Word_V)) (by cfg_eq) ?_ + exact step_end (root_end1 (v * 2 + r * 2) (b + d + s) ((d + j) * 2 + n + r * 2)) (by cfg_eq) + (by cfg_eq) + +theorem loneN_root (p n e d0 b h s v : Nat) + (HP : P p) (E1 : p = 2 + n * 2 + d0) (E2 : p + 3 + n * 2 + e = h * 2) (E3 : 1 <= h) + (E4 : s + v + 1 = h + 4 + n * 4) : + (loneN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ (3 + s * 2)) +> default)) p n e) + [target_tm]⊢* + (rootW default (v * 2) (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + b + s)) (h * 2 + n) (1 + d0)) := by + refine step_bridge (loneN_entry p n e d0 b (1 + s * 2) HP E1) (by cfg_eq) ?_ + exact step_end (S_tail_root n s v b 0 h d0 (by omega) E4) (by cfg_eq) (by cfg_eq) + +theorem loneN_root_odd (a n b r s v : Nat) + (HP : P (3 + a * 2)) (E1 : a = n + r) (E2 : s + b = 4 + a * 2) + (E3 : s + v + 1 = a + n + 7 + n * 4) : + (loneN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ (3 + s * 2)) +> default)) (3 + a * 2) + n 0) [target_tm]⊢* + ((((([1, 0] : zF) ^ (9 + a * 4 + n)) +> ((([1, 1, 0] : zF) ^ (10 + a * 4)) +> ((([1, 0] : zF) + ^ (5 + v * 2 + r * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (loneN_root (3 + a * 2) n 0 (1 + r * 2) b (a + n + 3) s v HP (by omega) + (by omega) (by omega) (by omega)) (by cfg_eq) ?_ + refine step_bridge (rootsW default (v * 2) _ _ _ ((a + n + 3) * 2 + n) 0 (1 + r) + (Word_pow _ _ _ (1 + b + s) Word_V)) (by cfg_eq) ?_ + exact step_end (root_end0 (2 + v * 2 + r * 2) (b + s) (2 + (a + n + 3) * 2 + n + r * 2)) + (by cfg_eq) (by cfg_eq) + +theorem loneN_root_even (a n b r s v : Nat) + (HP : P (2 + a * 2)) (E1 : a = n + r) (E2 : s + b = 4 + a * 2) + (E3 : s + v + 1 = a + n + 7 + n * 4) : + (loneN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ (3 + s * 2)) +> default)) (2 + a * 2) + n 1) [target_tm]⊢* + ((((([1, 0] : zF) ^ (8 + a * 4 + n)) +> ((([1, 1, 0] : zF) ^ (10 + a * 4)) +> ((([1, 0] : zF) + ^ (3 + v * 2 + r * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (loneN_root (2 + a * 2) n 1 (r * 2) b (a + n + 3) s v HP (by omega) (by omega) + (by omega) (by omega)) (by cfg_eq) ?_ + refine step_bridge (rootsW default (v * 2) _ _ _ ((a + n + 3) * 2 + n) + 1 r (Word_pow _ _ _ (1 + b + s) Word_V)) (by cfg_eq) ?_ + exact step_end (root_end1 (v * 2 + r * 2) (b + s) ((a + n + 3) * 2 + n + r * 2)) (by cfg_eq) + (by cfg_eq) + +theorem negativeN_one_odd (a n d b j r t : Nat) + (HP : P (3 + a * 2)) (E1 : a = n + r) (E2 : a + n + 3 = d + j) (E3 : b + n * 4 + 2 = d * 2) + (E4 : t + b * 2 = 13 + a * 4 + d * 2) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (3 + a * 2) n d 0) + [target_tm]⊢* + ((((([1, 0] : zF) ^ (9 + a * 4 + n)) +> ((([1, 1, 0] : zF) ^ (14 + a * 4 + d * 4)) + +> (([1, 0] : zF) +> default))) {{B}}> default)) := by + refine step_bridge (negativeN_cross (3 + a * 2) n d 0 (1 + r * 2) b j (3 + r * 2) HP (by omega) + (by omega)) (by cfg_eq) ?_ + refine step_bridge (Incs1 default default 3 (8 + a + n * 5 + b) (7 + a * 2 + n * 3) 1 r) + (by cfg_eq) ?_ + exact step_end (S_short1 default (7 + a + n * 5 + b + r) (7 + a * 2 + n * 3 + r * 2)) (by cfg_eq) + (by cfg_eq) + +theorem negativeN_one_even (a n d b j r t : Nat) + (HP : P (2 + a * 2)) (E1 : a = n + r) (E2 : a + n + 3 = d + j) (E3 : b + n * 4 + 1 = d * 2) + (E4 : t + b * 2 = 13 + a * 4 + d * 2) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (2 + a * 2) n d 1) + [target_tm]⊢* + ((((([1, 0] : zF) ^ (8 + a * 4 + n)) +> ((([1, 1, 0] : zF) ^ (14 + a * 4 + d * 4)) + +> (([1, 0] : zF) +> default))) {{B}}> default)) := by + refine step_bridge (negativeN_cross (2 + a * 2) n d 1 (r * 2) b j (1 + r * 2) HP (by omega) + (by omega)) (by cfg_eq) ?_ + refine step_bridge (Incs1 default default 1 (8 + a + n * 5 + b) (7 + a * 2 + n * 3) 0 r) + (by cfg_eq) ?_ + exact step_end (S_short0 default (7 + a + n * 5 + b + r) (7 + a * 2 + n * 3 + r * 2)) (by cfg_eq) + (by cfg_eq) + +theorem crossW_block (l r : zB) (b_blk b c d : Nat) : + (crossW ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> l) r 0 (([1, 0, 1, 0, 0, 1] : zF) ^ b) c d) + [target_tm]⊢* + (crossW l r 0 (([1, 0, 1, 0, 0, 1] : zF) ^ (b_blk + b)) c d) := by + exact step_end (even_block l (([0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ b) +> ((([1, 0] : zF) + ^ c) +> (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ d) +> r))))) b_blk) (by cfg_eq) (by cfg_eq) + +theorem crossV_block (l r : zB) (b_blk b c e : Nat) : + (crossV ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> l) r 0 b c e) [target_tm]⊢* + (crossV l r 0 (b_blk + b) c e) := by + exact step_end (even_block l (([0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ b) +> ((([1, 0] : zF) + ^ c) +> (([0, 1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ e) +> r))))) b_blk) + (by cfg_eq) (by cfg_eq) + +theorem crossZ_block (l r : zB) (b_blk b c e : Nat) : + (crossZ ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> l) r 0 b c e) [target_tm]⊢* + (crossZ l r 0 (b_blk + b) c e) := by + exact step_end (even_block l (([0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ b) +> ((([1, 0] : zF) + ^ c) +> (([0] : zF) +> ((([1, 0] : zF) ^ e) +> r))))) b_blk) (by cfg_eq) (by cfg_eq) + +theorem crossW_absorb (l r : zB) (a b_blk b c d : Nat) : + (crossW ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ a) +> l)) + r 0 (([1, 0, 1, 0, 0, 1] : zF) ^ b) c d) [target_tm]⊢* + (crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ (b_blk + b)) c d) := by + exact step_end (crossW_block ((([1, 0] : zF) ^ a) +> l) r b_blk b c d) (by cfg_eq) (by cfg_eq) + +theorem crossV_absorb (l r : zB) (a b_blk b c e : Nat) : + (crossV ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ a) +> l)) r 0 b c e) + [target_tm]⊢* + (crossV l r a (b_blk + b) c e) := by + exact step_end (crossV_block ((([1, 0] : zF) ^ a) +> l) r b_blk b c e) (by cfg_eq) (by cfg_eq) + +theorem crossZ_absorb (l r : zB) (a b_blk b c e : Nat) : + (crossZ ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ a) +> l)) r 0 b c e) + [target_tm]⊢* + (crossZ l r a (b_blk + b) c e) := by + exact step_end (crossZ_block ((([1, 0] : zF) ^ a) +> l) r b_blk b c e) (by cfg_eq) (by cfg_eq) + +structure BlockFlow (C : zB → Nat → Nat → Cfg (Fin 2) (Fin 6)) (R : Nat → Nat → Cfg (Fin 2) (Fin 6)) + (D : zB → Nat → Nat → Cfg (Fin 2) (Fin 6)) (T : Nat → Nat → Cfg (Fin 2) (Fin 6)) + (n : Nat) : Prop where + block_flow : Flow C R D T n + block_cross : ∀ l a b_blk b s v, s + v + 1 = n → + (C ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ (2 + v * 2 + a)) +> l)) (s * 2) b) + [target_tm]⊢* + (D l a (n + b_blk + b)) + block_border : ∀ b_blk b s t v, s + t + v + 1 = n → + (C ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ (1 + t * 2)) +> default)) (s * 2) b) + [target_tm]⊢* + (T (v * 2) (1 + s + t + b_blk + b)) + +theorem BlockFlow_id (C : zB → Nat → Nat → Cfg (Fin 2) (Fin 6)) (R : Nat → Nat → Cfg (Fin 2) + (Fin 6)) : + BlockFlow C R C R 0 := by + refine ⟨Flow_id C R, fun l a b_blk b s v h => by omega, fun b_blk b s t v h => by omega⟩ + +theorem BlockFlow_eq {C1 R1 D1 T1 C2 R2 D2 T2} {n1 n2 : Nat} + (h : BlockFlow C1 R1 D1 T1 n1) + (hC : ∀ l a b, C1 l a b = C2 l a b) + (hR : ∀ a b, R1 a b = R2 a b) + (hD : ∀ l a b, D1 l a b = D2 l a b) + (hT : ∀ a b, T1 a b = T2 a b) + (hn : n1 = n2) : + BlockFlow C2 R2 D2 T2 n2 := by + have eC : C1 = C2 := by funext l a b; exact hC l a b + have eR : R1 = R2 := by funext a b; exact hR a b + have eD : D1 = D2 := by funext l a b; exact hD l a b + have eT : T1 = T2 := by funext a b; exact hT a b + subst eC; subst eR; subst eD; subst eT; subst hn; exact h + +theorem BlockFlow_trans {C R D T F U} {n m : Nat} (h1 : BlockFlow C R D T n) + (h2 : BlockFlow D T F U m) : + BlockFlow C R F U (n + m) := by + refine ⟨Flow_trans h1.block_flow h2.block_flow, ?_, ?_⟩ + · intro l a b_blk b s v E + by_cases hle : n ≤ s + · refine step_bridge (h1.block_flow.flow_cross ((([1, 1, 0] : zF) ^ (b_blk * 2)) + +> ((([1, 0] : zF) ^ (2 + v * 2 + a)) +> l)) ((s - n) * 2) b) (by cfg_eq) ?_ + exact step_end (h2.block_cross l a b_blk (n + b) (s - n) v (by omega)) (by cfg_eq) (by cfg_eq) + · refine step_bridge (h1.block_cross l (m * 2 + a) b_blk b s (n - s - 1) (by omega)) (by cfg_eq) + ?_ + exact step_end (h2.block_flow.flow_cross l a (n + b_blk + b)) (by cfg_eq) (by cfg_eq) + · intro b_blk b s t v E + by_cases hle : n ≤ s + · refine step_bridge (h1.block_flow.flow_cross ((([1, 1, 0] : zF) ^ (b_blk * 2)) + +> ((([1, 0] : zF) ^ (1 + t * 2)) +> default)) ((s - n) * 2) b) (by cfg_eq) ?_ + exact step_end (h2.block_border b_blk (n + b) (s - n) t v (by omega)) (by cfg_eq) (by cfg_eq) + · by_cases hle2 : n ≤ s + t + · refine step_bridge (h1.block_cross default (1 + (s + t - n) * 2) b_blk b s (n - s - 1) + (by omega)) (by cfg_eq) ?_ + exact step_end (h2.block_flow.flow_border (s + t - n) v (n + b_blk + b) (by omega)) + (by cfg_eq) (by cfg_eq) + · refine ReachesStar.trans (h1.block_border b_blk b s t (n - s - t - 1) (by omega)) ?_ + exact step_end (h2.block_flow.flow_root ((n - s - t - 1) * 2) (1 + s + t + b_blk + b)) + (by cfg_eq) (by cfg_eq) + +theorem BlockFlow_one {C R D T} (h : Flow C R D T 1) + (hblock : ∀ l a b_blk b, (C ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ a) +> l)) + 0 b) [target_tm]⊢* (C l a (b_blk + b))) : + BlockFlow C R D T 1 := by + refine ⟨h, ?_, ?_⟩ + · intro l a b_blk b s v E + have hs : s = 0 := by omega + have hv : v = 0 := by omega + subst hs; subst hv + refine ReachesStar.trans (hblock l (2 + 0 * 2 + a) b_blk b) ?_ + have hfc := h.flow_cross l a (b_blk + b) + have heq1 : C l (2 + 0 * 2 + a) (b_blk + b) = C l (1 * 2 + a) (b_blk + b) := rfl + have heq2 : D l a (1 + (b_blk + b)) = D l a (1 + b_blk + b) := by congr 1; omega + exact step_end hfc heq1 heq2 + · intro b_blk b s t v E + have hs : s = 0 := by omega + have ht : t = 0 := by omega + have hv : v = 0 := by omega + subst hs; subst ht; subst hv + refine ReachesStar.trans (hblock default (1 + 0 * 2) b_blk b) ?_ + have hfb := h.flow_border 0 0 (b_blk + b) rfl + have heq2 : T (0 * 2) (1 + 0 + (b_blk + b)) = T (0 * 2) (1 + 0 + 0 + b_blk + b) := + by congr 1; omega + exact step_end hfb rfl heq2 + +theorem BlockFlow_two {C R D T} (h : Flow C R D T 2) + (hblock : ∀ l a b_blk b, (C ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ a) +> l)) + 0 b) [target_tm]⊢* (C l a (b_blk + b))) + (hc : ∀ l a b_blk b, (C ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ (2 + a)) +> l)) + 2 b) [target_tm]⊢* (D l a (2 + b_blk + b))) + (hb : ∀ b_blk b, (C ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> (([1, 0] : zF) +> default)) 2 b) + [target_tm]⊢* (T 0 (2 + b_blk + b))) : + BlockFlow C R D T 2 := by + refine ⟨h, ?_, ?_⟩ + · intro l a b_blk b s v E + rcases s with _ | _ | s + · have hv : v = 1 := by omega + subst hv + refine ReachesStar.trans (hblock l (2 + 1 * 2 + a) b_blk b) ?_ + have hfc := h.flow_cross l a (b_blk + b) + exact step_end hfc (by cfg_eq) (by cfg_eq) + · have hv : v = 0 := by omega + subst hv + exact hc l a b_blk b + · omega + · intro b_blk b s t v E + rcases s with _ | _ | s + · refine ReachesStar.trans (hblock default (1 + t * 2) b_blk b) ?_ + have hfb := h.flow_border t v (b_blk + b) (by omega) + exact step_end hfb rfl (by cfg_eq) + · have ht : t = 0 := by omega + have hv : v = 0 := by omega + subst ht; subst hv + have h1 := hb b_blk b + exact step_end h1 (by cfg_eq) (by cfg_eq) + · omega + +theorem BlockFlow_W (r : zB) (c d : Nat) : + BlockFlow (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (2 + d)) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (2 + d)) + (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c) d) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c) d) 1 := + BlockFlow_one (Flow_W r c d) (fun l a b_blk b => crossW_absorb l r a b_blk b c (2 + d)) + +theorem BlockFlow_to_Z (r : zB) (c : Nat) : + BlockFlow (fun l a b => crossW l (([0, 1, 1, 0, 1, 0, 1, 0] : zF) +> r) + a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (3 + c) 0) + (fun a b => rootW (([0, 1, 1, 0, 1, 0, 1, 0] : zF) +> r) a (([1, 0, 1, 0, 0, 1] : zF) + ^ b) (3 + c) 0) + (fun l a b => crossZ l r a b (5 + c) 2) + (fun a b => rootZ r a b (5 + c) 2) 1 := + BlockFlow_one (Flow_to_Z r c) (fun l a b_blk b => crossW_absorb l (([0, 1, 1, 0, 1, 0, 1, 0] : zF) + +> r) a b_blk b (3 + c) 0) + +theorem BlockFlow_to_V (r : zB) (c n : Nat) : + BlockFlow (fun l a b => crossW l (([0, 1, 1] : zF) +> ((([0, 1, 0, 0, 1, 1] : zF) ^ (1 + n)) + +> ((([0, 1] : zF) ^ (4 + n * 2)) +> (([0] : zF) +> r)))) + a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (3 + c) 0) + (fun a b => rootW (([0, 1, 1] : zF) +> ((([0, 1, 0, 0, 1, 1] : zF) ^ (1 + n)) + +> ((([0, 1] : zF) ^ (4 + n * 2)) +> (([0] : zF) +> r)))) + a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (3 + c) 0) + (fun l a b => crossV l ((([1, 0] : zF) ^ (5 + n * 2)) +> r) a b (5 + c) n) + (fun a b => rootV ((([1, 0] : zF) ^ (5 + n * 2)) +> r) a b (5 + c) n) 1 := + BlockFlow_one (Flow_to_V r c n) (fun l a b_blk b => crossW_absorb l _ a b_blk b (3 + c) 0) + +theorem BlockFlow_V (r : zB) (c e : Nat) : + BlockFlow (fun l a b => crossV l r a b (3 + c) (1 + e)) + (fun a b => rootV r a b (3 + c) (1 + e)) + (fun l a b => crossV l r a b (4 + c) e) + (fun a b => rootV r a b (4 + c) e) 2 := + BlockFlow_two (Flow_V r c e) + (fun l a b_blk b => crossV_absorb l r a b_blk b (3 + c) (1 + e)) + (fun l a b_blk b => step_end (crossV_step_block l r a b_blk b c e) (by cfg_eq) (by cfg_eq)) + (fun b_blk b => step_end (crossV_step_block_root r b_blk b c e) (by cfg_eq) (by cfg_eq)) + +theorem BlockFlow_Z (r : zB) (c e : Nat) : + BlockFlow (fun l a b => crossZ l r a b (3 + c) (2 + e)) + (fun a b => rootZ r a b (3 + c) (2 + e)) + (fun l a b => crossZ l r a b (3 + c) e) + (fun a b => rootZ r a b (3 + c) e) 2 := + BlockFlow_two (Flow_Z r c e) + (fun l a b_blk b => crossZ_absorb l r a b_blk b (3 + c) (2 + e)) + (fun l a b_blk b => step_end (crossZ_step_block l r a b_blk b c e) (by cfg_eq) (by cfg_eq)) + (fun b_blk b => step_end (crossZ_step_block_root r b_blk b c e) (by cfg_eq) (by cfg_eq)) + +theorem BlockFlow_V_end (r : zB) (c e : Nat) : + BlockFlow (fun l a b => crossV l ((([1, 0] : zF) ^ (1 + e)) +> r) a b (3 + c) 0) + (fun a b => rootV ((([1, 0] : zF) ^ (1 + e)) +> r) a b (3 + c) 0) + (fun l a b => crossZ l r a b (4 + c) e) + (fun a b => rootZ r a b (4 + c) e) 2 := + BlockFlow_two (Flow_V_end r c e) + (fun l a b_blk b => crossV_absorb l ((([1, 0] : zF) ^ (1 + e)) +> r) a b_blk b (3 + c) 0) + (fun l a b_blk b => step_end (crossVend_block l r a b_blk b c e) (by cfg_eq) (by cfg_eq)) + (fun b_blk b => step_end (crossVend_block_root r b_blk b c e) (by cfg_eq) (by cfg_eq)) + +theorem BlockFlow_Vs (r : zB) (c e n : Nat) : + BlockFlow (fun l a b => crossV l r a b (3 + c) (e + n)) + (fun a b => rootV r a b (3 + c) (e + n)) + (fun l a b => crossV l r a b (3 + c + n) e) + (fun a b => rootV r a b (3 + c + n) e) (n * 2) := by + induction n generalizing c e with + | zero => + exact BlockFlow_eq (BlockFlow_id _ _) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) (by omega) + | succ n ih => + have h1 : BlockFlow (fun l a b => crossV l r a b (3 + c) (e + (n + 1))) + (fun a b => rootV r a b (3 + c) (e + (n + 1))) + (fun l a b => crossV l r a b (3 + (1 + c)) (e + n)) + (fun a b => rootV r a b (3 + (1 + c)) (e + n)) 2 := + BlockFlow_eq (BlockFlow_V r c (e + n)) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) rfl + exact BlockFlow_eq (BlockFlow_trans h1 (ih (1 + c) e)) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) (by omega) + +theorem BlockFlow_Zs (r : zB) (c e n : Nat) : + BlockFlow (fun l a b => crossZ l r a b (3 + c) (e + n * 2)) + (fun a b => rootZ r a b (3 + c) (e + n * 2)) + (fun l a b => crossZ l r a b (3 + c) e) + (fun a b => rootZ r a b (3 + c) e) (n * 2) := by + induction n generalizing e with + | zero => + exact BlockFlow_eq (BlockFlow_id _ _) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) (by omega) + | succ n ih => + have h1 : BlockFlow (fun l a b => crossZ l r a b (3 + c) (e + (n + 1) * 2)) + (fun a b => rootZ r a b (3 + c) (e + (n + 1) * 2)) + (fun l a b => crossZ l r a b (3 + c) (e + n * 2)) + (fun a b => rootZ r a b (3 + c) (e + n * 2)) 2 := + BlockFlow_eq (BlockFlow_Z r c (e + n * 2)) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) rfl + exact BlockFlow_eq (BlockFlow_trans h1 (ih e)) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) (by omega) + +theorem BlockFlow_tail (r : zB) (c n : Nat) : + BlockFlow (fun l a b => crossW l (flow_tail n r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + c) 2) + (fun a b => rootW (flow_tail n r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + c) 2) + (fun l a b => crossZ l r a b (5 + c + n) 0) + (fun a b => rootZ r a b (5 + c + n) 0) (4 + n * 4) := by + have hw := BlockFlow_W (flow_tail n r) (1 + c) 0 + rcases n with _ | n + · have h1 : BlockFlow (fun l a b => crossW l (flow_tail 0 r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) + (2 + (1 + c)) 0) + (fun a b => rootW (flow_tail 0 r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) + (2 + (1 + c)) 0) + (fun l a b => crossZ l r a b (3 + (2 + c)) (2 + 0)) + (fun a b => rootZ r a b (3 + (2 + c)) (2 + 0)) 1 := + BlockFlow_eq (BlockFlow_to_Z r c) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) rfl + have h2 := BlockFlow_Z r (2 + c) 0 + exact BlockFlow_eq (BlockFlow_trans hw (BlockFlow_trans h1 h2)) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) (by omega) + · have h1 : BlockFlow (fun l a b => crossW l (flow_tail (n + 1) r) a (([1, 0, 1, 0, 0, 1] : zF) + ^ b) (2 + (1 + c)) 0) + (fun a b => rootW (flow_tail (n + 1) r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) + (2 + (1 + c)) 0) + (fun l a b => crossV l ((([1, 0] : zF) ^ (5 + n * 2)) +> r) + a b (3 + (2 + c)) (0 + n)) + (fun a b => rootV ((([1, 0] : zF) ^ (5 + n * 2)) +> r) a b (3 + (2 + c)) + (0 + n)) 1 := + BlockFlow_eq (BlockFlow_to_V r c n) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) rfl + have h2 := BlockFlow_Vs ((([1, 0] : zF) ^ (5 + n * 2)) +> r) (2 + c) 0 n + have h3 : BlockFlow (fun l a b => crossV l ((([1, 0] : zF) ^ (5 + n * 2)) +> r) a b (3 + (2 + c) + + n) 0) + (fun a b => rootV ((([1, 0] : zF) ^ (5 + n * 2)) +> r) a b (3 + (2 + c) + n) + 0) + (fun l a b => crossZ l r a b (3 + (3 + c + n)) (0 + (2 + n) * 2)) + (fun a b => rootZ r a b (3 + (3 + c + n)) (0 + (2 + n) * 2)) 2 := + BlockFlow_eq (BlockFlow_V_end r (2 + c + n) (4 + n * 2)) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) rfl + have h4 := BlockFlow_Zs r (3 + c + n) 0 (2 + n) + exact BlockFlow_eq (BlockFlow_trans hw (BlockFlow_trans h1 (BlockFlow_trans h2 (BlockFlow_trans + h3 h4)))) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) + (by omega) + +theorem crossW_finish (l : zB) (a b c e : Nat) (he : e ≤ 1) : + (crossW l default (2 + a) (([1, 0, 1, 0, 0, 1] : zF) ^ b) c e) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + c + e)) +> ((([1, 1, 0] : zF) ^ (3 + b * 2)) +> ((([1, 0] : zF) ^ a) + +> l))) {{B}}> default)) := by + rcases e with _ | _ | e + · exact step_end (crossW_finish0 l a b c) (by cfg_eq) (by cfg_eq) + · exact step_end (crossW_finish1 l a b c) (by cfg_eq) (by cfg_eq) + · omega + +theorem crossW_short (b c e : Nat) (he : e ≤ 1) : + (crossW default default 1 (([1, 0, 1, 0, 0, 1] : zF) ^ b) c e) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + c + e)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> (([1, 0] : zF) + +> default))) {{B}}> default)) := by + rcases e with _ | _ | e + · exact step_end (crossW_short0 default b c) (by cfg_eq) (by cfg_eq) + · exact step_end (crossW_short1 default b c) (by cfg_eq) (by cfg_eq) + · omega + +theorem rootW_finish (a b c e : Nat) (he : e ≤ 1) : + (rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + b)) c e) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + c + e)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> ((([1, 0] : zF) + ^ (3 + a)) +> default))) {{B}}> default)) := by + rcases e with _ | _ | e + · exact step_end (root_end0 a b c) (by cfg_eq) (by cfg_eq) + · exact step_end (root_end1 a b c) (by cfg_eq) (by cfg_eq) + · omega + +theorem crossZ_end (r : zB) (a b c d : Nat) (l : zB) : + (crossZ l ((([1, 0, 0] : zF) ^ d) +> r) a b (3 + c) 0) [target_tm]⊢* + (crossW l (([0] : zF) +> r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (1 + d)) := + step_eq (by cfg_eq) + +theorem BlockFlow_Z_end (r : zB) (c d : Nat) : + BlockFlow (fun l a b => crossZ l ((([1, 0, 0] : zF) ^ d) +> r) a b (3 + c) 0) + (fun a b => rootZ ((([1, 0, 0] : zF) ^ d) +> r) a b (3 + c) 0) + (fun l a b => crossW l (([0] : zF) +> r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (1 + d)) + (fun a b => rootW (([0] : zF) +> r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (1 + d)) + 0 := by + refine ⟨⟨?_, ?_, ?_⟩, fun l a b_blk b s v h => by omega, fun b_blk b s t v h => by omega⟩ + · intro l a b; exact step_end (crossZ_end r a b c d l) (by cfg_eq) (by cfg_eq) + · intro a b; exact step_end (rootZ_end r a b c d) (by cfg_eq) (by cfg_eq) + · intro s v b h; omega + +theorem BlockFlow_Ws (r : zB) (c e n : Nat) : + BlockFlow (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (e + n * 2)) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (e + n * 2)) + (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (c + n * 2) e) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (c + n * 2) e) n := by + induction n generalizing c with + | zero => + exact BlockFlow_eq (BlockFlow_id _ _) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) rfl + | succ n ih => + have h1 : BlockFlow (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (e + (n + 1) + * 2)) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (e + (n + 1) * 2)) + (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c) + (e + n * 2)) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c) (e + n * 2)) + 1 := + BlockFlow_eq (BlockFlow_W r c (e + n * 2)) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) rfl + exact BlockFlow_eq (BlockFlow_trans h1 (ih (2 + c))) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) (by omega) + +theorem BlockFlow_whole (c n d q e : Nat) (E : 1 + d = e + q * 2) : + BlockFlow (fun l a b => crossW l (flow_tail n ((([1, 0, 0] : zF) ^ d) +> default)) + a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + c) 2) + (fun a b => rootW (flow_tail n ((([1, 0, 0] : zF) ^ d) +> default)) + a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + c) 2) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c + n + q * 2) + e) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c + n + q * 2) e) + (4 + n * 4 + q) := by + have h1 := BlockFlow_tail ((([1, 0, 0] : zF) ^ d) +> default) c n + have h2 : BlockFlow (fun l a b => crossZ l ((([1, 0, 0] : zF) ^ d) +> default) a b (5 + c + n) 0) + (fun a b => rootZ ((([1, 0, 0] : zF) ^ d) +> default) a b (5 + c + n) 0) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c + n) + (e + q * 2)) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c + n) + (e + q * 2)) 0 := + BlockFlow_eq (BlockFlow_Z_end default (2 + c + n) d) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) rfl + have h3 := BlockFlow_Ws default (2 + c + n) e q + exact BlockFlow_eq (BlockFlow_trans h1 (BlockFlow_trans h2 h3)) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) (by omega) + +theorem S_tail_entry (l r : zB) (a b c n : Nat) : + (S l (specialN n r) a (1 + b) (2 + c) 0) [target_tm]⊢* + (crossW l (flow_tail n r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + c) 2) := + step_eq (by cfg_eq) + +theorem negativeN_large_start (l : zB) (p n e h k d0 : Nat) + (HP : P p) (E1 : p = 2 + n * 2 + d0) (E2 : p + 3 + n * 2 + e = h * 2) (Hh : 1 ≤ h) : + (negativeN l p n (h + k) e) [target_tm]⊢* + (crossW l (flow_tail n ((([1, 0, 0] : zF) ^ d0) +> default)) (k * 2) (([1, 0, 1, 0, 0, 1] : zF) + ^ h) (h * 2 - 1) 2) := by + refine step_bridge (negativeN_entry l p n (h + k) e d0 HP E1) (by cfg_eq) ?_ + refine step_bridge (Incs1 l (specialN n ((([1, 0, 0] : zF) ^ d0) +> default)) (k * 2) 1 0 0 h) + (by cfg_eq) ?_ + exact step_end (S_tail_entry l ((([1, 0, 0] : zF) ^ d0) +> default) (k * 2) h (h * 2 - 2) n) + (by cfg_eq) (by cfg_eq) + +theorem negativeN_large_cross (l : zB) (p n e h k d0 q M b_blk v a : Nat) + (HP : P p) (E1 : p = 2 + n * 2 + d0) (E2 : p + 3 + n * 2 + e = h * 2) (Hh : 1 ≤ h) + (E3 : 1 + d0 = e + q * 2) (EM : M = 4 + n * 4 + q) (EK : k + v = M) : + (negativeN ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ (v * 2 + a)) +> l)) + p n (h + k) e) [target_tm]⊢* + (crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ (M + b_blk + h)) (h * 2 + n + q * 2) e) := by + refine step_bridge (negativeN_large_start ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) + ^ (v * 2 + a)) +> l)) p n e h k d0 HP E1 E2 Hh) (by cfg_eq) ?_ + rcases v with _ | v + · refine step_bridge ((BlockFlow_whole (h * 2 - 2) + n d0 q e E3).block_flow.flow_cross ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ a) + +> l)) 0 h) (by cfg_eq) ?_ + exact step_end (crossW_absorb l default a b_blk (M + h) (h * 2 + n + q * 2) e) (by cfg_eq) + (by cfg_eq) + · exact step_end ((BlockFlow_whole (h * 2 - 2) n d0 q e E3).block_cross l a b_blk h k v + (by omega)) (by cfg_eq) (by cfg_eq) + +theorem negativeN_large_late (p n e h k d0 q M b_blk v u : Nat) + (HP : P p) (E1 : p = 2 + n * 2 + d0) (E2 : p + 3 + n * 2 + e = h * 2) (Hh : 1 ≤ h) (He : e ≤ 1) + (E3 : 1 + d0 = e + q * 2) (EM : M = 4 + n * 4 + q) (EK : k + v = M) : + (negativeN ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ (3 + v * 2 + u * 2)) + +> default)) p n (h + k) e) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + h * 2 + n + q * 2 + e)) +> ((([1, 1, 0] : zF) ^ (3 + (M + b_blk + h) + * 2)) +> ((([1, 0] : zF) ^ (1 + u * 2)) +> default))) {{B}}> default)) := by + refine step_bridge (negativeN_large_cross default p n e h k d0 q M b_blk v (3 + u * 2) + HP E1 E2 Hh E3 EM EK) (by cfg_eq) ?_ + exact step_end (crossW_finish default (1 + u * 2) (M + b_blk + h) (h * 2 + n + q * 2) e He) + (by cfg_eq) (by cfg_eq) + +theorem negativeN_large_short (p n e h k d0 q M b_blk v : Nat) + (HP : P p) (E1 : p = 2 + n * 2 + d0) (E2 : p + 3 + n * 2 + e = h * 2) (Hh : 1 ≤ h) (He : e ≤ 1) + (E3 : 1 + d0 = e + q * 2) (EM : M = 4 + n * 4 + q) (EK : k + v = M) : + (negativeN ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ (1 + v * 2)) +> default)) + p n (h + k) e) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + h * 2 + n + q * 2 + e)) +> ((([1, 1, 0] : zF) ^ (2 + (M + b_blk + h) + * 2)) +> (([1, 0] : zF) +> default))) {{B}}> default)) := by + refine step_bridge (negativeN_large_cross default p n e h k d0 q M b_blk v 1 HP E1 E2 Hh E3 EM EK) + (by cfg_eq) ?_ + exact step_end (crossW_short (M + b_blk + h) (h * 2 + n + q * 2) e He) (by cfg_eq) (by cfg_eq) + +theorem negativeN_large_root (p n e h k d0 q M b_blk s v : Nat) + (HP : P p) (E1 : p = 2 + n * 2 + d0) (E2 : p + 3 + n * 2 + e = h * 2) (Hh : 1 ≤ h) (He : e ≤ 1) + (E3 : 1 + d0 = e + q * 2) (EM : M = 4 + n * 4 + q) (EK : k + s + v + 1 = M) : + (negativeN ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) ^ (1 + s * 2)) +> default)) + p n (h + k) e) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + h * 2 + n + q * 2 + e)) +> ((([1, 1, 0] : zF) + ^ (2 + (k + s + b_blk + h) * 2)) +> ((([1, 0] : zF) ^ (3 + v * 2)) +> default))) + {{B}}> default)) := by + refine step_bridge (negativeN_large_start ((([1, 1, 0] : zF) ^ (b_blk * 2)) +> ((([1, 0] : zF) + ^ (1 + s * 2)) +> default)) p n e h k d0 HP E1 E2 Hh) (by cfg_eq) ?_ + refine step_bridge ((BlockFlow_whole (h * 2 - 2) n d0 q e E3).block_border b_blk h k s v + (by omega)) (by cfg_eq) ?_ + exact step_end (rootW_finish (v * 2) (k + s + b_blk + h) (h * 2 + n + q * 2) e He) (by cfg_eq) + (by cfg_eq) + +theorem rootW_finish_word0 (a : Nat) (w x y : zF) (c : Nat) (hw : Word w x y) : + (rootW default a w c 0) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + c)) +> (y.reverse +> ((([1, 0] : zF) ^ (3 + a)) +> default))) + {{B}}> default)) := by + rcases hw with ⟨e, hr, _⟩ + refine ReachesStar.trans (rootW_finish_word0_1 a w c) ?_ + have hws := word_shift e (([1, 0] : zF) +> ((([1, 0] : zF) ^ c) +> default)) + refine step_bridge (Word_U_1 _ _) (by rw [← hws]; rfl) ?_ + refine ReachesStar.trans (hr _ _) ?_ + exact step_end (rootW_finish_word_end _ (1 + c)) (by cfg_eq) (by cfg_eq) + +theorem crossW_finish_word0 (l : zB) (a : Nat) (w x y : zF) (c : Nat) (hw : Word w x y) : + (crossW l default (2 + a) w c 0) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + c)) +> (y.reverse +> ((([1, 1, 0] : zF) ^ 3) +> ((([1, 0] : zF) ^ a) + +> l)))) {{B}}> default)) := by + rcases hw with ⟨e, hr, _⟩ + refine ReachesStar.trans (crossW_finish_word0_1 l a w c) ?_ + have hws := word_shift e (([1, 0] : zF) +> ((([1, 0] : zF) ^ c) +> default)) + refine step_bridge (crossW_step_2 _ _) (by rw [← hws]; rfl) ?_ + refine ReachesStar.trans (hr _ _) ?_ + exact step_end (rootW_finish_word_end _ (1 + c)) (by cfg_eq) (by cfg_eq) + +theorem crossW_finish_word1 (l : zB) (a : Nat) (w x y : zF) (c : Nat) (hw : Word w x y) : + (crossW l default (2 + a) w c 1) [target_tm]⊢* + ((((([1, 0] : zF) ^ (2 + c)) +> (y.reverse +> ((([1, 1, 0] : zF) ^ 3) +> ((([1, 0] : zF) ^ a) + +> l)))) {{B}}> default)) := by + rcases hw with ⟨e, hr, _⟩ + refine ReachesStar.trans (crossW_finish_word1_1 l a w c) ?_ + have hws := word_shift e (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ c) +> default)) + refine step_bridge (crossW_step_2 _ _) (by rw [← hws]; rfl) ?_ + refine ReachesStar.trans (hr _ _) ?_ + exact step_end (rootW_finish_word_end _ (2 + c)) (by cfg_eq) (by cfg_eq) + +theorem rootW_finish_word1 (a : Nat) (w x y : zF) (c : Nat) (hw : Word w x y) : + (rootW default a w c 1) [target_tm]⊢* + ((((([1, 0] : zF) ^ (2 + c)) +> (y.reverse +> ((([1, 0] : zF) ^ (3 + a)) +> default))) + {{B}}> default)) := by + rcases hw with ⟨e, hr, _⟩ + refine ReachesStar.trans (rootW_finish_word1_1 a w c) ?_ + have hws := word_shift e (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ c) +> default)) + refine step_bridge (Word_U_1 _ _) (by rw [← hws]; rfl) ?_ + refine ReachesStar.trans (hr _ _) ?_ + exact step_end (rootW_finish_word_end _ (2 + c)) (by cfg_eq) (by cfg_eq) + +theorem scan_roots (a d n : Nat) : + (scan_root a (n * 2 + d)) [target_tm]⊢* (scan_root (n * 4 + a) d) := by + induction n generalizing a d with + | zero => exact step_eq (by cfg_eq) + | succ n ih => + refine step_bridge (scan_root_step a (n * 2 + d)) (by cfg_eq) ?_ + exact step_end (ih (4 + a) d) (by cfg_eq) (by cfg_eq) + +theorem final_zero_even (d : Nat) : + (final_scan 0 (d * 2)) [target_tm]⊢* (section_481 [3 + d * 4]) := by + refine ReachesStar.trans (final_zero_1 (d * 2)) ?_ + refine step_bridge (scan_roots 1 0 d) (by cfg_eq) ?_ + exact step_end (final_even_2 (d * 4)) (by cfg_eq) (by cfg_eq) + +theorem final_zero_odd (d : Nat) : + (final_scan 0 (1 + d * 2)) [target_tm]⊢* (section_481 [4 + d * 4]) := by + refine ReachesStar.trans (final_zero_1 (1 + d * 2)) ?_ + refine step_bridge (scan_roots 1 1 d) (by cfg_eq) ?_ + exact step_end (final_odd_2 (d * 4)) (by cfg_eq) (by cfg_eq) + +theorem final_one_even (d : Nat) : + (final_scan 1 (d * 2)) [target_tm]⊢* (section_481 [5 + d * 4]) := by + refine ReachesStar.trans (final_one_1 (d * 2)) ?_ + refine step_bridge (scan_roots 3 0 d) (by cfg_eq) ?_ + exact step_end (final_even_2 (2 + d * 4)) (by cfg_eq) (by cfg_eq) + +theorem final_one_odd (d : Nat) : + (final_scan 1 (1 + d * 2)) [target_tm]⊢* (section_481 [6 + d * 4]) := by + refine ReachesStar.trans (final_one_1 (1 + d * 2)) ?_ + refine step_bridge (scan_roots 3 1 d) (by cfg_eq) ?_ + exact step_end (final_odd_2 (2 + d * 4)) (by cfg_eq) (by cfg_eq) + +inductive Last : Nat → Nat → List Nat → Prop where + | Last0E (d : Nat) : Last 0 (d * 2) [3 + d * 4] + | Last0O (d : Nat) : Last 0 (1 + d * 2) [4 + d * 4] + | Last1E (d : Nat) : Last 1 (d * 2) [5 + d * 4] + | Last1O (d : Nat) : Last 1 (1 + d * 2) [6 + d * 4] + | LastEE (a d : Nat) : Last (2 + a * 2) (2 + a * 2 + d * 2) + [2 + a * 2 + d * 2, 2 + a * 2, 3 + d * 2] + | LastEO (a d : Nat) : Last (2 + a * 2) (1 + a * 2 + d * 2) + [1 + a * 2 + d * 2, 2 + a * 2, 1 + d * 2] + | LastOE (a d : Nat) : Last (3 + a * 2) (2 + a * 2 + d * 2) + [2 + a * 2 + d * 2, 2 + a * 2, 5 + d * 2] + | LastOO (a d : Nat) : Last (3 + a * 2) (3 + a * 2 + d * 2) + [3 + a * 2 + d * 2, 2 + a * 2, 5 + d * 2] + | LastBorder (a : Nat) : Last (4 + a * 2) (2 + a * 2) [2 + a * 2, 4 + a * 2, 1] + | LastOverflowO (a d : Nat) : Last (3 + d * 2 + a) (1 + d * 2) [1 + d * 2, 3 + d * 2, a] + | LastOverflowE (a d : Nat) : Last (5 + d * 2 + a) (2 + d * 2) [2 + d * 2, 5 + d * 2, a] + +theorem Last_spec (t m : Nat) (xs : List Nat) (h : Last t m xs) : + (final_scan t m) [target_tm]⊢* (section_481 xs) := by + rcases h with d | d | d | d | ⟨a, d⟩ | ⟨a, d⟩ | ⟨a, d⟩ | ⟨a, d⟩ | a | ⟨a, d⟩ | ⟨a, d⟩ + · exact final_zero_even d + · exact final_zero_odd d + · exact final_one_even d + · exact final_one_odd d + · exact step_end (even_left_even a d) (by cfg_eq) (by cfg_eq) + · exact step_end (even_left_odd a d) (by cfg_eq) (by cfg_eq) + · exact step_end (normal_even a d) (by cfg_eq) (by cfg_eq) + · exact step_end (normal_odd a d) (by cfg_eq) (by cfg_eq) + · exact step_end (border_even default a) (by cfg_eq) (by cfg_eq) + · exact step_end (left_overflow_odd default a d) (by cfg_eq) (by cfg_eq) + · exact step_end (left_overflow_even default a d) (by cfg_eq) (by cfg_eq) + +theorem parity (n : Nat) : ∃ k, n = k * 2 ∨ n = 1 + k * 2 := by + refine ⟨n / 2, ?_⟩ + omega + +theorem Last_eq {t1 t2 m1 m2 : Nat} {xs1 xs2 : List Nat} (h : Last t1 m1 xs1) + (ht : t1 = t2 := by omega) (hm : m1 = m2 := by omega) (hxs : xs1 = xs2 := by rfl) : + Last t2 m2 xs2 := by + subst ht; subst hm; subst hxs; exact h + +theorem Last_total (t m : Nat) (Hm : 0 < m) : ∃ xs, Last t m xs := by + rcases t with _ | _ | t + · rcases parity m with ⟨d, rfl | rfl⟩ + · exact ⟨_, Last.Last0E d⟩ + · exact ⟨_, Last.Last0O d⟩ + · rcases parity m with ⟨d, rfl | rfl⟩ + · exact ⟨_, Last.Last1E d⟩ + · exact ⟨_, Last.Last1O d⟩ + · rcases m with _ | m + · omega + · rcases parity t with ⟨a, rfl | rfl⟩ <;> rcases parity m with ⟨d, rfl | rfl⟩ + · by_cases hle : a ≤ d + · exact ⟨_, Last_eq (Last.LastEO a (d - a))⟩ + · exact ⟨_, Last_eq (Last.LastOverflowO (a * 2 - d * 2 - 1) d)⟩ + · by_cases hle : a ≤ d + · exact ⟨_, Last_eq (Last.LastEE a (d - a))⟩ + · by_cases heq : a = 1 + d + · exact ⟨_, Last_eq (Last.LastBorder d)⟩ + · exact ⟨_, Last_eq (Last.LastOverflowE (a * 2 - d * 2 - 3) d)⟩ + · by_cases hlt : a < d + · exact ⟨_, Last_eq (Last.LastOO a (d - a - 1))⟩ + · exact ⟨_, Last_eq (Last.LastOverflowO ((a - d) * 2) d)⟩ + · by_cases hle : a ≤ d + · exact ⟨_, Last_eq (Last.LastOE a (d - a))⟩ + · exact ⟨_, Last_eq (Last.LastOverflowE ((a - d - 1) * 2) d)⟩ + +theorem Last_progress (t m : Nat) (xs : List Nat) (H : Last t m xs) : + (final_scan t m) [target_tm]⊢⁺ (section_481 xs) := + evstep_progress (Last_spec t m xs H) (by ne_cfg) + +def last_output (t m : Nat) : List Nat := + let e := 1 - m % 2 + let r := t % 2 + if t ≤ 1 then [m * 2 + 2 + t * 2 + e] + else if t + r ≤ m + 1 + e then [m, t - r, m + 2 + r * 3 + e - t] + else [m, m + 2 + e, t - (m + 2 + e)] + +theorem Last_output (t m : Nat) (xs : List Nat) (H : Last t m xs) : + xs = last_output t m := by + cases H <;> dsimp only [last_output] <;> split_ifs <;> + (try simp only [List.cons.injEq, and_true, true_and]) <;> + ((repeat' constructor) <;> first | trivial | omega) + +theorem last_output_spec (t m : Nat) (H : 0 < m) : + (final_scan t m) [target_tm]⊢⁺ (section_481 (last_output t m)) := by + rcases Last_total t m H with ⟨xs, HL⟩ + rw [← Last_output t m xs HL] + exact Last_progress t m xs HL + +theorem good_section_formula (p b t : Nat) (HP : P p) (H : 0 < p + b) : + (section_481 [p, b, t]) [target_tm]⊢⁺ (section_481 (last_output t (p + b))) := by + refine evstep_progress_trans ?_ (last_output_spec t (p + b) H) + refine step_bridge (HP ((([1, 1, 0] : zF) ^ b) +> ((([1, 0] : zF) ^ t) +> default))) (by cfg_eq) + ?_ + exact step_end (pass_011 ((([1, 0] : zF) ^ t) +> default) ((([0, 1, 0] : zF) ^ p) +> default) b) + (by cfg_eq) (by cfg_eq) + +theorem S_short_section1 (b c : Nat) : + (S default default 3 (1 + b) c 1) [target_tm]⊢* (section_481 [2 + c, 4 + b * 2, 1]) := + step_end (S_short1 default b c) (by cfg_eq) (by cfg_eq) + +def S_odd_output (b c v d : Nat) : List Nat := + let edge := d + 2 + d % 2 + if 1 + v * 2 < edge then [1 + c + d, 2 + b * 2 + v * 2, edge - (1 + v * 2)] + else [1 + c + d, 3 + b * 2 + d + d % 2, 1 + v * 2 - edge] + +theorem S_odd_spec (b c v d : Nat) : + (S default default (1 + v * 2) (1 + b) c d) + [target_tm]⊢* (section_481 (S_odd_output b c v d)) := by + rcases parity d with ⟨r, rfl | rfl⟩ <;> dsimp only [S_odd_output] + · by_cases hlt : v < r + · rw [ite_eq_left (by omega)] + exact step_end (S_root_exit1 b c v (r - v - 1)) (by cfg_eq) (by cfg_eq) + · by_cases heq : v = r + · subst heq + rw [ite_eq_left (by omega)] + have he : v * 2 + 2 + v * 2 % 2 - (1 + v * 2) = 1 := by omega + rw [he] + refine step_bridge (Incs1 default default 1 (1 + b) c 0 v) (by cfg_eq) ?_ + exact step_end (S_short0 default (b + v) (c + v * 2)) (by cfg_eq) (by cfg_eq) + · rw [ite_eq_right (by omega)] + refine step_bridge (Incs1 default default (1 + (v - r) * 2) (1 + b) c 0 r) (by cfg_eq) ?_ + exact step_end (S_exit0 default ((v - r) * 2 - 1) (b + r) (c + r * 2)) (by cfg_eq) + (by cfg_eq) + · by_cases hle : v ≤ r + · rw [ite_eq_left (by omega)] + exact step_end (S_root_exit0 b c v (r - v)) (by cfg_eq) (by cfg_eq) + · by_cases heq : v = 1 + r + · subst v + rw [ite_eq_left (by omega)] + have he : 1 + r * 2 + 2 + (1 + r * 2) % 2 - (1 + (1 + r) * 2) = 1 := by omega + rw [he] + refine step_bridge (Incs1 default default 3 (1 + b) c 1 r) (by cfg_eq) ?_ + exact step_end (S_short_section1 (b + r) (c + r * 2)) (by cfg_eq) (by cfg_eq) + · rw [ite_eq_right (by omega)] + refine step_bridge (Incs1 default default (1 + (v - r) * 2) (1 + b) c 1 r) (by cfg_eq) ?_ + exact step_end (S_exit1 default ((v - r) * 2 - 3) (b + r) (c + r * 2)) (by cfg_eq) + (by cfg_eq) + +theorem S_odd_progress (b c v d : Nat) : + (S default default (1 + v * 2) (1 + b) c d) + [target_tm]⊢⁺ (section_481 (S_odd_output b c v d)) := + evstep_progress (S_odd_spec b c v d) (by ne_cfg) + +theorem odd_last_S (g j t : Nat) (HP : P (2 + g * 2)) : + (section_481 [(2 + g * 2) + (3 + g * 2), j * 2, t]) [target_tm]⊢* + (S default default t (2 + j + g) (1 + g * 2) 0) := by + refine step_bridge (return_last ((([1, 1, 0] : zF) ^ (j * 2)) +> ((([1, 0] : zF) ^ t) +> default)) + g HP) (by cfg_eq) ?_ + exact step_end (even_block ((([1, 0] : zF) ^ t) +> default) ((([0, 1, 1, 0, 1, 0] : zF) ^ (2 + g)) + +> ((([1, 0] : zF) ^ (1 + g * 2)) +> default)) j) (by cfg_eq) (by cfg_eq) + +theorem odd_gap_seed (g j t d : Nat) (HP : P (1 + g * 2 + d)) : + (section_481 [(1 + g * 2 + d) + (1 + g * 2), 1 + j * 2, t]) [target_tm]⊢* + (seed t (j + g) g d) := by + refine step_bridge (return_odd ((([1, 1, 0] : zF) ^ (1 + j * 2)) +> ((([1, 0] : zF) ^ t) + +> default)) g d HP) (by cfg_eq) ?_ + exact step_end (odd_seed g j t d) (by cfg_eq) (by cfg_eq) + +theorem odd_gap_S (g j t d : Nat) (HP : P (1 + g * 2 + d)) : + (section_481 [(1 + g * 2 + d) + (1 + g * 2), j * 2, t]) [target_tm]⊢* + (S default default t (1 + j + g) (g * 2) d) := by + refine step_bridge (return_odd ((([1, 1, 0] : zF) ^ (j * 2)) +> ((([1, 0] : zF) ^ t) +> default)) + g d HP) (by cfg_eq) ?_ + exact step_end (even_block ((([1, 0] : zF) ^ t) +> default) ((([0, 1, 1, 0, 1, 0] : zF) ^ (1 + g)) + +> ((([1, 0] : zF) ^ (g * 2)) +> (([0] : zF) +> ((([1, 0, 0] : zF) ^ d) +> default)))) j) + (by cfg_eq) (by cfg_eq) + +theorem seed_section (a b c d : Nat) : + (seed a b c d) [target_tm]⊢* (section_481 [1 + c * 2 + d, 2 + b * 2, 2 + a + d + d % 2]) := by + rcases parity d with ⟨r, rfl | rfl⟩ + · rcases r with _ | r + · exact step_end (seed_zero a b c) (by cfg_eq) (by cfg_eq) + · have hm : ((r + 1) * 2) % 2 = 0 := by omega + rw [hm] + exact step_end (seed_even a b c r) (by cfg_eq) (by cfg_eq) + · have hm : (1 + r * 2) % 2 = 1 := by omega + rw [hm] + exact step_end (seed_odd a b c r) (by cfg_eq) (by cfg_eq) + +theorem odd_last_even_formula (g j v : Nat) (H : P (2 + g * 2)) : + (section_481 [(2 + g * 2) + (3 + g * 2), j * 2, 1 + v * 2]) [target_tm]⊢⁺ + (section_481 (S_odd_output (1 + j + g) (1 + g * 2) v 0)) := by + refine evstep_progress_trans (odd_last_S g j (1 + v * 2) H) ?_ + exact step_end_plus_eq (S_odd_progress (1 + j + g) (1 + g * 2) v 0) (by cfg_eq) (by cfg_eq) + +theorem unary_progress (p k : Nat) (HP : P p) (H : 0 < p) : + (section_481 [p + k]) [target_tm]⊢⁺ (section_481 (last_output k p)) := by + refine evstep_progress_trans ?_ (last_output_spec k p H) + exact step_end (HP ((([1, 0] : zF) ^ k) +> default)) (by cfg_eq) (by cfg_eq) + +theorem rootTs (a b c d n : Nat) : + (rootT a b c (n * 2 + d)) [target_tm]⊢* (rootT (n * 2 + a) b (n * 2 + c) d) := by + induction n generalizing a c d with + | zero => exact step_eq (by cfg_eq) + | succ n ih => + refine step_bridge (rootT_step a b c (n * 2 + d)) (by cfg_eq) ?_ + exact step_end (ih (2 + a) (2 + c) d) (by cfg_eq) (by cfg_eq) + +def pred_output (n b t : Nat) : List Nat := + let h := n + 4 + n % 2 + if t < h then [1 + n, b + t - 1, h - t] else [1 + n, b + h - 1, t - h] + +theorem pred_root_formula (b n : Nat) : + (rootT 0 b 0 n) [target_tm]⊢* (section_481 [1 + n, 2 + b * 2, 3 + n + n % 2]) := by + rcases parity n with ⟨r, rfl | rfl⟩ + · have hm : (r * 2) % 2 = 0 := by omega + rw [hm] + refine step_bridge (rootTs 0 b 0 0 r) (by cfg_eq) ?_ + exact step_end (rootT_end0 (r * 2) b (r * 2)) (by cfg_eq) (by cfg_eq) + · have hm : (1 + r * 2) % 2 = 1 := by omega + rw [hm] + refine step_bridge (rootTs 0 b 0 1 r) (by cfg_eq) ?_ + exact step_end (rootT_end1 (r * 2) b (r * 2)) (by cfg_eq) (by cfg_eq) + +theorem pred_S_formula (b v n : Nat) : + S_odd_output (1 + b) 0 v n = pred_output n (2 + b * 2) (3 + v * 2) := by + dsimp only [S_odd_output, pred_output] + split_ifs <;> (try simp only [List.cons.injEq, and_true, true_and]) <;> + ((repeat' constructor) <;> first | trivial | omega) + +theorem pred_terminal (n b v : Nat) : + ((((([1, 1, 0] : zF) ^ (2 + b * 2)) +> ((([1, 0] : zF) ^ (1 + v * 2)) +> default)) <{{E}} + (([0, 1, 1] : zF) +> ((([0, 1, 0] : zF) ^ n) +> default)))) [target_tm]⊢⁺ + (section_481 (pred_output n (2 + b * 2) (1 + v * 2))) := by + refine evstep_progress ?_ (by ne_cfg) + rcases v with _ | v + · refine step_bridge (pred_root b n) (by cfg_eq) ?_ + dsimp only [pred_output] + rw [ite_eq_left (by omega)] + exact step_end (pred_root_formula b n) (by cfg_eq) (by cfg_eq) + · refine step_bridge (pred_S (1 + v * 2) b n) (by cfg_eq) ?_ + have heq : 1 + (v + 1) * 2 = 3 + v * 2 := by omega + rw [heq, ← pred_S_formula b v n] + exact step_end (S_odd_spec (1 + b) 0 v n) (by cfg_eq) (by cfg_eq) + +theorem pred_section (n b v : Nat) (HP : PP n) : + (section_481 [n, 2 + b * 2, 1 + v * 2]) [target_tm]⊢⁺ (section_481 (pred_output n (2 + b * 2) + (1 + v * 2))) := by + refine evstep_progress_trans ?_ (pred_terminal n b v) + exact step_end (HP ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> ((([1, 0] : zF) ^ (1 + v * 2)) + +> default))) (by cfg_eq) (by cfg_eq) + +theorem scan_lefts (r : zB) (a d n : Nat) : + (scan_left r a (n * 2 + d)) [target_tm]⊢* (scan_left r (n * 4 + a) d) := by + induction n generalizing a d with + | zero => exact step_eq (by cfg_eq) + | succ n ih => + refine step_bridge (scan_left_step r a (n * 2 + d)) (by cfg_eq) ?_ + exact step_end (ih (4 + a) d) (by cfg_eq) (by cfg_eq) + +theorem short_normalize (a n d : Nat) : + (scan_left (short_suffix n d) (1 + a) 0) [target_tm]⊢* + (rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + n)) (1 + n * 2) d) := + step_eq (by cfg_eq) + +theorem short_root (n j d : Nat) (HP : P (2 + n * 2 + d)) : + (section_481 [(2 + n * 2 + d) + (2 + n * 2), j * 2, 1]) [target_tm]⊢* + (rootW default (2 + j * 4) (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + n)) (1 + n * 2) d) := by + refine step_bridge (return_even ((([1, 1, 0] : zF) ^ (j * 2)) +> ((([1, 0] : zF) ^ 1) +> default)) + n d HP) (by cfg_eq) ?_ + refine step_bridge (pass_011 (([1, 0] : zF) +> default) (short_suffix n d) (j * 2)) (by cfg_eq) ?_ + refine step_bridge (scan_left_entry (short_suffix n d) (j * 2)) (by cfg_eq) ?_ + refine step_bridge (scan_lefts (short_suffix n d) 3 0 j) (by cfg_eq) ?_ + exact step_end (short_normalize (2 + j * 4) n d) (by cfg_eq) (by cfg_eq) + +theorem short_section (n j d : Nat) (HP : P (2 + n * 2 + d)) : + (section_481 [(2 + n * 2 + d) + (2 + n * 2), j * 2, 1]) [target_tm]⊢⁺ + (section_481 [2 + n * 2 + d, 2 + n * 2, 5 + j * 4 + d - d % 2]) := by + refine evstep_progress_trans (short_root n j d HP) ?_ + refine evstep_progress ?_ (by ne_cfg) + rcases parity d with ⟨r, rfl | rfl⟩ + · have hm : (r * 2) % 2 = 0 := by omega + rw [hm] + refine step_bridge (rootsW default (2 + j * 4) _ _ _ (1 + n * 2) 0 r (Word_pow _ _ _ (1 + n) + Word_V)) (by cfg_eq) ?_ + exact step_end (root_end0 (r * 2 + (2 + j * 4)) n (r * 2 + (1 + n * 2))) (by cfg_eq) (by cfg_eq) + · have hm : (1 + r * 2) % 2 = 1 := by omega + rw [hm] + refine step_bridge (rootsW default (2 + j * 4) _ _ _ (1 + n * 2) 1 r (Word_pow _ _ _ (1 + n) + Word_V)) (by cfg_eq) ?_ + exact step_end (root_end1 (r * 2 + (2 + j * 4)) n (r * 2 + (1 + n * 2))) (by cfg_eq) (by cfg_eq) + +def next_p (p : Nat) : Nat := p * 2 + 2 + (1 - p % 2) + +theorem P_next (p : Nat) (H : 3 ≤ p) (HP : P p) : P (next_p p) := by + dsimp only [next_p] + rcases parity p with ⟨a, rfl | rfl⟩ + · rcases a with _ | a + · omega + · have he1 : (a + 1) * 2 = 2 + a * 2 := by omega + have he2 : (a + 1) * 2 * 2 + 2 + (1 - (a + 1) * 2 % 2) = (2 + a * 2) + (5 + a * 2) := by omega + rw [he2] + exact P_S' a (he1 ▸ HP) + · have he2 : (1 + a * 2) * 2 + 2 + (1 - (1 + a * 2) % 2) = (1 + a * 2) + (3 + a * 2) := by omega + rw [he2] + exact P_S a HP + +inductive Chain : Nat → Prop where + | Chain0 : Chain 3 + | ChainS (p : Nat) : Chain p → Chain (next_p p) + +theorem next_p_grows (p : Nat) : p < next_p p := by + dsimp only [next_p]; omega + +theorem Chain_spec (p : Nat) (H : Chain p) : + 3 ≤ p ∧ P p ∧ (p % 16 = 3 ∨ p % 32 = 8) := by + induction H with + | Chain0 => refine ⟨by omega, P3, Or.inl rfl⟩ + | ChainS p _ ih => + rcases ih with ⟨Hp, HP, Hm⟩ + have hg := next_p_grows p + refine ⟨by omega, P_next p Hp HP, ?_⟩ + dsimp only [next_p] + rcases Hm with h16 | h32 + · right; omega + · left; omega + +def Band (p n : Nat) : Prop := Chain p ∧ p ≤ n ∧ n < next_p p + +theorem Band_total (n : Nat) (Hn : 3 ≤ n) : ∃ p, Band p n := by + induction n with + | zero => omega + | succ n ih => + by_cases heq : n = 2 + · subst heq + exact ⟨3, Chain.Chain0, by omega, by dsimp [next_p]; omega⟩ + · rcases ih (by omega) with ⟨p, HP, Hlo, Hhi⟩ + by_cases hlt : n + 1 < next_p p + · exact ⟨p, HP, by omega, hlt⟩ + · have hg := next_p_grows (next_p p) + exact ⟨next_p p, Chain.ChainS p HP, by omega, by omega⟩ + +def link (w : zF) (c d : Nat) (r : zB) : zB := + ([0, 1, 0, 0, 1] : zF) +> (w +> ((([1, 0] : zF) ^ c) +> (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ d) +> r)))) + +def clean_input (c d : Nat) (r : zB) : zB := + ((([1, 0] : zF) ^ c) +> (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ d) +> r))) + +theorem lpow_comm_single (w : zF) (n : Nat) : w ^ n ++ w = w ++ w ^ n := by + induction n with + | zero => simp only [list_pow_zero, List.nil_append, List.append_nil] + | succ n ih => + rw [list_pow_succ, List.append_assoc, ih, ← List.append_assoc] + +theorem reverse_power (w : zF) (n : Nat) : (w ^ n).reverse = (w.reverse) ^ n := by + induction n with + | zero => rfl + | succ n ih => + rw [list_pow_succ, List.reverse_append, ih, + list_pow_succ, lpow_comm_single] + +theorem rev_011011 : ([0, 1, 1, 0, 1, 1] : zF).reverse = [1, 1, 0, 1, 1, 0] := rfl +theorem rev_01 : ([0, 1] : zF).reverse = [1, 0] := rfl + +macro "solve_cfg_spine2" : tactic => + `(tactic| (first + | rfl + | apply app2_congr (by omega) (by omega) + | (apply app3_congr ?_ (by omega) (by omega); solve_spine; done) + | ((first | apply cfg_left_congr | apply cfg_right_congr) <;> (solve_spine; done)) + | (solve_spine; done))) + +macro "cfg_eq" : tactic => + `(tactic| first + | rfl + | (try dsimp only [Sim.toCfg, special, specialN, flow_tail, short_suffix, negativeN, loneN, + link, clean_input, + S, rootW, crossW, crossZ, rootZ, crossV, rootV, seed, final_scan, scan_root, + rootT, scan_left, scanW, section_481, section_side, w10, w110] + try simp only + [Nat.add_assoc, Nat.add_zero, Nat.zero_add, Nat.add_mul, Nat.mul_add, Nat.one_mul, + Nat.mul_one, Nat.mul_zero, Nat.zero_mul, + list_pow_zero, list_pow_succ, list_pow_one, + pow_add_1, pow_add_2, pow_add_3, pow_add_4, pow_add_5, + pow_add_right_2, pow_add_right_3, pow_add_right_4, pow_add_right_5, + pow_double3, + List.reverse_append, List.reverse_nil, reverse_power, rev_011011, rev_01, + List.nil_append, List.cons_append, List.append_assoc, + listblank_append_nil, listblank_append_cons, listblank_append_right_assoc, + shift2, shift3, shift6, + shift2_0, shift3_0_1, shift3_0_01, shift6_0_1, shift6_0_01, + pow_merge, ListBlank.cons_zero_default] + try ac_rfl + done) + | (try dsimp only [Sim.toCfg, special, specialN, flow_tail, short_suffix, negativeN, loneN, + link, clean_input, + S, rootW, crossW, rootZ, crossZ, rootV, crossV, seed, final_scan, scan_root, + rootT, scan_left, scanW, section_481, section_side, w10, w110] + try simp only [Nat.mul_zero, Nat.zero_mul, + List.reverse_append, List.reverse_nil, reverse_power, rev_011011, rev_01, + List.nil_append, List.cons_append, List.append_assoc, + listblank_append_nil, listblank_append_cons, listblank_append_right_assoc, + list_pow_zero, + pow_double3, pow_merge, fold2, fold3, fold6, ListBlank.cons_zero_default] + first | done | (solve_cfg_spine2; done)) + | (try dsimp only [Sim.toCfg, special, specialN, flow_tail, short_suffix, negativeN, loneN, + link, clean_input, + S, rootW, crossW, rootZ, crossZ, rootV, crossV, seed, final_scan, scan_root, + rootT, scan_left, scanW, section_481, section_side, w10, w110] + try simp only + [Nat.add_assoc, Nat.add_zero, Nat.zero_add, Nat.add_mul, Nat.mul_add, Nat.one_mul, + Nat.mul_one, Nat.mul_zero, Nat.zero_mul, + list_pow_zero, list_pow_succ, + pow_add_1, pow_add_2, pow_add_3, pow_add_4, pow_add_5, + pow_add_right_2, pow_add_right_3, pow_add_right_4, pow_add_right_5, + pow_double3, + List.reverse_append, List.reverse_nil, reverse_power, rev_011011, rev_01, + List.nil_append, List.cons_append, List.append_assoc, + listblank_append_nil, listblank_append_cons, listblank_append_right_assoc, + shift2, shift3, shift6, + shift2_0, shift3_0_1, shift3_0_01, shift6_0_1, shift6_0_01, + pow_merge, ListBlank.cons_zero_default] + try simp only [fold2, fold3, fold6, pow_merge, ListBlank.cons_zero_default] + first | done | (solve_cfg_spine2; done))) + +theorem crossW_one_word (r : zB) (w x y : zF) (c d : Nat) (hw : Word w x y) : + (crossW default r 1 w c (2 + d)) [target_tm]⊢* + (rootW r 0 (([1, 0, 1, 0, 0, 1] : zF) ++ w) (2 + c) d) := by + rcases hw with ⟨e, hr, hl⟩ + refine ReachesStar.trans (crossW_one_word_1 r w c d) ?_ + have hws := word_shift e (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ c) +> (([0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ d) +> r)))) + refine step_bridge (crossW_one_word_2 _ _) (by rw [← hws]; rfl) ?_ + refine ReachesStar.trans (hr _ _) ?_ + refine step_bridge (rootW_step_3 _ r c d) (by cfg_eq) ?_ + refine ReachesStar.trans (hl _ _) ?_ + exact step_end (crossW_one_word_4 r w c d) (by cfg_eq) (by cfg_eq) + +theorem crossW_join (l r : zB) (a : Nat) (w : zF) (c : Nat) (v : zF) (c' d : Nat) : + (crossW l (link v c' d r) a w c 0) [target_tm]⊢* + (crossW l r a (w ++ ([1, 0] : zF) ^ (1 + c) ++ [1, 0, 1, 0, 0, 1] ++ v) c' d) := + step_eq (by cfg_eq) + +theorem rootW_join (r : zB) (a : Nat) (w : zF) (c : Nat) (v : zF) (c' d : Nat) : + (rootW (link v c' d r) a w c 0) [target_tm]⊢* + (rootW r a (w ++ ([1, 0] : zF) ^ (1 + c) ++ [1, 0, 1, 0, 0, 1] ++ v) c' d) := + step_eq (by cfg_eq) + +theorem Flow_W_word (r : zB) (w x y : zF) (c d : Nat) (hw : Word w x y) : + Flow (fun l a b => crossW l r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) c (2 + d)) + (fun a b => rootW r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) c (2 + d)) + (fun l a b => crossW l r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) (2 + c) d) + (fun a b => rootW r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) (2 + c) d) 1 := by + have HW : ∀ b, Word ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) ((([1, 0, 0, 1, 1, 0] : zF) ^ b) ++ x) + ((([0, 1, 1, 0, 1, 1] : zF) ^ b) ++ y) := + fun b => Word_app _ _ _ _ _ _ (Word_pow _ _ _ b Word_V) hw + refine ⟨?_, ?_, ?_⟩ + · intro l a b + exact step_end (crossW_step l r a _ _ _ c d (HW b)) (by cfg_eq) (by cfg_eq) + · intro a b + exact step_end (rootW_step r a _ _ _ c d (HW b)) (by cfg_eq) (by cfg_eq) + · intro s v b hsv + have hs : s = 0 := by omega + have hv : v = 0 := by omega + subst hs; subst hv + exact step_end (crossW_one_word r _ _ _ c d (HW b)) (by cfg_eq) (by cfg_eq) + +theorem Flow_Ws_word (r : zB) (w x y : zF) (c d n : Nat) (hw : Word w x y) : + Flow (fun l a b => crossW l r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) c (n * 2 + d)) + (fun a b => rootW r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) c (n * 2 + d)) + (fun l a b => crossW l r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) (n * 2 + c) d) + (fun a b => rootW r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) (n * 2 + c) d) n := by + induction n generalizing c with + | zero => + exact Flow_eq (Flow_id _ _) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) rfl + | succ n ih => + have h1 : Flow (fun l a b => crossW l r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) c ((n + 1) + * 2 + d)) + (fun a b => rootW r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) c ((n + 1) * 2 + d)) + (fun l a b => crossW l r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) (2 + c) + (n * 2 + d)) + (fun a b => rootW r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ w) (2 + c) (n * 2 + d)) + 1 := + Flow_eq (Flow_W_word r w x y c (n * 2 + d) hw) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) rfl + exact Flow_eq (Flow_trans h1 (ih (2 + c))) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) (by omega) + +theorem Flow_join (r : zB) (w : zF) (c : Nat) (v : zF) (c' d : Nat) : + Flow (fun l a n => crossW l (link v c' d r) a ((([1, 0, 1, 0, 0, 1] : zF) ^ n) ++ w) c 0) + (fun a n => rootW (link v c' d r) a ((([1, 0, 1, 0, 0, 1] : zF) ^ n) ++ w) c 0) + (fun l a n => crossW l r a ((([1, 0, 1, 0, 0, 1] : zF) ^ n) ++ w ++ ([1, 0] : zF) ^ (1 + c) + ++ [1, 0, 1, 0, 0, 1] ++ v) c' d) + (fun a n => rootW r a ((([1, 0, 1, 0, 0, 1] : zF) ^ n) ++ w ++ ([1, 0] : zF) ^ (1 + c) + ++ [1, 0, 1, 0, 0, 1] ++ v) c' d) 0 := by + refine ⟨?_, ?_, fun s v b h => by omega⟩ + · intro l a n; exact step_end (crossW_join l r a ((([1, 0, 1, 0, 0, 1] : zF) ^ n) ++ w) c v c' d) + (by cfg_eq) (by cfg_eq) + · intro a n; exact step_end (rootW_join r a ((([1, 0, 1, 0, 0, 1] : zF) ^ n) ++ w) c v c' d) + (by cfg_eq) (by cfg_eq) + +inductive Route : Nat → Nat → zB → Nat → zF → Nat → Nat → zB → Prop where + | Route_done (c n e : Nat) (r : zB) : Route c (n * 2 + e) r n [] (n * 2 + c) e r + | Route_more (c n : Nat) (v x y : zF) (c' d : Nat) (r : zB) (m : Nat) (w : zF) (C_out e : Nat) + (R : zB) : + Word v x y → Route c' d r m w C_out e R → + Route c (n * 2) (link v c' d r) (n + m) + (([1, 0] : zF) ^ (1 + n * 2 + c) ++ [1, 0, 1, 0, 0, 1] ++ v ++ w) C_out e R + +theorem Route_eq {c1 c2 d1 d2 : Nat} {r1 r2 : zB} {n1 n2 : Nat} {w1 w2 : zF} {C1 C2 e1 e2 : Nat} {R1 + R2 : zB} + (h : Route c1 d1 r1 n1 w1 C1 e1 R1) + (hc : c1 = c2 := by omega) (hd : d1 = d2 := by omega) (hr : r1 = r2 := by cfg_eq) + (hn : n1 = n2 := by omega) + (hw : w1 = w2 := + by simp only + [list_pow_zero, list_pow_one, List.append_nil, List.nil_append, List.append_assoc]) + (hC : C1 = C2 := by omega) (he : e1 = e2 := by omega) (hR : R1 = R2 := by cfg_eq) : + Route c2 d2 r2 n2 w2 C2 e2 R2 := by + subst hc; subst hd; subst hr; subst hn; subst hw; subst hC; subst he; subst hR; exact h + +theorem Word_link (v x y : zF) (c : Nat) (z X Y : zF) (hv : Word v x y) (hz : Word z X Y) : + Word (v ++ ([1, 0] : zF) ^ c ++ [1, 0, 1, 0, 0, 1] ++ z) + (x ++ ([1, 0] : zF) ^ c ++ [1, 0, 0, 1, 1, 0] ++ X) + (y ++ ([0, 1] : zF) ^ c ++ [0, 1, 1, 0, 1, 1] ++ Y) := by + exact Word_app _ _ _ _ _ _ (Word_app _ _ _ _ _ _ (Word_app _ _ _ _ _ _ hv (Word_pow _ _ _ c + Word_U)) Word_V) hz + +theorem Route_flow (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (R : zB) + (H : Route c d r n w C_out e R) (v x y : zF) (HW : Word v x y) : + Flow (fun l a b => crossW l r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ v) c d) + (fun a b => rootW r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ v) c d) + (fun l a b => crossW l R a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ v ++ w) C_out e) + (fun a b => rootW R a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ v ++ w) C_out e) n := by + induction H generalizing v x y with + | Route_done c n e r => + exact Flow_eq (Flow_Ws_word r v x y c e n HW) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) rfl + | Route_more c n z X Y c' d r m w C_out e R Hz HR ih => + have h1 : Flow (fun l a b => crossW l (link z c' d r) a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ v) + c (n * 2)) + (fun a b => rootW (link z c' d r) a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ v) + c (n * 2)) + (fun l a b => crossW l (link z c' d r) a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ v) + (n * 2 + c) 0) + (fun a b => rootW (link z c' d r) a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ v) + (n * 2 + c) 0) n := + Flow_eq (Flow_Ws_word (link z c' d r) v x y c 0 n HW) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) rfl + have h2 := Flow_join r v (n * 2 + c) z c' d + have HV := Word_link v x y (1 + n * 2 + c) z X Y HW Hz + have h3 : Flow (fun l a b => crossW l r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ v ++ ([1, 0] : zF) + ^ (1 + (n * 2 + c)) ++ [1, 0, 1, 0, 0, 1] ++ z) c' d) + (fun a b => rootW r a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ v ++ ([1, 0] : zF) + ^ (1 + (n * 2 + c)) ++ [1, 0, 1, 0, 0, 1] ++ z) c' d) + (fun l a b => crossW l R a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) + ++ (v ++ ([1, 0] : zF) ^ (1 + n * 2 + c) + ++ [1, 0, 1, 0, 0, 1] ++ z) ++ w) C_out e) + (fun a b => rootW R a ((([1, 0, 1, 0, 0, 1] : zF) ^ b) ++ (v ++ ([1, 0] : zF) + ^ (1 + n * 2 + c) ++ [1, 0, 1, 0, 0, 1] ++ z) ++ w) C_out e) m := + Flow_eq (ih _ _ _ HV) (by intros; cfg_eq) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) rfl + exact Flow_eq (Flow_trans h1 (Flow_trans h2 h3)) (by intros; cfg_eq) (by intros; cfg_eq) + (by intros; cfg_eq) (by intros; cfg_eq) (by omega) + +theorem Route_word (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (R : zB) + (H : Route c d r n w C_out e R) : ∃ x y, Word w x y := by + induction H with + | Route_done => exact ⟨[], [], Word_nil⟩ + | Route_more c n v x y c' d r m w C_out e R HV HR ih => + rcases ih with ⟨X, Y, HW⟩ + exact ⟨_, _, Word_app _ _ _ _ _ _ (Word_app _ _ _ _ _ _ (Word_app _ _ _ _ _ _ (Word_pow _ _ _ (1 + + n * 2 + c) Word_U) Word_V) HV) HW⟩ + +theorem Route_cut (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (R : zB) + (H : Route c d r n w C_out e R) (k : Nat) (Hk : k ≤ n) : + ∃ c' d' r' u v, Route c d r k u c' d' r' ∧ Route c' d' r' (n - k) v C_out e R ∧ w = u ++ v := by + induction H generalizing k with + | Route_done c n e r => + refine ⟨k * 2 + c, (n - k) * 2 + e, r, [], [], ?_, ?_, rfl⟩ + · exact Route_eq (Route.Route_done c k ((n - k) * 2 + e) r) + · exact Route_eq (Route.Route_done (k * 2 + c) (n - k) e r) + | Route_more c n z X Y c0 d0 r0 m w C_out e R Hz HR ih => + by_cases hle : k ≤ n + · refine ⟨k * 2 + c, (n - k) * 2, link z c0 d0 r0, [], ([1, 0] : zF) ^ (1 + n * 2 + c) + ++ [1, 0, 1, 0, 0, 1] ++ z ++ w, ?_, ?_, rfl⟩ + · exact Route_eq (Route.Route_done c k ((n - k) * 2) (link z c0 d0 r0)) + · have heq : 1 + (n - k) * 2 + (k * 2 + c) = 1 + n * 2 + c := by omega + exact Route_eq (Route.Route_more (k * 2 + c) (n - k) z X Y c0 d0 r0 m w C_out e R Hz HR) + (hw := by rw [heq]) + · rcases ih (k - n) (by omega) with ⟨c', d', r', u, v, HU, HV, EW⟩ + refine ⟨c', d', r', ([1, 0] : zF) ^ (1 + n * 2 + c) ++ [1, 0, 1, 0, 0, 1] ++ z ++ u, v, ?_, + ?_, ?_⟩ + · exact Route_eq (Route.Route_more c n z X Y c0 d0 r0 (k - n) u c' d' r' Hz HU) + · exact Route_eq HV + · rw [EW]; simp only [List.append_assoc] + +theorem crossW_next (l r : zB) (w x y : zF) (c d : Nat) (hw : Word w x y) : + (crossW l r 1 w c (2 + d)) [target_tm]⊢* (scanW l r w (2 + c) d) := by + rcases hw with ⟨e, hr, hl⟩ + refine ReachesStar.trans (crossW_next_1 l r w c d) ?_ + have hws := word_shift e (([1, 0, 1, 0] : zF) +> ((([1, 0] : zF) ^ c) +> (([0, 1, 0] : zF) + +> ((([0, 1, 0] : zF) ^ d) +> r)))) + refine step_bridge (crossW_one_word_2 _ _) (by rw [← hws]; rfl) ?_ + refine ReachesStar.trans (hr _ _) ?_ + refine step_bridge (rootW_step_3 _ r c d) (by cfg_eq) ?_ + refine ReachesStar.trans (hl _ _) ?_ + exact step_end (crossW_next_4 l r w c d) (by cfg_eq) (by cfg_eq) + +theorem scan_pair (l r : zB) (n d : Nat) : + ((((([1, 0] : zF) ^ (2 + n * 2)) +> l) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (2 + n * 2 + d)) +> r)))) [target_tm]⊢* + (scanW l r (([1, 0, 1, 0, 0, 1] : zF) ^ n) (1 + n * 2) d) := by + refine step_bridge (scan_pair_1 l r n d) (by cfg_eq) ?_ + refine step_bridge (Incs1 l (([1, 0] : zF) +> ((([0, 1, 0] : zF) ^ d) +> r)) 1 1 0 0 n) + (by cfg_eq) ?_ + exact step_end (edge1 l ((([0, 1, 0] : zF) ^ d) +> r) (1 + n) (n * 2)) (by cfg_eq) (by cfg_eq) + +theorem scanW_join (l r : zB) (v : zF) (c : Nat) (w : zF) (c' d : Nat) : + (scanW l (link w c' d r) v c 0) [target_tm]⊢* + (scanW l r (v ++ ([1, 0] : zF) ^ (1 + c) ++ [1, 0, 1, 0, 0, 1] ++ w) c' d) := + step_eq (by cfg_eq) + +theorem Route_scan_zero (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (R : zB) + (H : Route c d r n w C_out e R) (hn : n = 0) (l : zB) (v : zF) : + (scanW l r v c d) [target_tm]⊢* (scanW l R (v ++ w) C_out e) := by + induction H generalizing v with + | Route_done c n e r => + subst hn; exact step_eq (by cfg_eq) + | Route_more c n z X Y c' d r m w C_out e R Hz HR ih => + have hn0 : n = 0 := by omega + have hm0 : m = 0 := by omega + subst hn0 + refine ReachesStar.trans (scanW_join l r v c z c' d) ?_ + exact step_end (ih hm0 (v ++ ([1, 0] : zF) ^ (1 + c) ++ [1, 0, 1, 0, 0, 1] ++ z)) (by cfg_eq) + (by cfg_eq) + +theorem Route_next (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (R : zB) + (H : Route c d r n w C_out e R) (hn : n = 1) (l : zB) (v x y : zF) (HW : Word v x y) : + (crossW l r 1 v c d) [target_tm]⊢* (scanW l R (v ++ w) C_out e) := by + induction H generalizing v x y with + | Route_done c n e r => + subst hn + exact step_end (crossW_next l r v x y c e HW) (by cfg_eq) (by cfg_eq) + | Route_more c n z X Y c' d r m w C_out e R Hz HR ih => + rcases n with _ | n + · have hm1 : m = 1 := by omega + refine step_bridge (crossW_join l r 1 v c z c' d) (by cfg_eq) ?_ + exact step_end (ih hm1 _ _ _ (Word_link v x y (1 + c) z X Y HW Hz)) (by cfg_eq) (by cfg_eq) + · have hn0 : n = 0 := by omega + have hm0 : m = 0 := by omega + subst hn0; subst hm0 + refine step_bridge (crossW_next l (link z c' d r) v x y c 0 HW) (by cfg_eq) ?_ + refine ReachesStar.trans (scanW_join l r v (2 + c) z c' d) ?_ + exact step_end (Route_scan_zero _ _ _ _ _ _ _ _ HR rfl l (v ++ ([1, 0] : zF) ^ (3 + c) + ++ [1, 0, 1, 0, 0, 1] ++ z)) (by cfg_eq) (by cfg_eq) + +theorem Route_scan (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (R : zB) + (H : Route c d r n w C_out e R) (a : Nat) (l : zB) (v x y : zF) (Ha : a ≤ n) (HW : Word v x y) : + ∃ c' d' r' u z, Route c' d' r' (n - a) z C_out e R ∧ w = u ++ z ∧ + (∃ X Y, Word u X Y) ∧ + (scanW ((([1, 0] : zF) ^ (a * 2)) +> l) r v c d) [target_tm]⊢* + (scanW l r' ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ v ++ u) c' d') := by + rcases a with _ | a + · refine ⟨c, d, r, [], w, Route_eq H, rfl, ⟨[], [], Word_nil⟩, step_eq (by cfg_eq)⟩ + · rcases Route_cut c d r n w C_out e R H a (by omega) with ⟨c1, d1, r1, u0, z0, H0, H1, E0⟩ + rcases Route_cut c1 d1 r1 (n - a) z0 C_out e R H1 1 (by omega) with ⟨c2, d2, r2, u1, z1, H2, H3, + E1⟩ + rcases Route_word _ _ _ _ _ _ _ _ H0 with ⟨X, Y, HU⟩ + rcases Route_word _ _ _ _ _ _ _ _ H2 with ⟨X1, Y1, HU1⟩ + refine ⟨c2, d2, r2, u0 ++ u1, z1, Route_eq H3, by rw [E0, E1, List.append_assoc], ⟨X ++ X1, + Y ++ Y1, Word_app _ _ _ _ _ _ HU HU1⟩, ?_⟩ + have HV : Word ([1, 0, 1, 0, 0, 1] ++ v) ([1, 0, 0, 1, 1, 0] ++ x) ([0, 1, 1, 0, 1, 1] ++ y) := + Word_app _ _ _ _ _ _ Word_V HW + refine step_bridge (scanW_entry l r (1 + a * 2) v c d) (by cfg_eq) ?_ + refine step_bridge ((Route_flow _ _ _ _ _ _ _ _ H0 _ _ _ HV).flow_cross l 1 0) (by cfg_eq) ?_ + have HZ : Word ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ [1, 0, 1, 0, 0, 1] ++ v ++ u0) + ((([1, 0, 0, 1, 1, 0] : zF) ^ a) ++ [1, 0, 0, 1, 1, 0] ++ x ++ X) + ((([0, 1, 1, 0, 1, 1] : zF) ^ a) ++ [0, 1, 1, 0, 1, 1] ++ y ++ Y) := + Word_app _ _ _ _ _ _ (Word_app _ _ _ _ _ _ (Word_app _ _ _ _ _ _ (Word_pow _ _ _ a Word_V) + Word_V) HW) HU + exact step_end (Route_next _ _ _ _ _ _ _ _ H2 rfl l _ _ _ HZ) (by cfg_eq) (by cfg_eq) + +def Counter (r : zB) (n : Nat) (w : zF) (C_out e : Nat) : Prop := + ∃ d s, r = ((([0, 1, 0] : zF) ^ (2 + d)) +> s) ∧ Route 1 d s n w C_out e default + +theorem Counter_eq {r1 r2 : zB} {n1 n2 : Nat} {w1 w2 : zF} {C1 C2 e1 e2 : Nat} + (h : Counter r1 n1 w1 C1 e1) + (hr : r1 = r2 := by cfg_eq) (hn : n1 = n2 := by omega) + (hw : w1 = w2 := + by simp only + [list_pow_zero, list_pow_one, List.append_nil, List.nil_append, List.append_assoc]) + (hC : C1 = C2 := by omega) (he : e1 = e2 := by omega) : + Counter r2 n2 w2 C2 e2 := by + subst hr; subst hn; subst hw; subst hC; subst he; exact h + +theorem Counter_step (l r : zB) (n : Nat) (w : zF) (C_out e a b : Nat) + (HR : Counter r n w C_out e) (Ha : a ≤ n) : + ∃ r', Counter r' (n - a + b) ((([1, 0] : zF) ^ (2 + b * 2)) ++ (([1, 0, 1, 0, 0, 1] : zF) + ^ (1 + a)) ++ w) C_out e ∧ + ((((([1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> l)) + <{{C}} (([0, 1] : zF) +> r))) [target_tm]⊢* + (l <{{C}} (([0, 1] : zF) +> r')) := by + rcases HR with ⟨d, s, rfl, HR⟩ + rcases Route_scan 1 d s n w C_out e default HR a ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> l) + [] [] [] Ha Word_nil with + ⟨c', d', s', u, z, HZ, EW, ⟨X, Y, HU⟩, HS⟩ + refine ⟨((([0, 1, 0] : zF) ^ (2 + b * 2)) +> link ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ u) + c' d' s'), ?_, ?_⟩ + · refine ⟨b * 2, link ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ u) c' d' s', rfl, ?_⟩ + have HV : Word ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ u) ((([1, 0, 0, 1, 1, 0] : zF) ^ a) ++ X) + ((([0, 1, 1, 0, 1, 1] : zF) ^ a) ++ Y) := + Word_app _ _ _ _ _ _ (Word_pow _ _ _ a Word_V) HU + have heq : 1 + b * 2 + 1 = 2 + b * 2 := by omega + exact Route_eq (Route.Route_more 1 b _ _ _ c' d' s' (n - a) z C_out e default HV HZ) + (hw := by rw [heq, EW, pow_add_1]; simp only [List.append_assoc]) + · refine step_bridge (scan_pair ((([1, 0] : zF) ^ (a * 2)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2)) + +> l)) s 0 d) (by cfg_eq) ?_ + refine ReachesStar.trans HS ?_ + exact step_end (pass_011 l (link ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ u) c' d' s') (2 + b * 2)) + (by cfg_eq) (by cfg_eq) + +theorem Counter_root (r : zB) (n : Nat) (w : zF) (C_out e s : Nat) + (HR : Counter r n w C_out e) (Hs : s ≤ n) : + ((((([1, 0] : zF) ^ (3 + s * 2)) +> default) <{{C}} (([0, 1] : zF) +> r))) [target_tm]⊢* + (rootW default (2 + (n - s) * 2) ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + s)) ++ w) C_out e) := by + rcases HR with ⟨d, r0, rfl, HR⟩ + rcases Route_cut 1 d r0 n w C_out e default HR s Hs with ⟨c', d', r', u, z, HU, HZ, EW⟩ + rcases Route_word _ _ _ _ _ _ _ _ HU with ⟨X, Y, HW⟩ + refine step_bridge (scan_pair ((([1, 0] : zF) ^ (1 + s * 2)) +> default) r0 0 d) (by cfg_eq) ?_ + refine step_bridge (scanW_entry default r0 (s * 2) [] 1 d) (by cfg_eq) ?_ + refine step_bridge ((Route_flow _ _ _ _ _ _ _ _ HU _ _ _ Word_V).flow_cross default 0 0) + (by cfg_eq) ?_ + have hcz := crossW_zero r' ((([1, 0, 1, 0, 0, 1] : zF) ^ s) ++ [1, 0, 1, 0, 0, 1] ++ u) c' d' + refine ReachesStar.trans hcz ?_ + have HV : Word ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + s)) ++ u) ((([1, 0, 0, 1, 1, 0] : zF) ^ (1 + s)) + ++ X) ((([0, 1, 1, 0, 1, 1] : zF) ^ (1 + s)) ++ Y) := + Word_app _ _ _ _ _ _ (Word_pow _ _ _ (1 + s) Word_V) HW + refine step_end ((Route_flow _ _ _ _ _ _ _ _ HZ _ _ _ HV).flow_root 2 0) ?_ ?_ + · rw [pow_add_1]; cfg_eq + · rw [EW]; cfg_eq + +theorem Counter_cross (r : zB) (n : Nat) (w : zF) (C_out e s : Nat) + (HR : Counter r n w C_out e) : + ((((([1, 0] : zF) ^ (5 + n * 2 + s * 2)) +> default) <{{C}} (([0, 1] : zF) +> r))) [target_tm]⊢* + (crossW default default (2 + s * 2) ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + n)) ++ w) + C_out e) := by + rcases HR with ⟨d, r0, rfl, HR⟩ + refine step_bridge (scan_pair ((([1, 0] : zF) ^ (3 + n * 2 + s * 2)) +> default) r0 0 d) + (by cfg_eq) ?_ + refine step_bridge (scanW_entry default r0 (2 + n * 2 + s * 2) [] 1 d) (by cfg_eq) ?_ + refine step_end ((Route_flow _ _ _ _ _ _ _ _ HR _ _ _ Word_V).flow_cross default (2 + s * 2) 0) + (by cfg_eq) ?_ + rw [pow_add_1]; cfg_eq + +theorem rootW_terminal (a : Nat) (w x y : zF) (c e : Nat) (He : e ≤ 1) (HW : Word w x y) : + (rootW default a w c e) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + c + e)) +> (y.reverse +> ((([1, 0] : zF) ^ (3 + a)) +> default))) + {{B}}> default)) := by + rcases e with _ | _ | e + · exact step_end (rootW_finish_word0 a w x y c HW) (by cfg_eq) (by cfg_eq) + · exact step_end (rootW_finish_word1 a w x y c HW) (by cfg_eq) (by cfg_eq) + · omega + +theorem crossW_terminal (l : zB) (a : Nat) (w x y : zF) (c e : Nat) (He : e ≤ 1) (HW : Word w x y) : + (crossW l default (2 + a) w c e) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + c + e)) +> (y.reverse +> ((([1, 1, 0] : zF) ^ 3) +> ((([1, 0] : zF) + ^ a) +> l)))) {{B}}> default)) := by + rcases e with _ | _ | e + · exact step_end (crossW_finish_word0 l a w x y c HW) (by cfg_eq) (by cfg_eq) + · exact step_end (crossW_finish_word1 l a w x y c HW) (by cfg_eq) (by cfg_eq) + · omega + +theorem Counter_normal (r : zB) (n : Nat) (w : zF) (C_out e s : Nat) (x y : zF) + (HR : Counter r n w C_out e) (Hs : s ≤ n) (He : e ≤ 1) (HW : Word w x y) : + ((((([1, 0] : zF) ^ (3 + s * 2)) +> default) <{{C}} (([0, 1] : zF) +> r))) [target_tm]⊢⁺ + ((((([1, 0] : zF) ^ (1 + C_out + e)) +> (((([0, 1, 1, 0, 1, 1] : zF) ^ (1 + s) ++ y).reverse) + +> ((([1, 0] : zF) ^ (5 + (n - s) * 2)) +> default))) {{B}}> default)) := by + refine evstep_progress ?_ (by ne_cfg) + refine ReachesStar.trans (Counter_root r n w C_out e s HR Hs) ?_ + exact step_end (rootW_terminal (2 + (n - s) * 2) + _ _ _ C_out e He (Word_app _ _ _ _ _ _ (Word_pow _ _ _ (1 + s) Word_V) HW)) (by cfg_eq) + (by cfg_eq) + +theorem Counter_overflow (r : zB) (n : Nat) (w : zF) (C_out e s : Nat) (x y : zF) + (HR : Counter r n w C_out e) (He : e ≤ 1) (HW : Word w x y) : + ((((([1, 0] : zF) ^ (5 + n * 2 + s * 2)) +> default) <{{C}} (([0, 1] : zF) +> r))) [target_tm]⊢⁺ + ((((([1, 0] : zF) ^ (1 + C_out + e)) +> (((([0, 1, 1, 0, 1, 1] : zF) ^ (1 + n) ++ y).reverse) + +> ((([1, 1, 0] : zF) ^ 3) +> ((([1, 0] : zF) ^ (s * 2)) +> default)))) + {{B}}> default)) := by + refine evstep_progress ?_ (by ne_cfg) + refine ReachesStar.trans (Counter_cross r n w C_out e s HR) ?_ + exact step_end (crossW_terminal default (s * 2) + _ _ _ C_out e He (Word_app _ _ _ _ _ _ (Word_pow _ _ _ (1 + n) Word_V) HW)) (by cfg_eq) + (by cfg_eq) + +def column_side (l : zB) : List (Nat × Nat) → zB + | [] => l + | (a, b) :: cs => + ((([1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> column_side l cs)) + +def column_word : List (Nat × Nat) → zF + | [] => [] + | (a, b) :: cs => + column_word cs ++ ([1, 0] : zF) ^ (2 + b * 2) ++ ([1, 0, 1, 0, 0, 1] : zF) ^ (1 + a) + +def column_image : List (Nat × Nat) → zF + | [] => [] + | (a, b) :: cs => + column_image cs ++ ([0, 1] : zF) ^ (2 + b * 2) ++ ([0, 1, 1, 0, 1, 1] : zF) ^ (1 + a) + +inductive ColumnRun : Nat → List (Nat × Nat) → Nat → Prop where + | Columns_nil (n : Nat) : ColumnRun n [] n + | Columns_cons (n a b : Nat) (cs : List (Nat × Nat)) (m : Nat) : + a ≤ n → ColumnRun (n - a + b) cs m → ColumnRun n ((a, b) :: cs) m + +theorem column_word_spec (cs : List (Nat × Nat)) : ∃ x, Word (column_word cs) + x (column_image cs) := by + induction cs with + | nil => exact ⟨[], Word_nil⟩ + | cons ab cs ih => + rcases ab with ⟨a, b⟩ + rcases ih with ⟨x, HW⟩ + exact ⟨_, Word_app _ _ _ _ _ _ (Word_app _ _ _ _ _ _ HW (Word_pow _ _ _ (2 + b * 2) Word_U)) + (Word_pow _ _ _ (1 + a) Word_V)⟩ + +theorem Counter_columns (n : Nat) (cs : List (Nat × Nat)) (m : Nat) (H : ColumnRun n cs m) + (l r : zB) (w : zF) (C_out e : Nat) (HR : Counter r n w C_out e) : + ∃ r', Counter r' m (column_word cs ++ w) C_out e ∧ + (column_side l cs <{{C}} (([0, 1] : zF) +> r)) [target_tm]⊢* (l <{{C}} (([0, 1] : zF) + +> r')) := by + induction H generalizing l r w with + | Columns_nil n => exact ⟨r, HR, step_eq rfl⟩ + | Columns_cons n a b cs m Ha H ih => + rcases Counter_step (column_side l cs) r n w C_out e a b HR Ha with ⟨r1, H1, HS⟩ + rcases ih l r1 _ H1 with ⟨r2, H2, HT⟩ + refine ⟨r2, Counter_eq H2 (hw := by dsimp [column_word]; simp only [List.append_assoc]), + ReachesStar.trans HS HT⟩ + +theorem Counter_columns_normal (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (cs : List (Nat × Nat)) + (m s : Nat) (x y : zF) + (HR : Counter r n w C_out e) (HC : ColumnRun n cs m) (Hs : s ≤ m) (He : e ≤ 1) + (HW : Word (column_word cs ++ w) x y) : + (column_side (((([1, 0] : zF) ^ (3 + s * 2)) +> default)) cs <{{C}} (([0, 1] : zF) +> r)) + [target_tm]⊢⁺ + ((((([1, 0] : zF) ^ (1 + C_out + e)) +> (((([0, 1, 1, 0, 1, 1] : zF) ^ (1 + s) ++ y).reverse) + +> ((([1, 0] : zF) ^ (5 + (m - s) * 2)) +> default))) {{B}}> default)) := by + rcases Counter_columns n cs m HC (((([1, 0] : zF) ^ (3 + s * 2)) +> default)) + r w C_out e HR with ⟨r', HT, HS⟩ + exact evstep_progress_trans HS (Counter_normal r' m _ C_out e s x y HT Hs He HW) + +theorem Counter_columns_overflow (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (cs : List (Nat × Nat)) + (m s : Nat) (x y : zF) + (HR : Counter r n w C_out e) (HC : ColumnRun n cs m) (He : e ≤ 1) + (HW : Word (column_word cs ++ w) x y) : + (column_side (((([1, 0] : zF) ^ (5 + m * 2 + s * 2)) +> default)) cs <{{C}} (([0, 1] : zF) + +> r)) [target_tm]⊢⁺ + ((((([1, 0] : zF) ^ (1 + C_out + e)) +> (((([0, 1, 1, 0, 1, 1] : zF) ^ (1 + m) ++ y).reverse) + +> ((([1, 1, 0] : zF) ^ 3) +> ((([1, 0] : zF) ^ (s * 2)) +> default)))) + {{B}}> default)) := by + rcases Counter_columns n cs m HC (((([1, 0] : zF) ^ (5 + m * 2 + s * 2)) +> default)) + r w C_out e HR with ⟨r', HT, HS⟩ + exact evstep_progress_trans HS (Counter_overflow r' m _ C_out e s x y HT He HW) + +theorem Counter_base (n e : Nat) : + Counter (((([0, 1, 0] : zF) ^ (2 + n * 2 + e)) +> default)) n [] (1 + n * 2) e := + ⟨n * 2 + e, default, by cfg_eq, Route_eq (Route.Route_done 1 n e default)⟩ + +theorem Counter_link (b : Nat) (v x y : zF) (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) + (HV : Word v x y) (HR : Route c d r n w C_out e default) : + Counter (((([0, 1, 0] : zF) ^ (2 + b * 2)) +> link v c d r)) (b + n) + ((([1, 0] : zF) ^ (2 + b * 2)) ++ [1, 0, 1, 0, 0, 1] ++ v ++ w) C_out e := by + have heq : 1 + b * 2 + 1 = 2 + b * 2 := by omega + exact ⟨b * 2, link v c d r, rfl, + Route_eq (Route.Route_more 1 b v x y c d r n w C_out e default HV HR) (hw := by rw [heq])⟩ + +theorem Counter_gap (g b d e : Nat) : + Counter (((([0, 1, 0] : zF) ^ (2 + b * 2)) +> link ((([1, 0, 1, 0, 0, 1] : zF) ^ g)) (1 + g * 2) + (d * 2 + e) default)) + (b + d) ((([1, 0] : zF) ^ (2 + b * 2)) ++ (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + g))) + (1 + g * 2 + d * 2) e := by + have h1 := Counter_link b _ _ _ (1 + g * 2) (d * 2 + e) default d [] (d * 2 + (1 + g * 2)) e + (Word_pow _ _ _ g Word_V) (Route.Route_done (1 + g * 2) d e default) + exact Counter_eq h1 (hw := by rw [pow_add_1]; simp only [List.append_nil, List.append_assoc]) + +theorem counter_begin (l : zB) (p b : Nat) (HP : P p) : + ((((([1, 0] : zF) ^ p) +> ((([1, 1, 0] : zF) ^ b) +> l)) {{B}}> default)) [target_tm]⊢* + (l <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (p + b)) +> default))) := by + refine ReachesStar.trans (HP ((([1, 1, 0] : zF) ^ b) +> l)) ?_ + exact step_end (pass_011 l ((([0, 1, 0] : zF) ^ p) +> default) b) (by cfg_eq) (by cfg_eq) + +theorem counter_begin_gap (l : zB) (g b d e : Nat) (HP : P (2 + g * 2 + (d * 2 + e))) : + ((((([1, 0] : zF) ^ ((2 + g * 2 + (d * 2 + e)) + (2 + g * 2))) +> ((([1, 1, 0] : zF) + ^ (2 + b * 2)) +> l)) {{B}}> default)) [target_tm]⊢* + (l <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (2 + b * 2)) + +> link ((([1, 0, 1, 0, 0, 1] : zF) ^ g)) (1 + g * 2) (d * 2 + e) default))) := by + refine ReachesStar.trans (return_even ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> l) g (d * 2 + e) HP) ?_ + exact step_end (pass_011 l _ (2 + b * 2)) (by cfg_eq) (by cfg_eq) + +inductive SectionStart (l : zB) : Nat → zF → Nat → Nat → Cfg (Fin 2) (Fin 6) → Prop where + | Start_good (d b e : Nat) : P (2 + d * 2 + e) → + SectionStart l (1 + d + b) [] (3 + d * 2 + b * 2) e + ((((([1, 0] : zF) ^ (2 + d * 2 + e)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> l)) + {{B}}> default)) + | Start_gap (g b d e : Nat) : P (2 + g * 2 + (d * 2 + e)) → + SectionStart l (b + d) ((([1, 0] : zF) ^ (2 + b * 2)) ++ (([1, 0, 1, 0, 0, 1] : zF) + ^ (1 + g))) + (1 + g * 2 + d * 2) e + ((((([1, 0] : zF) ^ ((2 + g * 2 + (d * 2 + e)) + (2 + g * 2))) +> ((([1, 1, 0] : zF) + ^ (2 + b * 2)) +> l)) {{B}}> default)) + +theorem SectionStart_spec (l : zB) (n : Nat) (w : zF) (C_out e : Nat) (c : Cfg (Fin 2) (Fin 6)) + (H : SectionStart l n w C_out e c) : + ∃ r, Counter r n w C_out e ∧ c [target_tm]⊢* (l <{{C}} (([0, 1] : zF) +> r)) := by + rcases H with ⟨d, b, e, HP⟩ | ⟨g, b, d, e, HP⟩ + · refine ⟨((([0, 1, 0] : zF) ^ ((2 + d * 2 + e) + (2 + b * 2))) +> default), ?_, + counter_begin l (2 + d * 2 + e) (2 + b * 2) HP⟩ + exact Counter_eq (Counter_base (1 + d + b) e) + · exact ⟨_, Counter_gap g b d e, counter_begin_gap l g b d e HP⟩ + +theorem section_columns_normal (n : Nat) (w : zF) (C_out e : Nat) (c : Cfg (Fin 2) (Fin 6)) + (cs : List (Nat × Nat)) (m s : Nat) (x y : zF) + (HS : SectionStart (column_side (((([1, 0] : zF) ^ (3 + s * 2)) +> default)) cs) n w C_out e c) + (HC : ColumnRun n cs m) (Hs : s ≤ m) (He : e ≤ 1) (HW : Word (column_word cs ++ w) x y) : + c [target_tm]⊢⁺ + ((((([1, 0] : zF) ^ (1 + C_out + e)) +> (((([0, 1, 1, 0, 1, 1] : zF) ^ (1 + s) ++ y).reverse) + +> ((([1, 0] : zF) ^ (5 + (m - s) * 2)) +> default))) {{B}}> default)) := by + rcases SectionStart_spec _ _ _ _ _ _ HS with ⟨r, HR, HT⟩ + exact evstep_progress_trans HT (Counter_columns_normal r n w C_out e cs m s x y HR HC Hs He HW) + +theorem section_columns_overflow (n : Nat) (w : zF) (C_out e : Nat) (c : Cfg (Fin 2) (Fin 6)) + (cs : List (Nat × Nat)) (m s : Nat) (x y : zF) + (HS : SectionStart (column_side (((([1, 0] : zF) ^ (5 + m * 2 + s * 2)) +> default)) cs) + n w C_out e c) + (HC : ColumnRun n cs m) (He : e ≤ 1) (HW : Word (column_word cs ++ w) x y) : + c [target_tm]⊢⁺ + ((((([1, 0] : zF) ^ (1 + C_out + e)) +> (((([0, 1, 1, 0, 1, 1] : zF) ^ (1 + m) ++ y).reverse) + +> ((([1, 1, 0] : zF) ^ 3) +> ((([1, 0] : zF) ^ (s * 2)) +> default)))) + {{B}}> default)) := by + rcases SectionStart_spec _ _ _ _ _ _ HS with ⟨r, HR, HT⟩ + exact evstep_progress_trans HT (Counter_columns_overflow r n w C_out e cs m s x y HR HC He HW) + +inductive EraseWord : zF → Nat → Nat → Prop where + | Erase_nil : EraseWord [] 0 0 + | Erase_V (n : Nat) (w : zF) (u v : Nat) : + EraseWord w u v → EraseWord ((([1, 0, 1, 0, 0, 1] : zF) ^ n) ++ w) u (n + v) + | Erase_pair (j k : Nat) (w : zF) (u v : Nat) : + EraseWord w u v → EraseWord ((([1, 0] : zF) ^ (2 + j * 2)) ++ (([1, 0, 1, 0, 0, 1] : zF) + ^ (1 + k)) ++ w) (1 + j + u) (1 + k + v) + +theorem EraseWord_eq {w1 w2 : zF} {u1 u2 v1 v2 : Nat} + (h : EraseWord w1 u1 v1) + (hw : w1 = w2 := + by simp only + [pow_add_1, list_pow_zero, list_pow_one, List.append_nil, List.nil_append, + List.append_assoc]) + (hu : u1 = u2 := by omega) (hv : v1 = v2 := by omega) : + EraseWord w2 u2 v2 := by + subst hw; subst hu; subst hv; exact h + +structure Pass (C : zB → Nat → Nat → Cfg (Fin 2) (Fin 6)) + (R : Nat → Nat → Cfg (Fin 2) (Fin 6)) + (D : zB → Nat → Nat → Cfg (Fin 2) (Fin 6)) + (T : Nat → Nat → Cfg (Fin 2) (Fin 6)) (n : Nat) : Prop where + pass_flow : Flow C R D T n + pass_even : ∀ s v b, s + v + 1 = n → (C default (2 + s * 2) b) [target_tm]⊢* (T (2 + v * 2) + (1 + s + b)) + +theorem Pass_id (C : zB → Nat → Nat → Cfg (Fin 2) (Fin 6)) (R : Nat → Nat → Cfg (Fin 2) (Fin 6)) : + Pass C R C R 0 := + ⟨Flow_id C R, fun s v b h => by omega⟩ + +theorem Pass_eq {C1 C2 R1 R2 D1 D2 T1 T2} {n1 n2 : Nat} + (h : Pass C1 R1 D1 T1 n1) + (hC : ∀ l a b, C1 l a b = C2 l a b := by intros; cfg_eq) + (hR : ∀ a b, R1 a b = R2 a b := by intros; cfg_eq) + (hD : ∀ l a b, D1 l a b = D2 l a b := by intros; cfg_eq) + (hT : ∀ a b, T1 a b = T2 a b := by intros; cfg_eq) + (hn : n1 = n2 := by omega) : + Pass C2 R2 D2 T2 n2 := by + have eC : C1 = C2 := by funext l a b; exact hC l a b + have eR : R1 = R2 := by funext a b; exact hR a b + have eD : D1 = D2 := by funext l a b; exact hD l a b + have eT : T1 = T2 := by funext a b; exact hT a b + subst eC; subst eR; subst eD; subst eT; subst hn; exact h + +theorem Pass_trans {C R D T F U} {n m : Nat} (h1 : Pass C R D T n) (h2 : Pass D T F U m) : + Pass C R F U (n + m) := by + refine ⟨Flow_trans h1.pass_flow h2.pass_flow, ?_⟩ + intro s v b H + by_cases hle : n ≤ s + · refine step_bridge (h1.pass_flow.flow_cross default (2 + (s - n) * 2) b) (by cfg_eq) ?_ + exact step_end (h2.pass_even (s - n) v (n + b) (by omega)) (by cfg_eq) (by cfg_eq) + · refine ReachesStar.trans (h1.pass_even s (n - s - 1) b (by omega)) ?_ + exact step_end (h2.pass_flow.flow_root (2 + (n - s - 1) * 2) (1 + s + b)) (by cfg_eq) + (by cfg_eq) + +theorem Pass_W (r : zB) (c d : Nat) : + Pass (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (2 + d)) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (2 + d)) + (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c) d) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c) d) 1 := by + refine ⟨Flow_W r c d, ?_⟩ + intro s v b E + have hs : s = 0 := by omega + have hv : v = 0 := by omega + subst hs; subst hv + refine step_bridge ((Flow_W r c d).flow_cross default 0 b) (by cfg_eq) ?_ + exact step_end (crossW_zero r (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + b)) (2 + c) d) (by cfg_eq) + (by cfg_eq) + +theorem Pass_V (r : zB) (c e : Nat) : + Pass (fun l a b => crossV l r a b (3 + c) (1 + e)) + (fun a b => rootV r a b (3 + c) (1 + e)) + (fun l a b => crossV l r a b (4 + c) e) + (fun a b => rootV r a b (4 + c) e) 2 := by + refine ⟨Flow_V r c e, ?_⟩ + intro s v b E + rcases s with _ | _ | s + · have hv : v = 1 := by omega + subst hv + exact step_end (crossV_two r b c e) (by cfg_eq) (by cfg_eq) + · have hv : v = 0 := by omega + subst hv + refine step_bridge (crossV_step default r 0 b c e) (by cfg_eq) ?_ + exact step_end (crossV_zero r (2 + b) (4 + c) e) (by cfg_eq) (by cfg_eq) + · omega + +theorem Pass_Z (r : zB) (c e : Nat) : + Pass (fun l a b => crossZ l r a b (3 + c) (2 + e)) + (fun a b => rootZ r a b (3 + c) (2 + e)) + (fun l a b => crossZ l r a b (3 + c) e) + (fun a b => rootZ r a b (3 + c) e) 2 := by + refine ⟨Flow_Z r c e, ?_⟩ + intro s v b E + rcases s with _ | _ | s + · have hv : v = 1 := by omega + subst hv + exact step_end (crossZ_two r b c e) (by cfg_eq) (by cfg_eq) + · have hv : v = 0 := by omega + subst hv + refine step_bridge (crossZ_step default r 0 b c e) (by cfg_eq) ?_ + exact step_end (crossZ_zero r (2 + b) (3 + c) e) (by cfg_eq) (by cfg_eq) + · omega + +theorem Pass_V_end (r : zB) (c e : Nat) : + Pass (fun l a b => crossV l ((([1, 0] : zF) ^ (1 + e)) +> r) a b (3 + c) 0) + (fun a b => rootV ((([1, 0] : zF) ^ (1 + e)) +> r) a b (3 + c) 0) + (fun l a b => crossZ l r a b (4 + c) e) + (fun a b => rootZ r a b (4 + c) e) 2 := by + refine ⟨Flow_V_end r c e, ?_⟩ + intro s v b E + rcases s with _ | _ | s + · have hv : v = 1 := by omega + subst hv + exact step_end (crossVend_two r b c e) (by cfg_eq) (by cfg_eq) + · have hv : v = 0 := by omega + subst hv + refine step_bridge (crossV_end default r 0 b c e) (by cfg_eq) ?_ + exact step_end (crossZ_zero r (2 + b) (4 + c) e) (by cfg_eq) (by cfg_eq) + · omega + +theorem Pass_Ws (r : zB) (c d n : Nat) : + Pass (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (n * 2 + d)) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c (n * 2 + d)) + (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (n * 2 + c) d) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (n * 2 + c) d) n := by + induction n generalizing c with + | zero => exact Pass_eq (Pass_id _ _) + | succ n ih => + have h1 : Pass (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c ((n + 1) * 2 + d)) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c ((n + 1) * 2 + d)) + (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c) (n * 2 + d)) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c) (n * 2 + d)) 1 := + Pass_eq (Pass_W r c (n * 2 + d)) + exact Pass_eq (Pass_trans h1 (ih (2 + c))) + +theorem Pass_Vs (r : zB) (c e n : Nat) : + Pass (fun l a b => crossV l r a b (3 + c) (e + n)) + (fun a b => rootV r a b (3 + c) (e + n)) + (fun l a b => crossV l r a b (3 + c + n) e) + (fun a b => rootV r a b (3 + c + n) e) (n * 2) := by + induction n generalizing c e with + | zero => exact Pass_eq (Pass_id _ _) + | succ n ih => + have h1 : Pass (fun l a b => crossV l r a b (3 + c) (e + (n + 1))) + (fun a b => rootV r a b (3 + c) (e + (n + 1))) + (fun l a b => crossV l r a b (3 + (1 + c)) (e + n)) + (fun a b => rootV r a b (3 + (1 + c)) (e + n)) 2 := + Pass_eq (Pass_V r c (e + n)) + exact Pass_eq (Pass_trans h1 (ih (1 + c) e)) + +theorem Pass_Zs (r : zB) (c e n : Nat) : + Pass (fun l a b => crossZ l r a b (3 + c) (e + n * 2)) + (fun a b => rootZ r a b (3 + c) (e + n * 2)) + (fun l a b => crossZ l r a b (3 + c) e) + (fun a b => rootZ r a b (3 + c) e) (n * 2) := by + induction n generalizing e with + | zero => exact Pass_eq (Pass_id _ _) + | succ n ih => + have h1 : Pass (fun l a b => crossZ l r a b (3 + c) (e + (n + 1) * 2)) + (fun a b => rootZ r a b (3 + c) (e + (n + 1) * 2)) + (fun l a b => crossZ l r a b (3 + c) (e + n * 2)) + (fun a b => rootZ r a b (3 + c) (e + n * 2)) 2 := + Pass_eq (Pass_Z r c (e + n * 2)) + exact Pass_eq (Pass_trans h1 (ih e)) + +theorem Pass_Z_to_V (r : zB) (c k : Nat) : + Pass (fun l a b => crossZ l ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) +> r) a b (3 + c) 1) + (fun a b => rootZ ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) +> r) a b (3 + c) 1) + (fun l a b => crossV l r a b (3 + c) k) + (fun a b => rootV r a b (3 + c) k) 2 := + Pass_eq (Pass_Z (([1, 0, 0, 1] : zF) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ k) +> r)) c 0) + +theorem Pass_Z_back (r : zB) (c d : Nat) : + Pass (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + d)) +> r)) + a b (4 + c) 0) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + d)) +> r)) a b (4 + c) 0) + (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + c) (2 + d)) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + c) (2 + d)) 2 := + Pass_eq (Pass_Z (([1, 0] : zF) +> ((([0, 1, 0] : zF) ^ d) +> r)) (1 + c) 0) + +theorem Pass_Z_empty (c : Nat) : + Pass (fun l a b => crossZ l (([1, 0, 1] : zF) +> default) a b (4 + c) 0) + (fun a b => rootZ (([1, 0, 1] : zF) +> default) a b (4 + c) 0) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c) 0) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + c) 0) 2 := by + refine ⟨⟨?_, ?_, ?_⟩, ?_⟩ + · intro l a b; exact step_end (crossZ_empty l a b c) (by cfg_eq) (by cfg_eq) + · intro a b; exact step_end (rootZ_empty a b c) (by cfg_eq) (by cfg_eq) + · intro s v b E + rcases s with _ | _ | s + · have hv : v = 1 := by omega + subst hv + exact step_end (crossZ_empty_one b c) (by cfg_eq) (by cfg_eq) + · have hv : v = 0 := by omega + subst hv + exact step_end (crossZ_empty_three b c) (by cfg_eq) (by cfg_eq) + · omega + · intro s v b E + rcases s with _ | _ | s + · have hv : v = 1 := by omega + subst hv + exact step_end (crossZ_empty_two b c) (by cfg_eq) (by cfg_eq) + · have hv : v = 0 := by omega + subst hv + refine step_bridge (crossZ_empty default 0 b c) (by cfg_eq) ?_ + exact step_end (crossW_zero default (([1, 0, 1, 0, 0, 1] : zF) ^ (2 + b)) (2 + c) 0) + (by cfg_eq) (by cfg_eq) + · omega + +theorem crossW_last_one (b c e : Nat) (He : e ≤ 1) : + (crossW default default 1 (([1, 0, 1, 0, 0, 1] : zF) ^ b) c e) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + c + e)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> (([1, 0] : zF) + +> default))) {{B}}> default)) := + crossW_short b c e He + +theorem EraseWord_app (w : zF) (u v : Nat) (z : zF) (x y : Nat) + (H : EraseWord w u v) (K : EraseWord z x y) : EraseWord (w ++ z) (u + x) (v + y) := by + induction H with + | Erase_nil => exact EraseWord_eq K + | Erase_V n w u v _ ih => exact EraseWord_eq (EraseWord.Erase_V n (w ++ z) (u + x) (v + y) ih) + | Erase_pair j k w u v _ ih => + exact EraseWord_eq (EraseWord.Erase_pair j k (w ++ z) (u + x) (v + y) ih) + +theorem EraseWord_word (w : zF) (u v : Nat) (H : EraseWord w u v) : ∃ x y, Word w x y := by + induction H with + | Erase_nil => exact ⟨[], [], Word_nil⟩ + | Erase_V n w u v _ ih => + rcases ih with ⟨X, Y, HW⟩ + exact ⟨_, _, Word_app _ _ _ _ _ _ (Word_pow _ _ _ n Word_V) HW⟩ + | Erase_pair j k w u v _ ih => + rcases ih with ⟨X, Y, HW⟩ + exact ⟨_, _, Word_app _ _ _ _ _ _ (Word_app _ _ _ _ _ _ (Word_pow _ _ _ (2 + j * 2) Word_U) + (Word_pow _ _ _ (1 + k) Word_V)) HW⟩ + +inductive RRoute : Nat → Nat → zB → Nat → zF → Nat → Nat → zB → Prop where + | RRoute_done (j n e : Nat) (r : zB) : RRoute (1 + j * 2) (n * 2 + e) r n [] (1 + (j + n) * 2) e r + | RRoute_more (j n : Nat) (v : zF) (u q c' d : Nat) (r : zB) (m : Nat) (w : zF) (C_out e : Nat) + (R : zB) : + EraseWord v u q → RRoute c' d r m w C_out e R → + RRoute (1 + j * 2) (n * 2) (link v c' d r) (n + m) + (([1, 0] : zF) ^ (2 + (j + n) * 2) ++ [1, 0, 1, 0, 0, 1] ++ v ++ w) C_out e R + +theorem RRoute_eq {c1 c2 d1 d2 : Nat} {r1 r2 : zB} {n1 n2 : Nat} {w1 w2 : zF} {C1 C2 e1 e2 : Nat} + {R1 R2 : zB} + (h : RRoute c1 d1 r1 n1 w1 C1 e1 R1) + (hc : c1 = c2 := by omega) (hd : d1 = d2 := by omega) (hr : r1 = r2 := by cfg_eq) + (hn : n1 = n2 := by omega) + (hw : w1 = w2 := + by simp only + [list_pow_zero, list_pow_one, List.append_nil, List.nil_append, List.append_assoc]) + (hC : C1 = C2 := by omega) (he : e1 = e2 := by omega) (hR : R1 = R2 := by cfg_eq) : + RRoute c2 d2 r2 n2 w2 C2 e2 R2 := by + subst hc; subst hd; subst hr; subst hn; subst hw; subst hC; subst he; subst hR; exact h + +theorem RRoute_forget (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (R : zB) + (H : RRoute c d r n w C_out e R) : Route c d r n w C_out e R := by + induction H with + | RRoute_done j n e r => exact Route_eq (Route.Route_done (1 + j * 2) n e r) + | RRoute_more j n v u q c' d r m w C_out e R HV HR ih => + rcases EraseWord_word v u q HV with ⟨X, Y, HW⟩ + have heq : 1 + n * 2 + (1 + j * 2) = 2 + (j + n) * 2 := by omega + exact Route_eq (Route.Route_more (1 + j * 2) n v X Y c' d r m w C_out e R HW ih) (hw := + by rw [heq]) + +theorem RRoute_erase (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (R : zB) + (H : RRoute c d r n w C_out e R) : ∃ u v, EraseWord w u v := by + induction H with + | RRoute_done => exact ⟨0, 0, EraseWord.Erase_nil⟩ + | RRoute_more j n z u q c' d r m w C_out e R HZ HR ih => + rcases ih with ⟨x, y, HW⟩ + refine ⟨1 + (j + n) + (u + x), 1 + (q + y), ?_⟩ + exact EraseWord_eq (EraseWord.Erase_pair (j + n) 0 (z ++ w) (u + x) (q + y) + (EraseWord_app z u q w x y HZ HW)) + +theorem RRoute_cut (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (R : zB) + (H : RRoute c d r n w C_out e R) (k : Nat) (Hk : k ≤ n) : + ∃ c' d' r' u v, RRoute c d r k u c' d' r' ∧ RRoute c' d' r' (n - k) + v C_out e R ∧ w = u ++ v := by + induction H generalizing k with + | RRoute_done j n e r => + refine ⟨1 + (j + k) * 2, (n - k) * 2 + e, r, [], [], ?_, ?_, rfl⟩ + · exact RRoute_eq (RRoute.RRoute_done j k ((n - k) * 2 + e) r) + · exact RRoute_eq (RRoute.RRoute_done (j + k) (n - k) e r) + | RRoute_more j n z x y c0 d0 r0 m w C_out e R HZ HR ih => + by_cases hle : k ≤ n + · refine ⟨1 + (j + k) * 2, (n - k) * 2, link z c0 d0 r0, [], ([1, 0] : zF) ^ (2 + (j + n) * 2) + ++ [1, 0, 1, 0, 0, 1] ++ z ++ w, ?_, ?_, rfl⟩ + · exact RRoute_eq (RRoute.RRoute_done j k ((n - k) * 2) (link z c0 d0 r0)) + · have heq : 2 + (j + k + (n - k)) * 2 = 2 + (j + n) * 2 := by omega + exact RRoute_eq (RRoute.RRoute_more (j + k) (n - k) z x y c0 d0 r0 m w C_out e R HZ HR) + (hw := by rw [heq]) + · rcases ih (k - n) (by omega) with ⟨c', d', r', u, v, HU, HV, EW⟩ + refine ⟨c', d', r', ([1, 0] : zF) ^ (2 + (j + n) * 2) ++ [1, 0, 1, 0, 0, 1] ++ z ++ u, v, ?_, + ?_, ?_⟩ + · exact RRoute_eq (RRoute.RRoute_more j n z x y c0 d0 r0 (k - n) u c' d' r' HZ HU) + · exact RRoute_eq HV + · rw [EW]; simp only [List.append_assoc] + +theorem scanW_consume (l : zB) (c d : Nat) (r : zB) (a : Nat) (u : zF) (c1 d1 : Nat) (r1 : zB) + (v : zF) (c2 d2 : Nat) (r2 : zB) (w x y : zF) + (HU : Route c d r a u c1 d1 r1) (HV : Route c1 d1 r1 1 v c2 d2 r2) (HW : Word w x y) : + (scanW ((([1, 0] : zF) ^ (2 + a * 2)) +> l) r w c d) [target_tm]⊢* + (scanW l r2 ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + a)) ++ w ++ u ++ v) c2 d2) := by + rcases Route_word _ _ _ _ _ _ _ _ HU with ⟨X, Y, EU⟩ + have H1 : Word ([1, 0, 1, 0, 0, 1] ++ w) ([1, 0, 0, 1, 1, 0] ++ x) ([0, 1, 1, 0, 1, 1] ++ y) := + Word_app _ _ _ _ _ _ Word_V HW + refine step_bridge (scanW_entry l r (1 + a * 2) w c d) (by cfg_eq) ?_ + refine step_bridge ((Route_flow _ _ _ _ _ _ _ _ HU _ _ _ H1).flow_cross l 1 0) (by cfg_eq) ?_ + have H2 : Word ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ [1, 0, 1, 0, 0, 1] ++ w ++ u) + ((([1, 0, 0, 1, 1, 0] : zF) ^ a) ++ [1, 0, 0, 1, 1, 0] ++ x ++ X) + ((([0, 1, 1, 0, 1, 1] : zF) ^ a) ++ [0, 1, 1, 0, 1, 1] ++ y ++ Y) := + Word_app _ _ _ _ _ _ (Word_app _ _ _ _ _ _ (Word_app _ _ _ _ _ _ (Word_pow _ _ _ a Word_V) + Word_V) HW) EU + refine step_end (Route_next _ _ _ _ _ _ _ _ HV rfl l _ _ _ H2) (by cfg_eq) ?_ + rw [pow_add_1]; cfg_eq + +theorem RRoute_scan (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (R : zB) + (H : RRoute c d r n w C_out e R) (a : Nat) (l : zB) (v x y : zF) (Ha : a ≤ n) + (HW : Word v x y) : + ∃ c' d' r' u z i j, RRoute c' d' r' (n - a) z C_out e R ∧ w = u ++ z ∧ EraseWord u i j ∧ + (scanW ((([1, 0] : zF) ^ (a * 2)) +> l) r v c d) [target_tm]⊢* + (scanW l r' ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ v ++ u) c' d') := by + rcases a with _ | a + · refine ⟨c, d, r, [], w, 0, 0, RRoute_eq H, rfl, EraseWord.Erase_nil, step_eq (by cfg_eq)⟩ + · rcases RRoute_cut c d r n w C_out e R H a (by omega) with ⟨c1, d1, r1, u0, z0, H0, H1, E0⟩ + rcases RRoute_cut c1 d1 r1 (n - a) z0 C_out e R H1 1 (by omega) with ⟨c2, d2, r2, u1, z1, H2, + H3, E1⟩ + rcases RRoute_erase _ _ _ _ _ _ _ _ H0 with ⟨i, j, EU0⟩ + rcases RRoute_erase _ _ _ _ _ _ _ _ H2 with ⟨k, q, EU1⟩ + refine ⟨c2, d2, r2, u0 ++ u1, z1, i + k, j + q, RRoute_eq H3, by rw [E0, E1, List.append_assoc], + EraseWord_app _ _ _ _ _ _ EU0 EU1, ?_⟩ + exact step_end (scanW_consume l c d r a u0 c1 d1 r1 u1 c2 d2 r2 v x y (RRoute_forget _ _ _ _ _ _ + _ _ H0) (RRoute_forget _ _ _ _ _ _ _ _ H2) HW) + (by cfg_eq) (by cfg_eq) + +def RCounter (r : zB) (n : Nat) (w : zF) (C_out e : Nat) : Prop := + ∃ d s, r = ((([0, 1, 0] : zF) ^ (2 + d)) +> s) ∧ RRoute 1 d s n w C_out e default + +theorem RCounter_eq {r1 r2 : zB} {n1 n2 : Nat} {w1 w2 : zF} {C1 C2 e1 e2 : Nat} + (h : RCounter r1 n1 w1 C1 e1) + (hr : r1 = r2 := by cfg_eq) (hn : n1 = n2 := by omega) + (hw : w1 = w2 := + by simp only + [list_pow_zero, list_pow_one, List.append_nil, List.nil_append, List.append_assoc]) + (hC : C1 = C2 := by omega) (he : e1 = e2 := by omega) : + RCounter r2 n2 w2 C2 e2 := by + subst hr; subst hn; subst hw; subst hC; subst he; exact h + +theorem RCounter_step (l r : zB) (n : Nat) (w : zF) (C_out e a b : Nat) + (HR : RCounter r n w C_out e) (Ha : a ≤ n) : + ∃ r', RCounter r' (n - a + b) ((([1, 0] : zF) ^ (2 + b * 2)) ++ (([1, 0, 1, 0, 0, 1] : zF) + ^ (1 + a)) ++ w) C_out e ∧ + ((((([1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> l)) + <{{C}} (([0, 1] : zF) +> r))) [target_tm]⊢* + (l <{{C}} (([0, 1] : zF) +> r')) := by + rcases HR with ⟨d, s, rfl, HR⟩ + rcases RRoute_scan 1 d s n w C_out e default HR a ((([1, 1, 0] : zF) ^ (2 + b * 2)) +> l) + [] [] [] Ha Word_nil with + ⟨c', d', s', u, z, i, j, HZ, EW, HU, HS⟩ + refine ⟨((([0, 1, 0] : zF) ^ (2 + b * 2)) +> link ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ u) + c' d' s'), ?_, ?_⟩ + · refine ⟨b * 2, link ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ u) c' d' s', rfl, ?_⟩ + exact RRoute_eq (RRoute.RRoute_more 0 b _ _ _ c' d' s' (n - a) + z C_out e default (EraseWord.Erase_V a u i j HU) HZ) + (hw := by rw [EW, pow_add_1]; simp only [Nat.zero_add, List.append_assoc]) + · refine step_bridge (scan_pair ((([1, 0] : zF) ^ (a * 2)) +> ((([1, 1, 0] : zF) ^ (2 + b * 2)) + +> l)) s 0 d) (by cfg_eq) ?_ + refine ReachesStar.trans HS ?_ + exact step_end (pass_011 l (link ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ u) c' d' s') (2 + b * 2)) + (by cfg_eq) (by cfg_eq) + +theorem RCounter_columns (n : Nat) (cs : List (Nat × Nat)) (m : Nat) (H : ColumnRun n cs m) + (l r : zB) (w : zF) (C_out e : Nat) (HR : RCounter r n w C_out e) : + ∃ r', RCounter r' m (column_word cs ++ w) C_out e ∧ + (column_side l cs <{{C}} (([0, 1] : zF) +> r)) [target_tm]⊢* (l <{{C}} (([0, 1] : zF) + +> r')) := by + induction H generalizing l r w with + | Columns_nil n => exact ⟨r, HR, step_eq rfl⟩ + | Columns_cons n a b cs m Ha H ih => + rcases RCounter_step (column_side l cs) r n w C_out e a b HR Ha with ⟨r1, H1, HS⟩ + rcases ih l r1 _ H1 with ⟨r2, H2, HT⟩ + refine ⟨r2, RCounter_eq H2 (hw := by dsimp [column_word]; simp only [List.append_assoc]), + ReachesStar.trans HS HT⟩ + +theorem RCounter_base (n e : Nat) : + RCounter (((([0, 1, 0] : zF) ^ (2 + n * 2 + e)) +> default)) n [] (1 + n * 2) e := + ⟨n * 2 + e, default, by cfg_eq, RRoute_eq (RRoute.RRoute_done 0 n e default)⟩ + +theorem RCounter_gap (g b d e : Nat) : + RCounter (((([0, 1, 0] : zF) ^ (2 + b * 2)) +> link ((([1, 0, 1, 0, 0, 1] : zF) ^ g)) + (1 + g * 2) (d * 2 + e) default)) + (b + d) ((([1, 0] : zF) ^ (2 + b * 2)) ++ (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + g))) + (1 + g * 2 + d * 2) e := by + refine ⟨b * 2, link ((([1, 0, 1, 0, 0, 1] : zF) ^ g)) (1 + g * 2) (d * 2 + e) default, rfl, ?_⟩ + exact RRoute_eq (RRoute.RRoute_more 0 b ((([1, 0, 1, 0, 0, 1] : zF) ^ g)) 0 g (1 + g * 2) + (d * 2 + e) default d [] (1 + (g + d) * 2) e default + (EraseWord_eq (EraseWord.Erase_V g [] 0 0 EraseWord.Erase_nil)) + (RRoute.RRoute_done g d e default)) + (hw := by rw [pow_add_1]; simp only [Nat.zero_add, List.append_nil, List.append_assoc]) + +theorem SectionStart_Rspec (l : zB) (n : Nat) (w : zF) (C_out e : Nat) (c : Cfg (Fin 2) (Fin 6)) + (H : SectionStart l n w C_out e c) : + ∃ r, RCounter r n w C_out e ∧ c [target_tm]⊢* (l <{{C}} (([0, 1] : zF) +> r)) := by + rcases H with ⟨d, b, e, HP⟩ | ⟨g, b, d, e, HP⟩ + · refine ⟨((([0, 1, 0] : zF) ^ ((2 + d * 2 + e) + (2 + b * 2))) +> default), ?_, + counter_begin l (2 + d * 2 + e) (2 + b * 2) HP⟩ + exact RCounter_eq (RCounter_base (1 + d + b) e) + · exact ⟨_, RCounter_gap g b d e, counter_begin_gap l g b d e HP⟩ + +theorem Pass_erase_pair (r : zB) (c j k : Nat) : + Pass (fun l a b => crossV l ((([1, 0] : zF) ^ (2 + j * 2)) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (1 + k)) +> r)) a b (3 + c) 0) + (fun a b => rootV ((([1, 0] : zF) ^ (2 + j * 2)) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) + +> r)) a b (3 + c) 0) + (fun l a b => crossV l r a b (4 + c + k) 0) + (fun a b => rootV r a b (4 + c + k) 0) ((2 + j + k) * 2) := by + have h1 : Pass (fun l a b => crossV l ((([1, 0] : zF) ^ (2 + j * 2)) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) +> r)) a b (3 + c) 0) + (fun a b => rootV ((([1, 0] : zF) ^ (2 + j * 2)) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (1 + k)) +> r)) a b (3 + c) 0) + (fun l a b => crossZ l ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) +> r) + a b (3 + (1 + c)) (1 + j * 2)) + (fun a b => rootZ ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) +> r) a b (3 + (1 + c)) + (1 + j * 2)) 2 := + Pass_eq (Pass_V_end ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) +> r) c (1 + j * 2)) + have h2 := Pass_Zs ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) +> r) (1 + c) 1 j + have h3 := Pass_Z_to_V r (1 + c) k + have h4 : Pass (fun l a b => crossV l r a b (3 + (1 + c)) k) + (fun a b => rootV r a b (3 + (1 + c)) k) + (fun l a b => crossV l r a b (3 + (1 + c) + k) 0) + (fun a b => rootV r a b (3 + (1 + c) + k) 0) (k * 2) := + Pass_eq (Pass_Vs r (1 + c) 0 k) + exact Pass_eq (Pass_trans h1 (Pass_trans h2 (Pass_trans h3 h4))) + +theorem EraseWord_pass (w : zF) (u v : Nat) (H : EraseWord w u v) (r : zB) (c : Nat) : + Pass (fun l a b => crossV l (w +> r) a b (3 + c) 0) + (fun a b => rootV (w +> r) a b (3 + c) 0) + (fun l a b => crossV l r a b (3 + c + v) 0) + (fun a b => rootV r a b (3 + c + v) 0) ((u + v) * 2) := by + induction H generalizing r c with + | Erase_nil => exact Pass_eq (Pass_id _ _) + | Erase_V n w u v _ ih => + have h1 : Pass (fun l a b => crossV l (((([1, 0, 1, 0, 0, 1] : zF) ^ n) ++ w) +> r) a b (3 + c) + 0) + (fun a b => rootV (((([1, 0, 1, 0, 0, 1] : zF) ^ n) ++ w) +> r) a b (3 + c) 0) + (fun l a b => crossV l (w +> r) a b (3 + (c + n)) 0) + (fun a b => rootV (w +> r) a b (3 + (c + n)) 0) (n * 2) := + Pass_eq (Pass_Vs (w +> r) c 0 n) + exact Pass_eq (Pass_trans h1 (ih r (c + n))) + | Erase_pair j k w u v _ ih => + have h1 : Pass (fun l a b => crossV l (((([1, 0] : zF) ^ (2 + j * 2)) + ++ (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) ++ w) +> r) a b (3 + c) + 0) + (fun a b => rootV (((([1, 0] : zF) ^ (2 + j * 2)) ++ (([1, 0, 1, 0, 0, 1] : zF) + ^ (1 + k)) ++ w) +> r) a b (3 + c) 0) + (fun l a b => crossV l (w +> r) a b (3 + (1 + c + k)) 0) + (fun a b => rootV (w +> r) a b (3 + (1 + c + k)) 0) ((2 + j + k) * 2) := + Pass_eq (Pass_erase_pair (w +> r) c j k) + exact Pass_eq (Pass_trans h1 (ih r (1 + c + k))) + +theorem Pass_odd_join (r : zB) (c : Nat) (w : zF) (c' d : Nat) : + Pass (fun l a b => crossW l (link w c' d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c 1) + (fun a b => rootW (link w c' d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c 1) + (fun l a b => crossV l (w +> clean_input c' d r) a b (3 + c) 0) + (fun a b => rootV (w +> clean_input c' d r) a b (3 + c) 0) 0 := + Pass_eq (Pass_id _ _) + +theorem Pass_clean_tail (j n e k : Nat) (He : e ≤ 1) : + ∃ C_out E, E ≤ 1 ∧ C_out + E = 2 + k + n * 2 + e ∧ + Pass (fun l a b => crossV l (clean_input (1 + j * 2) (n * 2 + e) default) a b (3 + k) 0) + (fun a b => rootV (clean_input (1 + j * 2) (n * 2 + e) default) a b (3 + k) 0) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C_out E) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C_out E) + (4 + j * 2 + n + e) := by + rcases e with _ | _ | e + · rcases n with _ | n + · refine ⟨2 + k, 0, by omega, by omega, ?_⟩ + have h1 : Pass (fun l a b => crossV l (clean_input (1 + j * 2) 0 default) a b (3 + k) 0) + (fun a b => rootV (clean_input (1 + j * 2) 0 default) a b (3 + k) 0) + (fun l a b => crossZ l (([1, 0, 1] : zF) +> default) a b (3 + (1 + k)) + (0 + j * 2)) + (fun a b => rootZ (([1, 0, 1] : zF) +> default) a b (3 + (1 + k)) (0 + j * 2)) + 2 := + Pass_eq (Pass_V_end (([1, 0, 1] : zF) +> default) k (j * 2)) + have h2 : Pass (fun l a b => crossZ l (([1, 0, 1] : zF) +> default) a b (3 + (1 + k)) + (0 + j * 2)) + (fun a b => rootZ (([1, 0, 1] : zF) +> default) a b (3 + (1 + k)) (0 + j * 2)) + (fun l a b => crossZ l (([1, 0, 1] : zF) +> default) a b (4 + k) 0) + (fun a b => rootZ (([1, 0, 1] : zF) +> default) a b (4 + k) 0) (j * 2) := + Pass_eq (Pass_Zs (([1, 0, 1] : zF) +> default) (1 + k) 0 j) + have h3 := Pass_Z_empty k + exact Pass_eq (Pass_trans h1 (Pass_trans h2 h3)) + · refine ⟨3 + k + n * 2, 1, by omega, by omega, ?_⟩ + have h1 : Pass (fun l a b => crossV l (clean_input (1 + j * 2) ((n + 1) * 2) default) + a b (3 + k) 0) + (fun a b => rootV (clean_input (1 + j * 2) ((n + 1) * 2) default) a b (3 + k) + 0) + (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (1 + (1 + n * 2))) +> default)) a b (3 + (1 + k)) + (0 + j * 2)) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> default)) a b (3 + (1 + k)) (0 + j * 2)) 2 := + Pass_eq (Pass_V_end (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> default)) k (j * 2)) + have h2 : Pass (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (1 + (1 + n * 2))) +> default)) a b (3 + (1 + k)) + (0 + j * 2)) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> default)) a b (3 + (1 + k)) (0 + j * 2)) + (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (1 + (1 + n * 2))) +> default)) a b (4 + k) 0) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> default)) a b (4 + k) 0) (j * 2) := + Pass_eq (Pass_Zs (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) +> default)) + (1 + k) 0 j) + have h3 := Pass_Z_back default k (1 + n * 2) + have h4 : Pass (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + k) + (2 + (1 + n * 2))) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + k) + (2 + (1 + n * 2))) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) + (3 + k + n * 2) 1) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (3 + k + n * 2) 1) + (1 + n) := + Pass_eq (Pass_Ws default (1 + k) 1 (1 + n)) + exact Pass_eq (Pass_trans h1 (Pass_trans h2 (Pass_trans h3 h4))) + · refine ⟨3 + k + n * 2, 0, by omega, by omega, ?_⟩ + have h1 : Pass (fun l a b => crossV l (clean_input (1 + j * 2) (n * 2 + 1) default) a b (3 + k) + 0) + (fun a b => rootV (clean_input (1 + j * 2) (n * 2 + 1) default) a b (3 + k) 0) + (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + n * 2)) + +> default)) a b (3 + (1 + k)) (0 + j * 2)) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + n * 2)) + +> default)) a b (3 + (1 + k)) (0 + j * 2)) 2 := + Pass_eq (Pass_V_end (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + n * 2)) +> default)) + k (j * 2)) + have h2 : Pass (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + n * 2)) + +> default)) a b (3 + (1 + k)) (0 + j * 2)) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + n * 2)) + +> default)) a b (3 + (1 + k)) (0 + j * 2)) + (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + n * 2)) + +> default)) a b (4 + k) 0) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + n * 2)) + +> default)) a b (4 + k) 0) (j * 2) := + Pass_eq (Pass_Zs (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + n * 2)) +> default)) (1 + k) + 0 j) + have h3 := Pass_Z_back default k (n * 2) + have h4 : Pass (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + k) + (2 + n * 2)) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + k) (2 + n * 2)) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (3 + k + n * 2) + 0) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (3 + k + n * 2) 0) + (1 + n) := + Pass_eq (Pass_Ws default (1 + k) 0 (1 + n)) + exact Pass_eq (Pass_trans h1 (Pass_trans h2 (Pass_trans h3 h4))) + · omega + +theorem Pass_clean_link (j n : Nat) (z : zF) (u v c d : Nat) (r : zB) (k : Nat) + (HZ : EraseWord z u v) : + Pass (fun l a b => crossV l (clean_input (1 + j * 2) (n * 2) (link z c d r)) a b (3 + k) 0) + (fun a b => rootV (clean_input (1 + j * 2) (n * 2) (link z c d r)) a b (3 + k) 0) + (fun l a b => crossV l (clean_input c d r) a b (4 + k + n * 2 + v) 0) + (fun a b => rootV (clean_input c d r) a b (4 + k + n * 2 + v) 0) (4 + j * 2 + n + (u + v) + * 2) := by + rcases n with _ | n + · have h1 : Pass (fun l a b => crossV l (clean_input (1 + j * 2) 0 (link z c d r)) a b (3 + k) 0) + (fun a b => rootV (clean_input (1 + j * 2) 0 (link z c d r)) a b (3 + k) 0) + (fun l a b => crossV l (z +> clean_input c d r) a b (3 + (1 + k)) 0) + (fun a b => rootV (z +> clean_input c d r) a b (3 + (1 + k)) 0) ((2 + j) * 2) := + Pass_eq (Pass_erase_pair (z +> clean_input c d r) k j 0) + have h2 := EraseWord_pass z u v HZ (clean_input c d r) (1 + k) + exact Pass_eq (Pass_trans h1 h2) + · have h1 : Pass (fun l a b => crossV l (clean_input (1 + j * 2) ((n + 1) * 2) (link z c d r)) + a b (3 + k) 0) + (fun a b => rootV (clean_input (1 + j * 2) ((n + 1) * 2) (link z c d r)) + a b (3 + k) 0) + (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (1 + (1 + n * 2))) +> link z c d r)) a b (3 + (1 + k)) + (0 + j * 2)) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> link z c d r)) a b (3 + (1 + k)) (0 + j * 2)) 2 := + Pass_eq (Pass_V_end (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> link z c d r)) k (j * 2)) + have h2 : Pass (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (1 + (1 + n * 2))) +> link z c d r)) a b (3 + (1 + k)) + (0 + j * 2)) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> link z c d r)) a b (3 + (1 + k)) (0 + j * 2)) + (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (1 + (1 + n * 2))) +> link z c d r)) a b (4 + k) 0) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> link z c d r)) a b (4 + k) 0) (j * 2) := + Pass_eq (Pass_Zs (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> link z c d r)) (1 + k) 0 j) + have h3 := Pass_Z_back (link z c d r) k (1 + n * 2) + have h4 : Pass (fun l a b => crossW l (link z c d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + k) + (2 + (1 + n * 2))) + (fun a b => rootW (link z c d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (1 + k) + (2 + (1 + n * 2))) + (fun l a b => crossW l (link z c d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) ((1 + n) + * 2 + (1 + k)) 1) + (fun a b => rootW (link z c d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) ((1 + n) + * 2 + (1 + k)) 1) (1 + n) := + Pass_eq (Pass_Ws (link z c d r) (1 + k) 1 (1 + n)) + have h5 := Pass_odd_join r ((1 + n) * 2 + (1 + k)) z c d + have h6 := EraseWord_pass z u v HZ (clean_input c d r) ((1 + n) * 2 + (1 + k)) + exact Pass_eq (Pass_trans h1 (Pass_trans h2 (Pass_trans h3 (Pass_trans h4 (Pass_trans h5 h6))))) + +theorem root_plain_terminal (a b c e : Nat) (He : e ≤ 1) : + (rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c e) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + c + e)) +> ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ (3 + a)) + +> default))) {{B}}> default)) := + step_end (rootW_terminal a _ _ _ c e He (Word_pow _ _ _ b Word_V)) (by cfg_eq) (by cfg_eq) + +theorem cross_plain_terminal (l : zB) (a b c e : Nat) (He : e ≤ 1) : + (crossW l default (2 + a) (([1, 0, 1, 0, 0, 1] : zF) ^ b) c e) [target_tm]⊢* + ((((([1, 0] : zF) ^ (1 + c + e)) +> ((([1, 1, 0] : zF) ^ (3 + b * 2)) +> ((([1, 0] : zF) ^ a) + +> l))) {{B}}> default)) := + step_end (crossW_terminal l a _ _ _ c e He (Word_pow _ _ _ b Word_V)) (by cfg_eq) (by cfg_eq) + +theorem cleanup_start0 (r : zB) (d : Nat) : + ((default <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (2 + d)) +> r)))) [target_tm]⊢* + (rootW r 2 [] 1 d) := by + refine ReachesStar.trans (scan_left_zero r (2 + d)) ?_ + exact step_end (scan_left_step r 1 d) (by cfg_eq) (by cfg_eq) + +theorem cleanup_start1 (r : zB) (d : Nat) : + (((([1, 0] : zF) +> default) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (2 + d)) +> r)))) + [target_tm]⊢* + (rootW r 4 [] 1 d) := by + refine ReachesStar.trans (scan_left_entry r (2 + d)) ?_ + exact step_end (scan_left_step r 3 d) (by cfg_eq) (by cfg_eq) + +theorem cleanup_start2 (r : zB) (d : Nat) : + ((((([1, 0] : zF) ^ 2) +> default) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (2 + d)) + +> r)))) [target_tm]⊢* + (rootW r 0 [1, 0, 1, 0, 0, 1] 1 d) := by + refine step_bridge (scan_pair default r 0 d) (by cfg_eq) ?_ + exact step_end (scanW_zero r [] 1 d) (by cfg_eq) (by cfg_eq) + +theorem cleanup_start (l : zB) (a : Nat) (r : zB) (d : Nat) : + ((((([1, 0] : zF) ^ (3 + a)) +> l) <{{C}} (([0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (2 + d)) + +> r)))) [target_tm]⊢* + (crossW l r a [1, 0, 1, 0, 0, 1] 1 d) := by + refine step_bridge (scan_pair ((([1, 0] : zF) ^ (1 + a)) +> l) r 0 d) (by cfg_eq) ?_ + exact step_end (scanW_entry l r a [] 1 d) (by cfg_eq) (by cfg_eq) + +def Cleanup (r : zB) (N X : Nat) : Prop := + ∃ d s c e, r = ((([0, 1, 0] : zF) ^ (2 + d)) +> s) ∧ e ≤ 1 ∧ X = 1 + c + e ∧ + Pass (fun l a b => crossW l s a (([1, 0, 1, 0, 0, 1] : zF) ^ b) 1 d) + (fun a b => rootW s a (([1, 0, 1, 0, 0, 1] : zF) ^ b) 1 d) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c e) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c e) N + +theorem Cleanup_eq {r1 r2 : zB} {N1 N2 X1 X2 : Nat} + (h : Cleanup r1 N1 X1) + (hr : r1 = r2 := by cfg_eq) (hN : N1 = N2 := by omega) (hX : X1 = X2 := by omega) : + Cleanup r2 N2 X2 := by + subst hr; subst hN; subst hX; exact h + +inductive CleanLast (N X : Nat) : Nat → List Nat → Prop where + | Clean0 : CleanLast N X 0 [X + 5 + N * 2] + | Clean1 : CleanLast N X 1 [X + 7 + N * 2] + | CleanEven (s : Nat) : s ≤ N → CleanLast N X (2 + s * 2) [X, 2 + s * 2, 3 + (N - s) * 2] + | CleanOdd (s : Nat) : s ≤ N → CleanLast N X (3 + s * 2) [X, 2 + s * 2, 5 + (N - s) * 2] + | CleanBorder : CleanLast N X (4 + N * 2) [X, 4 + N * 2, 1] + | CleanOver (a : Nat) : CleanLast N X (5 + N * 2 + a) [X, 5 + N * 2, a] + +theorem CleanLast_eq {N1 N2 X1 X2 t1 t2 : Nat} {xs1 xs2 : List Nat} + (h : CleanLast N1 X1 t1 xs1) + (hN : N1 = N2 := by omega) (hX : X1 = X2 := by omega) (ht : t1 = t2 := by omega) + (hxs : xs1 = xs2 := by + first + | rfl + | (try simp only [List.cons.injEq, and_true, true_and]) + (repeat' constructor) <;> first | trivial | omega) : + CleanLast N2 X2 t2 xs2 := by + subst hN; subst hX; subst ht; subst hxs; exact h + +theorem Cleanup_spec (r : zB) (N X t : Nat) (xs : List Nat) + (HC : Cleanup r N X) (HL : CleanLast N X t xs) : + ((((([1, 0] : zF) ^ t) +> default) <{{C}} (([0, 1] : zF) +> r))) + [target_tm]⊢⁺ (section_481 xs) := by + rcases HC with ⟨d, r0, c, e, rfl, He, rfl, ⟨HF, HE⟩⟩ + refine evstep_progress ?_ (by ne_cfg) + rcases HL with _ | _ | ⟨s, Hs⟩ | ⟨s, Hs⟩ | _ | a + · refine step_bridge (cleanup_start0 r0 d) (by cfg_eq) ?_ + refine step_bridge (HF.flow_root 2 0) (by cfg_eq) ?_ + exact step_end (root_plain_terminal (N * 2 + 2) 0 c e He) (by cfg_eq) (by cfg_eq) + · refine step_bridge (cleanup_start1 r0 d) (by cfg_eq) ?_ + refine step_bridge (HF.flow_root 4 0) (by cfg_eq) ?_ + exact step_end (root_plain_terminal (N * 2 + 4) 0 c e He) (by cfg_eq) (by cfg_eq) + · rcases s with _ | s + · refine step_bridge (cleanup_start2 r0 d) (by cfg_eq) ?_ + refine step_bridge (HF.flow_root 0 1) (by cfg_eq) ?_ + exact step_end (root_plain_terminal (N * 2 + 0) 1 c e He) (by cfg_eq) (by cfg_eq) + · refine step_bridge (cleanup_start default (1 + s * 2) r0 d) (by cfg_eq) ?_ + refine step_bridge (HF.flow_border s (N - s - 1) 1 (by omega)) (by cfg_eq) ?_ + exact step_end (root_plain_terminal ((N - s - 1) * 2) (2 + s) c e He) (by cfg_eq) (by cfg_eq) + · rcases s with _ | s + · refine step_bridge (cleanup_start default 0 r0 d) (by cfg_eq) ?_ + refine step_bridge (crossW_zero r0 [1, 0, 1, 0, 0, 1] 1 d) (by cfg_eq) ?_ + refine step_bridge (HF.flow_root 2 1) (by cfg_eq) ?_ + exact step_end (root_plain_terminal (N * 2 + 2) 1 c e He) (by cfg_eq) (by cfg_eq) + · refine step_bridge (cleanup_start default (2 + s * 2) r0 d) (by cfg_eq) ?_ + refine step_bridge (HE s (N - s - 1) 1 (by omega)) (by cfg_eq) ?_ + exact step_end (root_plain_terminal (2 + (N - s - 1) * 2) (2 + s) c e He) (by cfg_eq) + (by cfg_eq) + · refine step_bridge (cleanup_start default (1 + N * 2) r0 d) (by cfg_eq) ?_ + refine step_bridge (HF.flow_cross default 1 1) (by cfg_eq) ?_ + exact step_end (crossW_last_one (1 + N) c e He) (by cfg_eq) (by cfg_eq) + · refine step_bridge (cleanup_start default (2 + N * 2 + a) r0 d) (by cfg_eq) ?_ + refine step_bridge (HF.flow_cross default (2 + a) 1) (by cfg_eq) ?_ + exact step_end (cross_plain_terminal default a (1 + N) c e He) (by cfg_eq) (by cfg_eq) + +theorem RRoute_clean (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (R : zB) + (H : RRoute c d r n w C_out e R) (ER : R = default) (He : e ≤ 1) : + ∃ u v, EraseWord w u v ∧ ∀ k, ∃ N C' E, + E ≤ 1 ∧ N + n = (u + v) * 2 + 3 + C_out + e ∧ C' + E = 2 + k + v + n * 2 + e ∧ + Pass (fun l a b => crossV l (clean_input c d r) a b (3 + k) 0) + (fun a b => rootV (clean_input c d r) a b (3 + k) 0) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C' E) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C' E) N := by + induction H with + | RRoute_done j n e r => + subst ER + refine ⟨0, 0, EraseWord.Erase_nil, fun k => ?_⟩ + rcases Pass_clean_tail j n e k He with ⟨C', E, HE, HC, HP⟩ + exact ⟨4 + j * 2 + n + e, C', E, HE, by omega, by omega, HP⟩ + | RRoute_more j n z x y c' d r m w C_out e R HZ HR ih => + rcases ih ER He with ⟨u, v, HW, IHk⟩ + refine ⟨1 + (j + n) + x + u, 1 + y + v, ?_, fun k => ?_⟩ + · exact EraseWord_eq (EraseWord.Erase_pair (j + n) 0 (z ++ w) (x + u) (y + v) + (EraseWord_app z x y w u v HZ HW)) + · rcases IHk (1 + k + n * 2 + y) with ⟨N, C0, E, HE, HN, HC, HP⟩ + refine ⟨4 + j * 2 + n + (x + y) * 2 + N, C0, E, HE, by omega, by omega, ?_⟩ + have h1 := Pass_clean_link j n z x y c' d r k HZ + have h2 : Pass (fun l a b => crossV l (clean_input c' d r) a b (4 + k + n * 2 + y) 0) + (fun a b => rootV (clean_input c' d r) a b (4 + k + n * 2 + y) 0) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C0 E) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C0 E) N := + Pass_eq HP + exact Pass_eq (Pass_trans h1 h2) + +theorem RRoute_cleanup (b : Nat) (z : zF) (i j c d : Nat) (r : zB) (n : Nat) (w : zF) + (C_out e : Nat) + (HZ : EraseWord z i j) (HR : RRoute c d r n w C_out e default) (He : e ≤ 1) : + ∃ u v N X, EraseWord w u v ∧ + N + n = b + (i + j + u + v) * 2 + 3 + C_out + e ∧ X = 4 + b * 2 + j + v + n * 2 + e ∧ + Cleanup ((([0, 1, 0] : zF) ^ (3 + b * 2)) +> link z c d r) N X := by + rcases RRoute_clean c d r n w C_out e default HR rfl He with ⟨u, v, HW, HK⟩ + rcases HK (1 + b * 2 + j) with ⟨N, c', e', He', HN, HX, HP⟩ + refine ⟨u, v, b + (i + j) * 2 + N, 1 + c' + e', HW, by omega, by omega, ?_⟩ + refine ⟨1 + b * 2, link z c d r, c', e', by cfg_eq, He', rfl, ?_⟩ + have h1 : Pass (fun l a b_blk => crossW l (link z c d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b_blk) + 1 (1 + b * 2)) + (fun a b_blk => rootW (link z c d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b_blk) + 1 (1 + b * 2)) + (fun l a b_blk => crossW l (link z c d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b_blk) + (b * 2 + 1) 1) + (fun a b_blk => rootW (link z c d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b_blk) + (b * 2 + 1) 1) b := + Pass_eq (Pass_Ws (link z c d r) 1 1 b) + have h2 := Pass_odd_join r (b * 2 + 1) z c d + have h3 := EraseWord_pass z i j HZ (clean_input c d r) (b * 2 + 1) + have h4 : Pass (fun l a b_blk => crossV l (clean_input c d r) a b_blk (3 + (b * 2 + 1) + j) 0) + (fun a b_blk => rootV (clean_input c d r) a b_blk (3 + (b * 2 + 1) + j) 0) + (fun l a b_blk => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b_blk) c' e') + (fun a b_blk => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b_blk) c' e') N := + Pass_eq HP + exact Pass_eq (Pass_trans h1 (Pass_trans h2 (Pass_trans h3 h4))) + +theorem pow_length (w : zF) (n : Nat) : (w ^ n).length = w.length * n := by + induction n with + | zero => simp only [list_pow_zero, List.length_nil, Nat.mul_zero] + | succ n ih => rw [list_pow_succ, List.length_append, ih, Nat.mul_add, Nat.mul_one, Nat.add_comm] + +theorem EraseWord_size (w : zF) (u v : Nat) (H : EraseWord w u v) : w.length = u * 4 + v * 6 := by + induction H with + | Erase_nil => rfl + | Erase_V n w u v _ ih => + simp only [List.length_append, pow_length, List.length_cons, List.length_nil, ih] + omega + | Erase_pair j k w u v _ ih => + simp only [List.length_append, pow_length, List.length_cons, List.length_nil, ih] + omega + +theorem Cleanup_triple (g b d e : Nat) (He : e ≤ 1) : + Cleanup ((([0, 1, 0] : zF) ^ (3 + b * 2)) +> link ((([1, 0, 1, 0, 0, 1] : zF) ^ g)) (1 + g * 2) + (d * 2 + e) default) + (4 + b + g * 4 + d + e) (4 + b * 2 + g + d * 2 + e) := by + rcases RRoute_cleanup b ((([1, 0, 1, 0, 0, 1] : zF) ^ g)) 0 g (1 + g * 2) (d * 2 + e) + default d [] (1 + (g + d) * 2) e + (EraseWord_eq (EraseWord.Erase_V g [] 0 0 EraseWord.Erase_nil)) + (RRoute.RRoute_done g d e default) He with + ⟨u, v, N, X, HW, HN, HX, HC⟩ + have hlen := EraseWord_size [] u v HW + have hu : u = 0 := by dsimp at hlen; omega + have hv : v = 0 := by dsimp at hlen; omega + subst hu; subst hv + exact Cleanup_eq HC + +theorem cleanup_triple_section (g b d e t : Nat) (xs : List Nat) + (HP : P (2 + g * 2 + (d * 2 + e))) (He : e ≤ 1) + (HL : CleanLast (4 + b + g * 4 + d + e) (4 + b * 2 + g + d * 2 + e) t xs) : + (section_481 [(2 + g * 2 + (d * 2 + e)) + (2 + g * 2), 3 + b * 2, t]) + [target_tm]⊢⁺ (section_481 xs) := by + refine evstep_progress_trans ?_ (Cleanup_spec _ _ _ t xs (Cleanup_triple g b d e He) HL) + refine step_bridge (return_even ((([1, 1, 0] : zF) ^ (3 + b * 2)) +> ((([1, 0] : zF) ^ t) + +> default)) g (d * 2 + e) HP) (by cfg_eq) ?_ + exact step_end (pass_011 ((([1, 0] : zF) ^ t) +> default) _ (3 + b * 2)) (by cfg_eq) (by cfg_eq) + +theorem RCounter_cleanup (l r : zB) (n : Nat) (w : zF) (C_out e a b : Nat) + (HR : RCounter r n w C_out e) (Ha : a ≤ n) (He : e ≤ 1) : + ∃ u v N X r', EraseWord w u v ∧ + N + n = b + a * 3 + (u + v) + * 2 + 3 + C_out + e ∧ X + a = 4 + b * 2 + v + n * 2 + e ∧ Cleanup r' N X ∧ + ((((([1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 1, 0] : zF) ^ (3 + b * 2)) +> l)) + <{{C}} (([0, 1] : zF) +> r))) [target_tm]⊢* + (l <{{C}} (([0, 1] : zF) +> r')) := by + rcases HR with ⟨d, s, rfl, HR⟩ + rcases RRoute_scan 1 d s n w C_out e default HR a ((([1, 1, 0] : zF) ^ (3 + b * 2)) +> l) + [] [] [] Ha Word_nil with + ⟨c', d', s', u, z, i, j, HZ, EW, HU, HS⟩ + rcases RRoute_cleanup b ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ u) i (a + j) c' d' s' (n - a) + z C_out e + (EraseWord.Erase_V a u i j HU) HZ He with ⟨x, y, N, X, HW, HN, HX, HC⟩ + refine ⟨i + x, j + y, N, X, ((([0, 1, 0] : zF) ^ (3 + b * 2)) +> link ((([1, 0, 1, 0, 0, 1] : zF) + ^ a) ++ u) c' d' s'), ?_, by omega, by omega, HC, ?_⟩ + · rw [EW]; exact EraseWord_app u i j z x y HU HW + · refine step_bridge (scan_pair ((([1, 0] : zF) ^ (a * 2)) +> ((([1, 1, 0] : zF) ^ (3 + b * 2)) + +> l)) s 0 d) (by cfg_eq) ?_ + refine ReachesStar.trans HS ?_ + exact step_end (pass_011 l (link ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ u) c' d' s') (3 + b * 2)) + (by cfg_eq) (by cfg_eq) + +theorem CleanLast_total (N X t : Nat) : ∃ xs, CleanLast N X t xs := by + rcases t with _ | _ | t + · exact ⟨_, CleanLast.Clean0⟩ + · exact ⟨_, CleanLast.Clean1⟩ + · rcases parity t with ⟨s, rfl | rfl⟩ + · by_cases hle : s ≤ N + · exact ⟨_, CleanLast_eq (@CleanLast.CleanEven N X s hle) rfl rfl (by omega) rfl⟩ + · by_cases heq : s = N + 1 + · exact ⟨_, CleanLast_eq (@CleanLast.CleanBorder N X) rfl rfl (by omega) rfl⟩ + · exact ⟨_, CleanLast_eq (@CleanLast.CleanOver N X (2 + s * 2 - (5 + N * 2))) rfl rfl + (by omega) rfl⟩ + · by_cases hle : s ≤ N + · exact ⟨_, CleanLast_eq (@CleanLast.CleanOdd N X s hle) rfl rfl (by omega) rfl⟩ + · exact ⟨_, CleanLast_eq (@CleanLast.CleanOver N X (3 + s * 2 - (5 + N * 2))) rfl rfl + (by omega) rfl⟩ + +theorem Pass_V_low (r : zB) (e : Nat) : + Pass (fun l a b => crossV l r a b 2 (1 + e)) + (fun a b => rootV r a b 2 (1 + e)) + (fun l a b => crossV l r a b 3 e) + (fun a b => rootV r a b 3 e) 2 := by + refine ⟨⟨?_, ?_, ?_⟩, ?_⟩ + · intro l a b; exact step_end (crossV_low l r a b e) (by cfg_eq) (by cfg_eq) + · intro a b; exact step_end (rootV_low r a b e) (by cfg_eq) (by cfg_eq) + · intro s v b E + rcases s with _ | _ | s + · have hv : v = 1 := by omega + subst hv; exact step_end (crossV_low_one r b e) (by cfg_eq) (by cfg_eq) + · have hv : v = 0 := by omega + subst hv; exact step_end (crossV_low_three r b e) (by cfg_eq) (by cfg_eq) + · omega + · intro s v b E + rcases s with _ | _ | s + · have hv : v = 1 := by omega + subst hv; exact step_end (crossV_low_two r b e) (by cfg_eq) (by cfg_eq) + · have hv : v = 0 := by omega + subst hv + refine step_bridge (crossV_low default r 0 b e) (by cfg_eq) ?_ + exact step_end (crossV_zero r (2 + b) 3 e) (by cfg_eq) (by cfg_eq) + · omega + +theorem Pass_Vend_low (r : zB) (e : Nat) : + Pass (fun l a b => crossV l ((([1, 0] : zF) ^ (1 + e)) +> r) a b 2 0) + (fun a b => rootV ((([1, 0] : zF) ^ (1 + e)) +> r) a b 2 0) + (fun l a b => crossZ l r a b 3 e) + (fun a b => rootZ r a b 3 e) 2 := by + refine ⟨⟨?_, ?_, ?_⟩, ?_⟩ + · intro l a b; exact step_end (crossVend_low l r a b e) (by cfg_eq) (by cfg_eq) + · intro a b; exact step_end (rootVend_low r a b e) (by cfg_eq) (by cfg_eq) + · intro s v b E + rcases s with _ | _ | s + · have hv : v = 1 := by omega + subst hv; exact step_end (crossVend_low_one r b e) (by cfg_eq) (by cfg_eq) + · have hv : v = 0 := by omega + subst hv; exact step_end (crossVend_low_three r b e) (by cfg_eq) (by cfg_eq) + · omega + · intro s v b E + rcases s with _ | _ | s + · have hv : v = 1 := by omega + subst hv; exact step_end (crossVend_low_two r b e) (by cfg_eq) (by cfg_eq) + · have hv : v = 0 := by omega + subst hv + refine step_bridge (crossVend_low default r 0 b e) (by cfg_eq) ?_ + exact step_end (crossZ_zero r (2 + b) 3 e) (by cfg_eq) (by cfg_eq) + · omega + +theorem Pass_Z_empty_low : + Pass (fun l a b => crossZ l (([1, 0, 1] : zF) +> default) a b 3 0) + (fun a b => rootZ (([1, 0, 1] : zF) +> default) a b 3 0) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) 1 0) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) 1 0) 2 := by + refine ⟨⟨?_, ?_, ?_⟩, ?_⟩ + · intro l a b; exact step_end (crossZ_empty_low l a b) (by cfg_eq) (by cfg_eq) + · intro a b; exact step_end (rootZ_empty_low a b) (by cfg_eq) (by cfg_eq) + · intro s v b E + rcases s with _ | _ | s + · have hv : v = 1 := by omega + subst hv; exact step_end (crossZ_empty_low_one b) (by cfg_eq) (by cfg_eq) + · have hv : v = 0 := by omega + subst hv; exact step_end (crossZ_empty_low_three b) (by cfg_eq) (by cfg_eq) + · omega + · intro s v b E + rcases s with _ | _ | s + · have hv : v = 1 := by omega + subst hv; exact step_end (crossZ_empty_low_two b) (by cfg_eq) (by cfg_eq) + · have hv : v = 0 := by omega + subst hv + refine step_bridge (crossZ_empty_low default 0 b) (by cfg_eq) ?_ + exact step_end (crossW_zero default (([1, 0, 1, 0, 0, 1] : zF) ^ (2 + b)) 1 0) (by cfg_eq) + (by cfg_eq) + · omega + +theorem Pass_Z_back_low (r : zB) (d : Nat) : + Pass (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + d)) +> r)) a b 3 0) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + d)) +> r)) a b 3 0) + (fun l a b => crossW l r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) 0 (2 + d)) + (fun a b => rootW r a (([1, 0, 1, 0, 0, 1] : zF) ^ b) 0 (2 + d)) 2 := + Pass_eq (Pass_Z (([1, 0] : zF) +> ((([0, 1, 0] : zF) ^ d) +> r)) 0 0) + +theorem Pass_clean_tail_low (j n e : Nat) (He : e ≤ 1) : + ∃ C_out E, E ≤ 1 ∧ C_out + E = 1 + n * 2 + e ∧ + Pass (fun l a b => crossV l (clean_input (1 + j * 2) (n * 2 + e) default) a b 2 0) + (fun a b => rootV (clean_input (1 + j * 2) (n * 2 + e) default) a b 2 0) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C_out E) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C_out E) + (4 + j * 2 + n + e) := by + rcases e with _ | _ | e + · rcases n with _ | n + · refine ⟨1, 0, by omega, by omega, ?_⟩ + have h1 : Pass (fun l a b => crossV l (clean_input (1 + j * 2) 0 default) a b 2 0) + (fun a b => rootV (clean_input (1 + j * 2) 0 default) a b 2 0) + (fun l a b => crossZ l (([1, 0, 1] : zF) +> default) a b 3 (0 + j * 2)) + (fun a b => rootZ (([1, 0, 1] : zF) +> default) a b 3 (0 + j * 2)) 2 := + Pass_eq (Pass_Vend_low (([1, 0, 1] : zF) +> default) (j * 2)) + have h2 := Pass_Zs (([1, 0, 1] : zF) +> default) 0 0 j + have h3 := Pass_Z_empty_low + exact Pass_eq (Pass_trans h1 (Pass_trans h2 h3)) + · refine ⟨2 + n * 2, 1, by omega, by omega, ?_⟩ + have h1 : Pass (fun l a b => crossV l (clean_input (1 + j * 2) ((n + 1) * 2) default) a b 2 0) + (fun a b => rootV (clean_input (1 + j * 2) ((n + 1) * 2) default) a b 2 0) + (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (1 + (1 + n * 2))) +> default)) a b 3 (0 + j * 2)) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> default)) a b 3 (0 + j * 2)) 2 := + Pass_eq (Pass_Vend_low (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> default)) (j * 2)) + have h2 := Pass_Zs (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) +> default)) + 0 0 j + have h3 := Pass_Z_back_low default (1 + n * 2) + have h4 : Pass (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) + 0 (2 + (1 + n * 2))) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) + 0 (2 + (1 + n * 2))) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + n * 2) 1) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + n * 2) 1) + (1 + n) := + Pass_eq (Pass_Ws default 0 1 (1 + n)) + exact Pass_eq (Pass_trans h1 (Pass_trans h2 (Pass_trans h3 h4))) + · refine ⟨2 + n * 2, 0, by omega, by omega, ?_⟩ + have h1 : Pass (fun l a b => crossV l (clean_input (1 + j * 2) (n * 2 + 1) default) a b 2 0) + (fun a b => rootV (clean_input (1 + j * 2) (n * 2 + 1) default) a b 2 0) + (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + n * 2)) + +> default)) a b 3 (0 + j * 2)) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + n * 2)) + +> default)) a b 3 (0 + j * 2)) 2 := + Pass_eq (Pass_Vend_low (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + n * 2)) +> default)) + (j * 2)) + have h2 := Pass_Zs (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + n * 2)) +> default)) 0 0 j + have h3 := Pass_Z_back_low default (n * 2) + have h4 : Pass (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) 0 (2 + n * 2)) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) 0 (2 + n * 2)) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + n * 2) 0) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) (2 + n * 2) 0) + (1 + n) := + Pass_eq (Pass_Ws default 0 0 (1 + n)) + exact Pass_eq (Pass_trans h1 (Pass_trans h2 (Pass_trans h3 h4))) + · omega + +def OneCleanup (r : zB) (N X : Nat) : Prop := + ∃ c e, e ≤ 1 ∧ X = 1 + c + e ∧ + Pass (fun l a b => crossV l r a b 2 0) + (fun a b => rootV r a b 2 0) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c e) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) c e) (1 + N) + +theorem OneCleanup_spec (r : zB) (N X t : Nat) (xs : List Nat) + (HC : OneCleanup r N X) (HL : CleanLast N X t xs) : + ((((([1, 0] : zF) ^ t) +> default) <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) +> r))) + [target_tm]⊢⁺ + (section_481 xs) := by + rcases HC with ⟨c, e, He, rfl, ⟨HF, HE⟩⟩ + refine evstep_progress ?_ (by ne_cfg) + rcases HL with _ | _ | ⟨s, Hs⟩ | ⟨s, Hs⟩ | _ | a + · refine step_bridge (cleanup_one_zero r) (by cfg_eq) ?_ + refine step_bridge (HF.flow_root 0 0) (by cfg_eq) ?_ + exact step_end (root_plain_terminal ((1 + N) * 2) 0 c e He) (by cfg_eq) (by cfg_eq) + · refine step_bridge (cleanup_one_entry default 0 r) (by cfg_eq) ?_ + refine step_bridge (crossV_zero r 0 2 0) (by cfg_eq) ?_ + refine step_bridge (HF.flow_root 2 0) (by cfg_eq) ?_ + exact step_end (root_plain_terminal ((1 + N) * 2 + 2) 0 c e He) (by cfg_eq) (by cfg_eq) + · refine step_bridge (cleanup_one_entry default (1 + s * 2) r) (by cfg_eq) ?_ + refine step_bridge (HF.flow_border s (N - s) 0 (by omega)) (by cfg_eq) ?_ + exact step_end (root_plain_terminal ((N - s) * 2) (1 + s) c e He) (by cfg_eq) (by cfg_eq) + · refine step_bridge (cleanup_one_entry default (2 + s * 2) r) (by cfg_eq) ?_ + refine step_bridge (HE s (N - s) 0 (by omega)) (by cfg_eq) ?_ + exact step_end (root_plain_terminal (2 + (N - s) * 2) (1 + s) c e He) (by cfg_eq) (by cfg_eq) + · refine step_bridge (cleanup_one_entry default (3 + N * 2) r) (by cfg_eq) ?_ + refine step_bridge (HF.flow_cross default 1 0) (by cfg_eq) ?_ + exact step_end (crossW_last_one (1 + N) c e He) (by cfg_eq) (by cfg_eq) + · refine step_bridge (cleanup_one_entry default (4 + N * 2 + a) r) (by cfg_eq) ?_ + refine step_bridge (HF.flow_cross default (2 + a) 0) (by cfg_eq) ?_ + exact step_end (cross_plain_terminal default a (1 + N) c e He) (by cfg_eq) (by cfg_eq) + +theorem OneCleanup_triple (g d e : Nat) (He : e ≤ 1) : + OneCleanup ((([1, 0, 1, 0, 0, 1] : zF) ^ g) +> clean_input (1 + g * 2) (d * 2 + e) default) + (3 + g * 4 + d + e) (2 + g + d * 2 + e) := by + rcases g with _ | g + · rcases Pass_clean_tail_low 0 d e He with ⟨C_out, E, HE, HC, HP⟩ + exact ⟨C_out, E, HE, by omega, Pass_eq HP⟩ + · rcases Pass_clean_tail (1 + g) d e g He with ⟨C_out, E, HE, HC, HP⟩ + refine ⟨C_out, E, HE, by omega, ?_⟩ + have h1 : Pass (fun l a b => crossV l ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + g)) + +> clean_input (1 + (1 + g) * 2) (d * 2 + e) default) a b 2 0) + (fun a b => rootV ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + g)) + +> clean_input (1 + (1 + g) * 2) (d * 2 + e) default) a b 2 0) + (fun l a b => crossV l (clean_input (1 + (1 + g) * 2) (d * 2 + e) default) + a b (3 + 0) (0 + g)) + (fun a b => rootV (clean_input (1 + (1 + g) * 2) (d * 2 + e) default) a b (3 + 0) + (0 + g)) 2 := + Pass_eq (Pass_V_low (clean_input (1 + (1 + g) * 2) (d * 2 + e) default) g) + have h2 : Pass (fun l a b => crossV l (clean_input (1 + (1 + g) * 2) (d * 2 + e) default) + a b (3 + 0) (0 + g)) + (fun a b => rootV (clean_input (1 + (1 + g) * 2) (d * 2 + e) default) a b (3 + 0) + (0 + g)) + (fun l a b => crossV l (clean_input (1 + (1 + g) * 2) (d * 2 + e) default) + a b (3 + g) 0) + (fun a b => rootV (clean_input (1 + (1 + g) * 2) (d * 2 + e) default) a b (3 + g) + 0) (g * 2) := + Pass_eq (Pass_Vs (clean_input (1 + (1 + g) * 2) (d * 2 + e) default) 0 0 g) + exact Pass_eq (Pass_trans h1 (Pass_trans h2 HP)) + +theorem cleanup_triple_one_section (g d e t : Nat) (xs : List Nat) + (HP : P (2 + g * 2 + (d * 2 + e))) (He : e ≤ 1) + (HL : CleanLast (3 + g * 4 + d + e) (2 + g + d * 2 + e) t xs) : + (section_481 [(2 + g * 2 + (d * 2 + e)) + (2 + g * 2), 1, t]) + [target_tm]⊢⁺ (section_481 xs) := by + refine evstep_progress_trans ?_ (OneCleanup_spec _ _ _ t xs (OneCleanup_triple g d e He) HL) + refine step_bridge (return_even ((([1, 1, 0] : zF) ^ 1) +> ((([1, 0] : zF) ^ t) +> default)) + g (d * 2 + e) HP) (by cfg_eq) ?_ + exact step_end (pass_011 ((([1, 0] : zF) ^ t) +> default) _ 1) (by cfg_eq) (by cfg_eq) + +theorem cleanup_odd_triple_section (g b d e t : Nat) (xs : List Nat) + (HP : P (2 + g * 2 + (d * 2 + e))) (He : e ≤ 1) + (HL : CleanLast (3 + b + g * 4 + d + e) (2 + b * 2 + g + d * 2 + e) t xs) : + (section_481 [(2 + g * 2 + (d * 2 + e)) + (2 + g * 2), 1 + b * 2, t]) + [target_tm]⊢⁺ (section_481 xs) := by + rcases b with _ | b + · exact cleanup_triple_one_section g d e t xs HP He (CleanLast_eq HL) + · exact step_end_plus_eq (cleanup_triple_section g b d e t xs HP He (CleanLast_eq HL)) (by cfg_eq) + rfl + +def count00 : Fin 2 → zF → Nat + | _, [] => 0 + | p, x :: w => (if p == 0 && x == 0 then 1 else 0) + count00 x w + +theorem count00_U (n : Nat) (w : zF) (k : Nat) (H : ∀ p, count00 p w = k) (p : Fin 2) : + count00 p ((([1, 0] : zF) ^ n) ++ w) = k := by + induction n generalizing p with + | zero => exact H p + | succ n ih => + rcases p with ⟨_ | _ | p, hp⟩ <;> try omega + · dsimp [list_pow_succ, count00]; rw [ih 0]; omega + · dsimp [list_pow_succ, count00]; rw [ih 0]; omega + +theorem count00_V (n : Nat) (w : zF) (k : Nat) (H : ∀ p, count00 p w = k) (p : Fin 2) : + count00 p ((([1, 0, 1, 0, 0, 1] : zF) ^ n) ++ w) = n + k := by + induction n generalizing p with + | zero => simp only [list_pow_zero, List.nil_append, Nat.zero_add, H p] + | succ n ih => + rcases p with ⟨_ | _ | p, hp⟩ <;> try omega + · dsimp [list_pow_succ, count00]; rw [ih 1]; omega + · dsimp [list_pow_succ, count00]; rw [ih 1]; omega + +theorem EraseWord_count00 (w : zF) (u v : Nat) (H : EraseWord w u v) (p : Fin 2) : + count00 p w = v := by + induction H generalizing p with + | Erase_nil => rfl + | Erase_V n w u v _ ih => exact count00_V n w v ih p + | Erase_pair j k w u v _ ih => + rw [List.append_assoc] + exact count00_U (2 + j * 2) _ (1 + k + v) (fun q => count00_V (1 + k) w v ih q) p + +theorem EraseWord_unique (w : zF) (u v u' v' : Nat) + (H : EraseWord w u v) (K : EraseWord w u' v') : u = u' ∧ v = v' := by + have hc1 := EraseWord_count00 w u v H 1 + have hc2 := EraseWord_count00 w u' v' K 1 + have hs1 := EraseWord_size w u v H + have hs2 := EraseWord_size w u' v' K + omega + +def column_U : List (Nat × Nat) → Nat + | [] => 0 + | (_, b) :: cs => 1 + b + column_U cs + +def column_V : List (Nat × Nat) → Nat + | [] => 0 + | (a, _) :: cs => 1 + a + column_V cs + +theorem column_word_erase (cs : List (Nat × Nat)) : EraseWord (column_word cs) (column_U cs) + (column_V cs) := by + induction cs with + | nil => exact EraseWord.Erase_nil + | cons ab cs ih => + rcases ab with ⟨a, b⟩ + dsimp [column_word, column_U, column_V] + exact EraseWord_eq (EraseWord_app _ _ _ _ _ _ ih (EraseWord.Erase_pair b a [] 0 0 + EraseWord.Erase_nil)) + +theorem ColumnRun_balance (n : Nat) (cs : List (Nat × Nat)) (m : Nat) (H : ColumnRun n cs m) : + m + column_V cs = n + column_U cs := by + induction H with + | Columns_nil => rfl + | Columns_cons n a b cs m Ha _ ih => dsimp [column_U, column_V]; omega + +theorem Pass_erase_pair_low (r : zB) (j k : Nat) : + Pass (fun l a b => crossV l ((([1, 0] : zF) ^ (2 + j * 2)) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (1 + k)) +> r)) a b 2 0) + (fun a b => rootV ((([1, 0] : zF) ^ (2 + j * 2)) +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) + +> r)) a b 2 0) + (fun l a b => crossV l r a b (3 + k) 0) + (fun a b => rootV r a b (3 + k) 0) ((2 + j + k) * 2) := by + have h1 : Pass (fun l a b => crossV l ((([1, 0] : zF) ^ (2 + j * 2)) + +> ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) +> r)) a b 2 0) + (fun a b => rootV ((([1, 0] : zF) ^ (2 + j * 2)) +> ((([1, 0, 1, 0, 0, 1] : zF) + ^ (1 + k)) +> r)) a b 2 0) + (fun l a b => crossZ l ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) +> r) a b (3 + 0) + (1 + j * 2)) + (fun a b => rootZ ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) +> r) a b (3 + 0) + (1 + j * 2)) 2 := + Pass_eq (Pass_Vend_low ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) +> r) (1 + j * 2)) + have h2 := Pass_Zs ((([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) +> r) 0 1 j + have h3 := Pass_Z_to_V r 0 k + have h4 : Pass (fun l a b => crossV l r a b (3 + 0) k) + (fun a b => rootV r a b (3 + 0) k) + (fun l a b => crossV l r a b (3 + k) 0) + (fun a b => rootV r a b (3 + k) 0) (k * 2) := + Pass_eq (Pass_Vs r 0 0 k) + exact Pass_eq (Pass_trans h1 (Pass_trans h2 (Pass_trans h3 h4))) + +theorem Pass_Vs_low (r : zB) (e n : Nat) : + Pass (fun l a b => crossV l r a b 2 (e + n)) + (fun a b => rootV r a b 2 (e + n)) + (fun l a b => crossV l r a b (2 + n) e) + (fun a b => rootV r a b (2 + n) e) (n * 2) := by + rcases n with _ | n + · exact Pass_eq (Pass_id _ _) + · have h1 : Pass (fun l a b => crossV l r a b 2 (e + (n + 1))) + (fun a b => rootV r a b 2 (e + (n + 1))) + (fun l a b => crossV l r a b (3 + 0) (e + n)) + (fun a b => rootV r a b (3 + 0) (e + n)) 2 := + Pass_eq (Pass_V_low r (e + n)) + exact Pass_eq (Pass_trans h1 (Pass_Vs r 0 e n)) + +theorem EraseWord_pass_low (w : zF) (u v : Nat) (H : EraseWord w u v) (r : zB) : + Pass (fun l a b => crossV l (w +> r) a b 2 0) + (fun a b => rootV (w +> r) a b 2 0) + (fun l a b => crossV l r a b (2 + v) 0) + (fun a b => rootV r a b (2 + v) 0) ((u + v) * 2) := by + induction H generalizing r with + | Erase_nil => exact Pass_eq (Pass_id _ _) + | Erase_V n w u v H ih => + rcases n with _ | n + · exact Pass_eq (ih r) + · have h1 : Pass (fun l a b => crossV l (((([1, 0, 1, 0, 0, 1] : zF) ^ (n + 1)) ++ w) +> r) + a b 2 0) + (fun a b => rootV (((([1, 0, 1, 0, 0, 1] : zF) ^ (n + 1)) ++ w) +> r) a b 2 0) + (fun l a b => crossV l (w +> r) a b (3 + n) 0) + (fun a b => rootV (w +> r) a b (3 + n) 0) ((1 + n) * 2) := + Pass_eq (Pass_Vs_low (w +> r) 0 (1 + n)) + exact Pass_eq (Pass_trans h1 (EraseWord_pass w u v H r n)) + | Erase_pair j k w u v H ih => + have h1 : Pass (fun l a b => crossV l (((([1, 0] : zF) ^ (2 + j * 2)) + ++ (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + k)) ++ w) +> r) a b 2 0) + (fun a b => rootV (((([1, 0] : zF) ^ (2 + j * 2)) ++ (([1, 0, 1, 0, 0, 1] : zF) + ^ (1 + k)) ++ w) +> r) a b 2 0) + (fun l a b => crossV l (w +> r) a b (3 + k) 0) + (fun a b => rootV (w +> r) a b (3 + k) 0) ((2 + j + k) * 2) := + Pass_eq (Pass_erase_pair_low (w +> r) j k) + exact Pass_eq (Pass_trans h1 (EraseWord_pass w u v H r k)) + +theorem Pass_clean_link_low (j n : Nat) (z : zF) (u v c d : Nat) (r : zB) (HZ : EraseWord z u v) : + Pass (fun l a b => crossV l (clean_input (1 + j * 2) (n * 2) (link z c d r)) a b 2 0) + (fun a b => rootV (clean_input (1 + j * 2) (n * 2) (link z c d r)) a b 2 0) + (fun l a b => crossV l (clean_input c d r) a b (3 + n * 2 + v) 0) + (fun a b => rootV (clean_input c d r) a b (3 + n * 2 + v) 0) (4 + j * 2 + n + (u + v) + * 2) := by + rcases n with _ | n + · have h1 : Pass (fun l a b => crossV l (clean_input (1 + j * 2) 0 (link z c d r)) a b 2 0) + (fun a b => rootV (clean_input (1 + j * 2) 0 (link z c d r)) a b 2 0) + (fun l a b => crossV l (z +> clean_input c d r) a b (3 + 0) 0) + (fun a b => rootV (z +> clean_input c d r) a b (3 + 0) 0) ((2 + j) * 2) := + Pass_eq (Pass_erase_pair_low (z +> clean_input c d r) j 0) + exact Pass_eq (Pass_trans h1 (EraseWord_pass z u v HZ (clean_input c d r) 0)) + · have h1 : Pass (fun l a b => crossV l (clean_input (1 + j * 2) ((n + 1) * 2) (link z c d r)) + a b 2 0) + (fun a b => rootV (clean_input (1 + j * 2) ((n + 1) * 2) (link z c d r)) a b 2 0) + (fun l a b => crossZ l (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) + ^ (1 + (1 + n * 2))) +> link z c d r)) a b (3 + 0) (0 + j * 2)) + (fun a b => rootZ (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> link z c d r)) a b (3 + 0) (0 + j * 2)) 2 := + Pass_eq (Pass_Vend_low (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> link z c d r)) (j * 2)) + have h2 := Pass_Zs (([1, 0, 1] : zF) +> ((([0, 1, 0] : zF) ^ (1 + (1 + n * 2))) + +> link z c d r)) 0 0 j + have h3 := Pass_Z_back_low (link z c d r) (1 + n * 2) + have h4 : Pass (fun l a b => crossW l (link z c d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) + 0 (2 + (1 + n * 2))) + (fun a b => rootW (link z c d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) + 0 (2 + (1 + n * 2))) + (fun l a b => crossW l (link z c d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) ((1 + n) + * 2) 1) + (fun a b => rootW (link z c d r) a (([1, 0, 1, 0, 0, 1] : zF) ^ b) ((1 + n) * 2) + 1) (1 + n) := + Pass_eq (Pass_Ws (link z c d r) 0 1 (1 + n)) + have h5 := Pass_odd_join r ((1 + n) * 2) z c d + have h6 := EraseWord_pass z u v HZ (clean_input c d r) ((1 + n) * 2) + exact Pass_eq (Pass_trans h1 (Pass_trans h2 (Pass_trans h3 (Pass_trans h4 (Pass_trans h5 h6))))) + +theorem RRoute_clean_low (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) + (HR : RRoute c d r n w C_out e default) (He : e ≤ 1) : + ∃ u v N C' E, EraseWord w u v ∧ E ≤ 1 ∧ + N + n = (u + v) * 2 + 3 + C_out + e ∧ C' + E = 1 + v + n * 2 + e ∧ + Pass (fun l a b => crossV l (clean_input c d r) a b 2 0) + (fun a b => rootV (clean_input c d r) a b 2 0) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C' E) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C' E) N := by + generalize hR : (default : zB) = R at HR + rcases HR with ⟨j, n, e, r⟩ | ⟨j, n, z, x, y, c', d, r, m, w, C_out, e, R, HZ, HR⟩ + · subst hR + rcases Pass_clean_tail_low j n e He with ⟨C', E, HE, HC, HP⟩ + exact ⟨0, 0, 4 + j * 2 + n + e, C', E, EraseWord.Erase_nil, HE, by omega, by omega, HP⟩ + · subst hR + rcases RRoute_clean c' d r m w C_out e default HR rfl He with ⟨u, v, HW, HK⟩ + rcases HK (n * 2 + y) with ⟨N, C', E, HE, HN, HC, HP⟩ + refine ⟨1 + (j + n) + x + u, 1 + y + v, 4 + j * 2 + n + (x + y) * 2 + N, C', E, ?_, HE, + by omega, by omega, ?_⟩ + · exact EraseWord_eq (EraseWord.Erase_pair (j + n) 0 (z ++ w) (x + u) (y + v) + (EraseWord_app z x y w u v HZ HW)) + · have h1 := Pass_clean_link_low j n z x y c' d r HZ + have h2 : Pass (fun l a b => crossV l (clean_input c' d r) a b (3 + n * 2 + y) 0) + (fun a b => rootV (clean_input c' d r) a b (3 + n * 2 + y) 0) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C' E) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C' E) N := + Pass_eq HP + exact Pass_eq (Pass_trans h1 h2) + +theorem RRoute_clean_at2 (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e u v k : Nat) + (HR : RRoute c d r n w C_out e default) (HW : EraseWord w u v) (He : e ≤ 1) : + ∃ N C' E, E ≤ 1 ∧ N + n = (u + v) * 2 + 3 + C_out + e ∧ C' + E = 1 + k + v + n * 2 + e ∧ + Pass (fun l a b => crossV l (clean_input c d r) a b (2 + k) 0) + (fun a b => rootV (clean_input c d r) a b (2 + k) 0) + (fun l a b => crossW l default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C' E) + (fun a b => rootW default a (([1, 0, 1, 0, 0, 1] : zF) ^ b) C' E) N := by + rcases k with _ | k + · rcases RRoute_clean_low c d r n w C_out e HR He with ⟨x, y, N, C', E, HZ, HE, HN, HC, HP⟩ + rcases EraseWord_unique w x y u v HZ HW with ⟨rfl, rfl⟩ + exact ⟨N, C', E, HE, HN, by omega, Pass_eq HP⟩ + · rcases RRoute_clean c d r n w C_out e default HR rfl He with ⟨x, y, HZ, HK⟩ + rcases EraseWord_unique w x y u v HZ HW with ⟨rfl, rfl⟩ + rcases HK k with ⟨N, C', E, HE, HN, HC, HP⟩ + exact ⟨N, C', E, HE, HN, by omega, Pass_eq HP⟩ + +theorem RRoute_capacity_bound (c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) (R : zB) + (HR : RRoute c d r n w C_out e R) (u v : Nat) (HW : EraseWord w u v) : n ≤ u + C_out := by + induction HR generalizing u v with + | RRoute_done => omega + | RRoute_more j n z x y c' d r m w C_out e R HZ HR ih => + rcases RRoute_erase _ _ _ _ _ _ _ _ HR with ⟨i, k, HK⟩ + have hi := ih i k HK + have HT : EraseWord (([1, 0] : zF) ^ (2 + (j + n) * 2) ++ [1, 0, 1, 0, 0, 1] ++ z ++ w) + (1 + (j + n) + x + i) (1 + y + k) := + EraseWord_eq (EraseWord.Erase_pair (j + n) 0 (z ++ w) (x + i) (y + k) + (EraseWord_app z x y w i k HZ HK)) + rcases EraseWord_unique _ _ _ _ _ HW HT with ⟨rfl, rfl⟩ + omega + +theorem RRoute_one_cleanup (z : zF) (i j c d : Nat) (r : zB) (n : Nat) (w : zF) (C_out e : Nat) + (HZ : EraseWord z i j) (HR : RRoute c d r n w C_out e default) (He : e ≤ 1) : + ∃ u v N X, EraseWord w u v ∧ + N + n = (i + j + u + v) * 2 + 2 + C_out + e ∧ X = 2 + j + v + n * 2 + e ∧ + OneCleanup (z +> clean_input c d r) N X := by + rcases RRoute_erase _ _ _ _ _ _ _ _ HR with ⟨u, v, HW⟩ + rcases RRoute_clean_at2 c d r n w C_out e u v j HR HW He with ⟨N, C', E, HE, HN, HC, HP⟩ + have hcap := RRoute_capacity_bound c d r n w C_out e default HR u v HW + refine ⟨u, v, (i + j) * 2 + N - 1, 1 + C' + E, HW, by omega, by omega, ?_⟩ + refine ⟨C', E, HE, rfl, ?_⟩ + exact Pass_eq (Pass_trans (EraseWord_pass_low z i j HZ (clean_input c d r)) HP) + +theorem RCounter_one_cleanup (l r : zB) (n : Nat) (w : zF) (C_out e a : Nat) + (HR : RCounter r n w C_out e) (Ha : a ≤ n) (He : e ≤ 1) : + ∃ u v N X r', EraseWord w u v ∧ + N + n = a * 3 + (u + v) * 2 + 2 + C_out + e ∧ X + a = 2 + v + n * 2 + e ∧ OneCleanup r' N X ∧ + ((((([1, 0] : zF) ^ (2 + a * 2)) +> (([1, 1, 0] : zF) +> l)) <{{C}} (([0, 1] : zF) +> r))) + [target_tm]⊢* + (l <{{C}} (([0, 1, 0, 1, 0, 0, 1, 0, 0, 1] : zF) +> r')) := by + rcases HR with ⟨d, s, rfl, HR⟩ + rcases RRoute_scan 1 d s n w C_out e default HR a (([1, 1, 0] : zF) +> l) + [] [] [] Ha Word_nil with + ⟨c', d', s', u, z, i, j, HZ, EW, HU, HS⟩ + rcases RRoute_one_cleanup ((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ u) i (a + j) c' d' s' (n - a) + z C_out e + (EraseWord.Erase_V a u i j HU) HZ He with ⟨x, y, N, X, HW, HN, HX, HC⟩ + refine ⟨i + x, j + y, N, X, (((([1, 0, 1, 0, 0, 1] : zF) ^ a) ++ u) +> clean_input c' d' s'), ?_, + by omega, by omega, HC, ?_⟩ + · rw [EW]; exact EraseWord_app u i j z x y HU HW + · refine step_bridge (scan_pair ((([1, 0] : zF) ^ (a * 2)) +> (([1, 1, 0] : zF) +> l)) s 0 d) + (by cfg_eq) ?_ + refine ReachesStar.trans HS ?_ + exact step_end (pass_011 l _ 1) (by cfg_eq) (by cfg_eq) + +def CleanRight (r : zB) (N X : Nat) : Prop := + ∀ t xs, CleanLast N X t xs → + ((((([1, 0] : zF) ^ t) +> default) <{{C}} (([0, 1] : zF) +> r))) [target_tm]⊢⁺ (section_481 xs) + +theorem Cleanup_right (r : zB) (N X : Nat) (H : Cleanup r N X) : CleanRight r N X := + fun t xs HL => Cleanup_spec r N X t xs H HL + +theorem OneCleanup_right (r : zB) (N X : Nat) (H : OneCleanup r N X) : + CleanRight (([0, 1, 0, 0, 1, 0, 0, 1] : zF) +> r) N X := + fun t xs HL => step_end_plus_eq (OneCleanup_spec r N X t xs H HL) (by cfg_eq) rfl + +theorem RCounter_odd_cleanup (l r : zB) (n : Nat) (w : zF) (C_out e a b : Nat) + (HR : RCounter r n w C_out e) (Ha : a ≤ n) (He : e ≤ 1) : + ∃ u v N X r', EraseWord w u v ∧ + N + n = b + a * 3 + (u + v) + * 2 + 2 + C_out + e ∧ X + a = 2 + b * 2 + v + n * 2 + e ∧ CleanRight r' N X ∧ + ((((([1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 1, 0] : zF) ^ (1 + b * 2)) +> l)) + <{{C}} (([0, 1] : zF) +> r))) [target_tm]⊢* + (l <{{C}} (([0, 1] : zF) +> r')) := by + rcases b with _ | b + · rcases RCounter_one_cleanup l r n w C_out e a HR Ha He with ⟨u, v, N, X, r', HW, HN, HX, HC, HT⟩ + refine ⟨u, v, N, X, (([0, 1, 0, 0, 1, 0, 0, 1] : zF) +> r'), HW, by omega, by omega, + OneCleanup_right r' N X HC, ?_⟩ + exact step_end HT (by cfg_eq) (by cfg_eq) + · rcases RCounter_cleanup l r n w C_out e a b HR Ha He with ⟨u, v, N, X, r', HW, HN, HX, HC, HT⟩ + refine ⟨u, v, N, X, r', HW, by omega, by omega, Cleanup_right r' N X HC, ?_⟩ + exact step_end HT (by cfg_eq) (by cfg_eq) + +def column_list : List (Nat × Nat) → List Nat + | [] => [] + | (a, b) :: cs => (2 + a * 2) :: (2 + b * 2) :: column_list cs + +theorem column_list_side (cs : List (Nat × Nat)) (xs : List Nat) : + section_side (column_list cs ++ xs) true = column_side (section_side xs true) cs := by + induction cs with + | nil => rfl + | cons ab cs ih => + rcases ab with ⟨a, b⟩ + dsimp [column_list, section_side, column_side] + rw [ih] + +theorem column_image_side (cs : List (Nat × Nat)) (xs : List Nat) : + section_side (column_list cs ++ xs) + false = (column_image cs).reverse +> section_side xs false := by + induction cs with + | nil => rfl + | cons ab cs ih => + rcases ab with ⟨a, b⟩ + dsimp [column_list, section_side, column_image] + rw [ih] + cfg_eq + +theorem restored_section (p g b : Nat) (cs : List (Nat × Nat)) (a t : Nat) : + section_481 (p :: (2 + g * 2) :: b :: column_list cs ++ [a, t]) = + (((([1, 0] : zF) ^ p) +> (((column_image cs ++ ([0, 1] : zF) ^ b ++ ([0, 1, 1, 0, 1, 1] : zF) + ^ (1 + g)).reverse) +> ((([1, 1, 0] : zF) ^ a) +> ((([1, 0] : zF) ^ t) +> default)))) + {{B}}> default) := by + dsimp only [section_481, section_side, List.cons_append] + rw [column_image_side] + dsimp only [section_side] + cfg_eq + +theorem restored_section_good (p : Nat) (cs : List (Nat × Nat)) (a t : Nat) : + section_481 (p :: column_list cs ++ [a, t]) = + (((([1, 0] : zF) ^ p) +> ((column_image cs).reverse +> ((([1, 1, 0] : zF) ^ a) + +> ((([1, 0] : zF) ^ t) +> default)))) {{B}}> default) := by + dsimp only [section_481, section_side, List.cons_append] + rw [column_image_side] + dsimp only [section_side] + +theorem gap_column_word (g b : Nat) (cs : List (Nat × Nat)) : + ∃ x, Word (column_word cs ++ ((([1, 0] : zF) ^ (2 + b * 2)) ++ (([1, 0, 1, 0, 0, 1] : zF) + ^ (1 + g)))) x + (column_image cs ++ ((([0, 1] : zF) ^ (2 + b * 2)) ++ (([0, 1, 1, 0, 1, 1] : zF) + ^ (1 + g)))) := by + rcases column_word_spec cs with ⟨x, HX⟩ + exact ⟨_, Word_app _ _ _ _ _ _ HX (Word_app _ _ _ _ _ _ (Word_pow _ _ _ (2 + b * 2) Word_U) + (Word_pow _ _ _ (1 + g) Word_V))⟩ + +theorem gap_normal_section (g b d e : Nat) (cs : List (Nat × Nat)) (m s : Nat) + (HP : P (2 + g * 2 + (d * 2 + e))) (HC : ColumnRun (b + d) cs m) (Hs : s ≤ m) (He : e ≤ 1) : + (section_481 (((2 + g * 2 + (d * 2 + e)) + + (2 + g * 2)) :: (2 + b * 2) :: column_list cs ++ [3 + s * 2])) [target_tm]⊢⁺ + (section_481 ((2 + g * 2 + (d * 2 + e)) :: (2 + g * 2) :: (2 + b * 2) :: column_list cs ++ + [2 + s * 2, 5 + (m - s) * 2])) := by + rcases gap_column_word g b cs with ⟨x, HW⟩ + have h1 := section_columns_normal (b + d) _ (1 + g * 2 + d * 2) e _ cs m s x _ + (SectionStart.Start_gap g b d e HP) HC Hs He HW + refine step_end_plus_eq h1 ?_ ?_ + · dsimp [section_481, section_side]; rw [column_list_side]; dsimp [section_side] + · rw [restored_section]; cfg_eq + +theorem gap_overflow_section (g b d e : Nat) (cs : List (Nat × Nat)) (m s : Nat) + (HP : P (2 + g * 2 + (d * 2 + e))) (HC : ColumnRun (b + d) cs m) (He : e ≤ 1) : + (section_481 (((2 + g * 2 + (d * 2 + e)) + + (2 + g * 2)) :: (2 + b * 2) :: column_list cs ++ [5 + m * 2 + s * 2])) [target_tm]⊢⁺ + (section_481 ((2 + g * 2 + (d * 2 + e)) :: (2 + g * 2) :: (2 + b * 2) :: column_list cs ++ + [5 + m * 2, s * 2])) := by + rcases gap_column_word g b cs with ⟨x, HW⟩ + have h1 := section_columns_overflow (b + d) _ (1 + g * 2 + d * 2) e _ cs m s x _ + (SectionStart.Start_gap g b d e HP) HC He HW + refine step_end_plus_eq h1 ?_ ?_ + · dsimp [section_481, section_side]; rw [column_list_side]; dsimp [section_side] + · rw [restored_section]; cfg_eq + +theorem good_normal_section (d b e : Nat) (cs : List (Nat × Nat)) (m s : Nat) + (HP : P (2 + d * 2 + e)) (HC : ColumnRun (1 + d + b) cs m) (Hs : s ≤ m) (He : e ≤ 1) : + (section_481 ((2 + d * 2 + e) :: (2 + b * 2) :: column_list cs ++ [3 + s * 2])) [target_tm]⊢⁺ + (section_481 ((4 + d * 2 + b * 2 + e) :: column_list cs ++ [2 + s * 2, 5 + (m - s) * 2])) := by + rcases column_word_spec cs with ⟨x, HW⟩ + rw [← List.append_nil (column_word cs)] at HW + have h1 := section_columns_normal (1 + d + b) [] (3 + d * 2 + b * 2) e _ cs m s x _ + (SectionStart.Start_good d b e HP) HC Hs He HW + refine step_end_plus_eq h1 ?_ ?_ + · dsimp [section_481, section_side]; rw [column_list_side]; dsimp [section_side] + · rw [restored_section_good]; cfg_eq + +theorem good_overflow_section (d b e : Nat) (cs : List (Nat × Nat)) (m s : Nat) + (HP : P (2 + d * 2 + e)) (HC : ColumnRun (1 + d + b) cs m) (He : e ≤ 1) : + (section_481 ((2 + d * 2 + e) :: (2 + b * 2) :: column_list cs ++ [5 + m * 2 + s * 2])) + [target_tm]⊢⁺ + (section_481 ((4 + d * 2 + b * 2 + e) :: column_list cs ++ [5 + m * 2, s * 2])) := by + rcases column_word_spec cs with ⟨x, HW⟩ + rw [← List.append_nil (column_word cs)] at HW + have h1 := section_columns_overflow (1 + d + b) [] (3 + d * 2 + b * 2) e _ cs m s x _ + (SectionStart.Start_good d b e HP) HC He HW + refine step_end_plus_eq h1 ?_ ?_ + · dsimp [section_481, section_side]; rw [column_list_side]; dsimp [section_side] + · rw [restored_section_good]; cfg_eq + +theorem section_columns_cleanup (n : Nat) (w : zF) (C_out e : Nat) (c : Cfg (Fin 2) (Fin 6)) + (cs : List (Nat × Nat)) (m a b u v t : Nat) + (HStart : SectionStart (column_side (((([1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 1, 0] : zF) + ^ (1 + b * 2)) +> ((([1, 0] : zF) ^ t) +> default)))) cs) n w C_out e c) + (HW : EraseWord w u v) (HCols : ColumnRun n cs m) (Ha : a ≤ m) (He : e ≤ 1) : + ∃ N X, N + m = b + a * 3 + (column_U cs + column_V cs + u + v) * 2 + 2 + C_out + e ∧ + X + a = 2 + b * 2 + column_V cs + v + m * 2 + e ∧ + ∀ xs, CleanLast N X t xs → c [target_tm]⊢⁺ (section_481 xs) := by + rcases SectionStart_Rspec _ _ _ _ _ _ HStart with ⟨r, HR, T0⟩ + rcases RCounter_columns n cs m HCols (((([1, 0] : zF) ^ (2 + a * 2)) +> ((([1, 1, 0] : zF) + ^ (1 + b * 2)) +> ((([1, 0] : zF) ^ t) +> default)))) r w C_out e HR with ⟨r0, H0, T1⟩ + rcases RCounter_odd_cleanup ((([1, 0] : zF) ^ t) +> default) r0 m _ C_out e a b H0 Ha He with ⟨i, + j, N, X, r1, H1, HN, HX, HC, T2⟩ + rcases EraseWord_unique _ _ _ _ _ H1 (EraseWord_app _ _ _ _ _ _ (column_word_erase cs) HW) + with ⟨rfl, rfl⟩ + refine ⟨N, X, by omega, by omega, fun xs HL => ?_⟩ + exact evstep_progress_trans T0 (evstep_progress_trans T1 (evstep_progress_trans T2 (HC t xs HL))) + +theorem gap_cleanup_section (g b0 d e : Nat) (cs : List (Nat × Nat)) (m a b t N X : Nat) + (xs : List Nat) + (HP : P (2 + g * 2 + (d * 2 + e))) (HCols : ColumnRun (b0 + d) cs m) (Ha : a ≤ m) (He : e ≤ 1) + (HN : N + m = b + a * 3 + (column_U cs + column_V cs + (1 + b0) + (1 + g)) + * 2 + 3 + g * 2 + d * 2 + e) + (HX : X + a = 3 + b * 2 + column_V cs + g + m * 2 + e) (HL : CleanLast N X t xs) : + (section_481 (((2 + g * 2 + (d * 2 + e)) + + (2 + g * 2)) :: (2 + b0 * 2) :: column_list cs ++ [2 + a * 2, 1 + b * 2, t])) + [target_tm]⊢⁺ + (section_481 xs) := by + have HW : EraseWord ((([1, 0] : zF) ^ (2 + b0 * 2)) ++ (([1, 0, 1, 0, 0, 1] : zF) ^ (1 + g))) + (1 + b0) (1 + g) := + EraseWord_eq (EraseWord.Erase_pair b0 g [] 0 0 EraseWord.Erase_nil) + rcases section_columns_cleanup (b0 + d) _ (1 + g * 2 + d * 2) e _ cs m a b (1 + b0) (1 + g) t + (SectionStart.Start_gap g b0 d e HP) HW HCols Ha He with ⟨N0, X0, HN0, HX0, HT⟩ + have hN : N0 = N := by omega + have hX : X0 = X := by omega + subst hN; subst hX + refine step_end_plus_eq (HT xs HL) ?_ rfl + dsimp [section_481, section_side]; rw [column_list_side]; dsimp [section_side] + +theorem good_cleanup_section (d b0 e : Nat) (cs : List (Nat × Nat)) (m a b t N X : Nat) + (xs : List Nat) + (HP : P (2 + d * 2 + e)) (HCols : ColumnRun (1 + d + b0) cs m) (Ha : a ≤ m) (He : e ≤ 1) + (HN : N + m = b + a * 3 + (column_U cs + column_V cs) * 2 + 5 + d * 2 + b0 * 2 + e) + (HX : X + a = 2 + b * 2 + column_V cs + m * 2 + e) (HL : CleanLast N X t xs) : + (section_481 ((2 + d * 2 + e) :: (2 + b0 * 2) :: column_list cs ++ [2 + a * 2, 1 + b * 2, t])) + [target_tm]⊢⁺ + (section_481 xs) := by + rcases section_columns_cleanup (1 + d + b0) [] (3 + d * 2 + b0 * 2) e _ cs m a b 0 0 t + (SectionStart.Start_good d b0 e HP) EraseWord.Erase_nil HCols Ha He with ⟨N0, X0, HN0, HX0, HT⟩ + have hN : N0 = N := by omega + have hX : X0 = X := by omega + subst hN; subst hX + refine step_end_plus_eq (HT xs HL) ?_ rfl + dsimp [section_481, section_side]; rw [column_list_side]; dsimp [section_side] + +theorem P_eq {n1 n2 : Nat} (h : P n1) (heq : n1 = n2 := by omega) : P n2 := by subst heq; exact h +theorem PP_eq {n1 n2 : Nat} (h : PP n1) (heq : n1 = n2 := by omega) : PP n2 := by subst heq; exact h + +inductive BoundedRun (h : Nat) : Nat → List (Nat × Nat) → Nat → Prop where + | Bounded_nil (n : Nat) : n ≤ h → BoundedRun h n [] n + | Bounded_cons (n a b : Nat) (cs : List (Nat × Nat)) (m : Nat) : + n ≤ h → a ≤ n → BoundedRun h (n - a + b) cs m → BoundedRun h n ((a, b) :: cs) m + +theorem Bounded_eq {h1 h2 n1 n2 m1 m2 : Nat} {cs1 cs2 : List (Nat × Nat)} + (H : BoundedRun h1 n1 cs1 m1) + (hh : h1 = h2 := by omega) (hn : n1 = n2 := by omega) + (hcs : cs1 = cs2 := by rfl) (hm : m1 = m2 := by omega) : + BoundedRun h2 n2 cs2 m2 := by + subst hh; subst hn; subst hcs; subst hm; exact H + +theorem Bounded_forget (h n : Nat) (cs : List (Nat × Nat)) (m : Nat) (H : BoundedRun h n cs m) : + ColumnRun n cs m := by + induction H with + | Bounded_nil n _ => exact ColumnRun.Columns_nil n + | Bounded_cons n a b cs m _ ha _ ih => exact ColumnRun.Columns_cons n a b cs m ha ih + +theorem Bounded_ends (h n : Nat) (cs : List (Nat × Nat)) (m : Nat) (H : BoundedRun h n cs m) : + n ≤ h ∧ m ≤ h := by + induction H with + | Bounded_nil n hn => exact ⟨hn, hn⟩ + | Bounded_cons n a b cs m hn _ _ ih => exact ⟨hn, ih.2⟩ + +def flip_columns (b : Nat) : List (Nat × Nat) → Nat → List (Nat × Nat) + | [], s => [(b, s)] + | (a, b') :: cs, s => (b, a) :: flip_columns b' cs s + +def flip_front (b : Nat) : List (Nat × Nat) → List (Nat × Nat) + | [] => [] + | (a, b') :: cs => (b, a) :: flip_front b' cs + +def last_column (b : Nat) : List (Nat × Nat) → Nat + | [] => b + | (_, b') :: cs => last_column b' cs + +theorem flip_columns_list (b : Nat) (cs : List (Nat × Nat)) (s : Nat) : + column_list (flip_columns b cs s) = (2 + b * 2) :: column_list cs ++ [2 + s * 2] := by + induction cs generalizing b with + | nil => rfl + | cons ab cs ih => + rcases ab with ⟨a, b'⟩ + dsimp [flip_columns, column_list] + rw [ih b']; rfl + +theorem flip_front_list (b : Nat) (cs : List (Nat × Nat)) (xs : List Nat) : + column_list (flip_front b cs) ++ (2 + last_column b cs * 2) :: xs = + (2 + b * 2) :: column_list cs ++ xs := by + induction cs generalizing b with + | nil => rfl + | cons ab cs ih => + rcases ab with ⟨a, b'⟩ + dsimp [flip_front, last_column, column_list] + rw [ih b']; rfl + +theorem flip_front_counts (b : Nat) (cs : List (Nat × Nat)) : + column_U (flip_front b cs) = column_V cs ∧ + column_V (flip_front b cs) + last_column b cs = b + column_U cs := by + induction cs generalizing b with + | nil => dsimp [flip_front, last_column, column_U, column_V]; omega + | cons ab cs ih => + rcases ab with ⟨a, b'⟩ + rcases ih b' with ⟨h1, h2⟩ + dsimp [flip_front, last_column, column_U, column_V] + omega + +theorem Bounded_flip (h n : Nat) (cs : List (Nat × Nat)) (m : Nat) (H : BoundedRun h n cs m) + (b r s : Nat) (Hb : b ≤ n) (Hr : r + n = h + b) (Hs : s ≤ m) : + BoundedRun h r (flip_columns b cs s) (h - m + s) := by + induction H generalizing b r with + | Bounded_nil n hn => + dsimp [flip_columns] + refine BoundedRun.Bounded_cons r b s [] (h - n + s) (by omega) (by omega) ?_ + exact Bounded_eq (@BoundedRun.Bounded_nil h (h - n + s) (by omega)) + | Bounded_cons n a b' cs m hn ha _ ih => + dsimp [flip_columns] + exact BoundedRun.Bounded_cons r b a (flip_columns b' cs s) (h - m + s) (by omega) (by omega) + (ih b' (r - b + a) (by omega) (by omega) Hs) + +theorem Bounded_flip_front (h n : Nat) (cs : List (Nat × Nat)) (m : Nat) (H : BoundedRun h n cs m) + (b r : Nat) (Hb : b ≤ n) (Hr : r + n = h + b) : + ∃ q, BoundedRun h r (flip_front b cs) + q ∧ last_column b cs ≤ q ∧ q + m = h + last_column b cs := by + induction H generalizing b r with + | Bounded_nil n hn => + exact ⟨r, BoundedRun.Bounded_nil r (by omega), by dsimp [last_column]; omega, + by dsimp [last_column]; omega⟩ + | Bounded_cons n a b' cs m hn ha _ ih => + rcases ih b' (r - b + a) (by omega) (by omega) with ⟨q, HQ, HL, HE⟩ + exact ⟨q, BoundedRun.Bounded_cons r b a (flip_front b' cs) q (by omega) (by omega) HQ, HL, HE⟩ + +inductive Stair (p e : Nat) : List Nat → Prop where + | Stair_good (d b : Nat) (cs : List (Nat × Nat)) (m s : Nat) : + p = 2 + d * 2 + e → BoundedRun (p - 1 - e) (1 + d + b) cs m → m + s = p - e → + Stair p e (p :: (2 + b * 2) :: column_list cs ++ [3 + s * 2]) + | Stair_gap (g b d : Nat) (cs : List (Nat × Nat)) (m s : Nat) : + p = 2 + g * 2 + (d * 2 + e) → BoundedRun (p - 1 - e) (b + d) cs m → m + s = p - e → + Stair p e ((p + (2 + g * 2)) :: (2 + b * 2) :: column_list cs ++ [3 + s * 2]) + +macro "list_nat_eq" : tactic => + `(tactic| first + | rfl + | ((try simp only [flip_columns_list, flip_front_list, column_list, + List.cons_append, List.nil_append, List.append_assoc, + List.cons.injEq, list_append_inj, and_true, true_and]); + ((repeat' constructor) <;> first | trivial | omega))) + +theorem Stair_eq {p1 p2 e1 e2 : Nat} {xs1 xs2 : List Nat} + (H : Stair p1 e1 xs1) + (hp : p1 = p2 := by omega) (he : e1 = e2 := by omega) (hxs : xs1 = xs2 := by list_nat_eq) : + Stair p2 e2 xs2 := by + subst hp; subst he; subst hxs; exact H + +theorem section_step_eq {xs1 xs2 ys1 ys2 : List Nat} + (H : (section_481 xs1) [target_tm]⊢⁺ (section_481 ys1)) + (hxs : xs1 = xs2 := by list_nat_eq) (hys : ys1 = ys2 := by list_nat_eq) : + (section_481 xs2) [target_tm]⊢⁺ (section_481 ys2) := by + subst hxs; subst hys; exact H + +theorem section_evstep_eq {xs1 xs2 ys1 ys2 : List Nat} + (H : (section_481 xs1) [target_tm]⊢* (section_481 ys1)) + (hxs : xs1 = xs2 := by list_nat_eq) (hys : ys1 = ys2 := by list_nat_eq) : + (section_481 xs2) [target_tm]⊢* (section_481 ys2) := by + subst hxs; subst hys; exact H + +theorem stair_gap_normal (g b d e : Nat) (cs : List (Nat × Nat)) (m s : Nat) + (_He : e ≤ 1) (HR : BoundedRun ((2 + g * 2 + (d * 2 + e)) - 1 - e) (b + d) cs m) + (HS : m + s = (2 + g * 2 + (d * 2 + e)) - e) (Hs : s ≤ m) : + Stair (2 + g * 2 + (d * 2 + e)) e + ((2 + g * 2 + (d * 2 + e)) :: (2 + g * 2) :: (2 + b * 2) :: column_list cs ++ + [2 + s * 2, 5 + (m - s) * 2]) := by + rcases Bounded_ends _ _ _ _ HR with ⟨Hn, Hm⟩ + refine Stair_eq (@Stair.Stair_good (2 + g * 2 + (d * 2 + e)) e (g + d) g (flip_columns b cs s) + ((2 + g * 2 + (d * 2 + e)) - 1 - e - m + s) (1 + m - s) (by omega) ?_ (by omega)) + exact Bounded_flip _ _ _ _ HR b (1 + (g + d) + g) s (by omega) (by omega) Hs + +theorem stair_good_normal (d b e : Nat) (cs : List (Nat × Nat)) (m s : Nat) + (_He : e ≤ 1) (HR : BoundedRun ((2 + d * 2 + e) - 1 - e) (1 + d + b) cs m) + (HS : m + s = (2 + d * 2 + e) - e) (Hs : s ≤ m) : + Stair (2 + d * 2 + e) + e ((4 + d * 2 + b * 2 + e) :: column_list cs ++ [2 + s * 2, 5 + (m - s) * 2]) := by + rcases Bounded_ends _ _ _ _ HR with ⟨Hn, Hm⟩ + have Hb : b ≤ d := by omega + rcases cs with _ | ⟨⟨a, b'⟩, cs⟩ + · cases HR with + | Bounded_nil _ _ => + refine Stair_eq (@Stair.Stair_gap (2 + d * 2 + e) e b s (d - b) [] (s + (d - b)) + (1 + (1 + d + b) - s) + (by omega) ?_ (by omega)) + exact BoundedRun.Bounded_nil _ (by omega) + · cases HR with + | Bounded_cons _ _ _ _ _ Hn' Ha HT => + refine Stair_eq (@Stair.Stair_gap (2 + d * 2 + e) e b a (d - b) (flip_columns b' cs s) + ((2 + d * 2 + e) - 1 - e - m + s) (1 + m - s) (by omega) ?_ (by omega)) + exact Bounded_flip _ _ _ _ HT b' (a + (d - b)) s (by omega) (by omega) Hs + +theorem clean_after_gap (g b d e : Nat) (cs : List (Nat × Nat)) (m t : Nat) (xs : List Nat) + (HP : P (2 + g * 2 + (d * 2 + e))) (He : e ≤ 1) + (HR : BoundedRun ((2 + g * 2 + (d * 2 + e)) - 1 - e) (b + d) cs m) + (HC : CleanLast ((2 + g * 2 + (d * 2 + e)) + (1 + b + column_U cs) * 4) + ((2 + g * 2 + (d * 2 + e)) * 2 + 3 - e + (1 + b + column_U cs)) t xs) : + (section_481 ((2 + g * 2 + (d * 2 + e)) :: (2 + g * 2) :: (2 + b * 2) :: column_list cs ++ + [5 + m * 2, t])) [target_tm]⊢⁺ + (section_481 xs) := by + rcases Bounded_Ends : Bounded_ends _ _ _ _ HR with ⟨Hn, Hm⟩ + rcases Bounded_flip_front _ _ _ _ HR b (1 + (g + d) + g) (by omega) (by omega) with ⟨q, HQ, HL, + HE⟩ + have HB := ColumnRun_balance _ _ _ (Bounded_forget _ _ _ _ HR) + rcases flip_front_counts b cs with ⟨HU, HV⟩ + have HP' : P (2 + (g + d) * 2 + e) := P_eq HP + have hstep := good_cleanup_section (g + d) g e (flip_front b cs) q (last_column b cs) + (2 + m) t ((2 + g * 2 + (d * 2 + e)) + (1 + b + column_U cs) * 4) + ((2 + g * 2 + (d * 2 + e)) * 2 + 3 - e + (1 + b + column_U cs)) xs + HP' (Bounded_forget _ _ _ _ HQ) HL He (by omega) (by omega) HC + refine section_step_eq hstep ?_ rfl + have hfl := flip_front_list b cs [1 + (2 + m) * 2, t] + simp only [List.cons_append] at hfl ⊢ + rw [hfl] + list_nat_eq + +theorem clean_after_good (d b e : Nat) (cs : List (Nat × Nat)) (m t : Nat) (xs : List Nat) + (HP : P (2 + d * 2 + e)) (He : e ≤ 1) + (HR : BoundedRun ((2 + d * 2 + e) - 1 - e) (1 + d + b) cs m) + (HC : CleanLast ((2 + d * 2 + e) + (1 + b + column_U cs) * 4) + ((2 + d * 2 + e) * 2 + 3 - e + (1 + b + column_U cs)) t xs) : + (section_481 ((4 + d * 2 + b * 2 + e) :: column_list cs ++ [5 + m * 2, t])) [target_tm]⊢⁺ + (section_481 xs) := by + rcases Bounded_ends _ _ _ _ HR with ⟨Hn, Hm⟩ + have Hb : b ≤ d := by omega + rcases cs with _ | ⟨⟨a, b'⟩, cs⟩ + · cases HR with + | Bounded_nil _ _ => + dsimp [column_list, column_U] at HC ⊢ + exact section_step_eq (cleanup_odd_triple_section b (2 + (1 + d + b)) (d - b) e t xs (P_eq HP) + He (CleanLast_eq HC)) + · cases HR with + | Bounded_cons _ _ _ _ _ Hn' Ha HT => + rcases Bounded_flip_front _ _ _ _ HT b' (a + (d - b)) (by omega) (by omega) with ⟨q, HQ, HL, + HE⟩ + have HB := ColumnRun_balance _ _ _ (Bounded_forget _ _ _ _ HT) + rcases flip_front_counts b' cs with ⟨HU, HV⟩ + have HP' : P (2 + b * 2 + ((d - b) * 2 + e)) := P_eq HP + have hstep := gap_cleanup_section b a (d - b) e (flip_front b' cs) q (last_column b' cs) + (2 + m) t ((2 + d * 2 + e) + (1 + b + column_U ((a, b') :: cs)) * 4) + ((2 + d * 2 + e) * 2 + 3 - e + (1 + b + column_U ((a, b') :: cs))) xs + HP' (Bounded_forget _ _ _ _ HQ) HL He (by dsimp [column_U]; omega) + (by dsimp [column_U]; omega) HC + refine section_step_eq hstep ?_ rfl + have hfl := flip_front_list b' cs [1 + (2 + m) * 2, t] + dsimp [column_list] + simp only [List.cons_append] at hfl ⊢ + rw [hfl] + list_nat_eq + +theorem Band_eq {p1 p2 n1 n2 : Nat} (H : Band p1 n1) (hp : p1 = p2 := by omega) (hn : n1 = n2 := + by omega) : + Band p2 n2 := by + subst hp; subst hn; exact H + +theorem Band_offset (p k : Nat) (HP : Chain p) : ∃ q, p ≤ q ∧ Band q (p + k) := by + induction k with + | zero => + have hg := next_p_grows p + exact ⟨p, by omega, HP, by omega, by omega⟩ + | succ k ih => + rcases ih with ⟨q, Hpq, HQ, Hlo, Hhi⟩ + by_cases hlt : p + (k + 1) < next_p q + · exact ⟨q, Hpq, HQ, by omega, hlt⟩ + · have hg1 := next_p_grows q + have hg2 := next_p_grows (next_p q) + exact ⟨next_p q, by omega, Chain.ChainS q HQ, by omega, by omega⟩ + +theorem Band_above (p n : Nat) (HP : Chain p) (Hn : p ≤ n) : ∃ q, p ≤ q ∧ Band q n := by + rcases Band_offset p (n - p) HP with ⟨q, HQ, HB⟩ + exact ⟨q, HQ, Band_eq HB⟩ + +inductive CoreEntry : List Nat → Prop where + | Entry_unary (n : Nat) : CoreEntry [n] + | Entry_small (p n b t : Nat) : + Band p n → 2 ≤ b → b % 2 = 0 → 1 ≤ t → t % 2 = 1 → b ≤ p → b + t ≤ n * 8 → + CoreEntry [n, b, t] + +theorem next_p_parity (p e : Nat) (He : e ≤ 1) (HP : p % 2 = e) : next_p p = p * 2 + 3 - e := by + dsimp [next_p]; omega + +theorem Stair_parity (p e : Nat) (xs : List Nat) (He : e ≤ 1) (H : Stair p e xs) : p % 2 = e := by + cases H <;> omega + +theorem core_even_exit (p e f r : Nat) (HP : Chain p) (He : e ≤ 1) (Hpar : p % 2 = e) (Hf : 1 ≤ f) + (Hr : r ≤ p - 1 - e) : + ∃ xs, CleanLast (p + f * 4) (next_p p + f) (r * 2) xs ∧ CoreEntry xs := by + rcases Chain_spec p HP with ⟨Hp, _⟩ + have Hnext := next_p_parity p e He Hpar + rcases r with _ | r + · exact ⟨_, CleanLast.Clean0, CoreEntry.Entry_unary _⟩ + · refine ⟨[next_p p + f, 2 + r * 2, 3 + (p + f * 4 - r) * 2], ?_, ?_⟩ + · exact CleanLast_eq (@CleanLast.CleanEven (p + f * 4) (next_p p + f) r (by omega)) + · rcases Band_above (next_p p) (next_p p + f) (Chain.ChainS p HP) (by omega) with ⟨q, Hq, HB⟩ + exact CoreEntry.Entry_small q (next_p p + f) (2 + r * 2) (3 + (p + f * 4 - r) * 2) HB + (by omega) (by omega) (by omega) (by omega) (by omega) (by omega) + +theorem Stair_progress (p e : Nat) (xs : List Nat) (HChain : Chain p) (He : e ≤ 1) + (HStair : Stair p e xs) : + ∃ ys, ((section_481 xs) [target_tm]⊢⁺ (section_481 ys)) ∧ (Stair p e ys ∨ CoreEntry ys) := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + have Hpar := Stair_parity p e xs He HStair + have Hnext := next_p_parity p e He Hpar + rcases HStair with ⟨d, b, cs, m, s, rfl, HR, HS⟩ | ⟨g, b, d, cs, m, s, rfl, HR, HS⟩ + · by_cases Hs : s ≤ m + · refine ⟨(4 + d * 2 + b * 2 + e) :: column_list cs ++ [2 + s * 2, 5 + (m - s) * 2], ?_, + Or.inl ?_⟩ + · exact good_normal_section d b e cs m s HP (Bounded_forget _ _ _ _ HR) Hs He + · exact stair_good_normal d b e cs m s He HR HS Hs + · rcases core_even_exit (2 + d * 2 + e) e (1 + b + column_U cs) (s - m - 1) HChain He Hpar + (by omega) (by omega) with ⟨ys, HC, HY⟩ + refine ⟨ys, ?_, Or.inr HY⟩ + refine progress_trans (good_overflow_section d b e cs m (s - m - 1) + HP (Bounded_forget _ _ _ _ HR) He |> fun h => section_step_eq h) ?_ + rw [Hnext] at HC + exact clean_after_good d b e cs m ((s - m - 1) * 2) ys HP He HR HC + · by_cases Hs : s ≤ m + · refine ⟨(2 + g * 2 + (d * 2 + e)) :: (2 + g * 2) :: (2 + b * 2) :: column_list cs ++ + [2 + s * 2, 5 + (m - s) * 2], ?_, Or.inl ?_⟩ + · exact gap_normal_section g b d e cs m s HP (Bounded_forget _ _ _ _ HR) Hs He + · exact stair_gap_normal g b d e cs m s He HR HS Hs + · rcases core_even_exit (2 + g * 2 + (d * 2 + e)) e (1 + b + column_U cs) (s - m - 1) + HChain He Hpar (by omega) (by omega) with ⟨ys, HC, HY⟩ + refine ⟨ys, ?_, Or.inr HY⟩ + refine progress_trans (gap_overflow_section g b d e cs m (s - m - 1) + HP (Bounded_forget _ _ _ _ HR) He |> fun h => section_step_eq h) ?_ + rw [Hnext] at HC + exact clean_after_gap g b d e cs m ((s - m - 1) * 2) ys HP He HR HC + +theorem good_relation (p b t : Nat) (xs : List Nat) (HP : P p) (H : 0 < p + b) (HL : Last t (p + b) + xs) : + (section_481 [p, b, t]) [target_tm]⊢⁺ (section_481 xs) := by + rw [Last_output t (p + b) xs HL] + exact good_section_formula p b t HP H + +theorem odd_gap_odd_progress (g j t d : Nat) (HP : P (1 + g * 2 + d)) : + (section_481 [(1 + g * 2 + d) + (1 + g * 2), 1 + j * 2, t]) [target_tm]⊢⁺ + (section_481 [1 + g * 2 + d, 2 + (j + g) * 2, 2 + t + d + d % 2]) := + evstep_progress_trans (odd_gap_seed g j t d HP) (evstep_progress (seed_section t (j + g) g d) + (by ne_cfg)) + +theorem odd_gap_even_progress (g j v d : Nat) (HP : P (1 + g * 2 + d)) : + (section_481 [(1 + g * 2 + d) + (1 + g * 2), j * 2, 1 + v * 2]) [target_tm]⊢⁺ + (section_481 (S_odd_output (j + g) (g * 2) v d)) := by + refine evstep_progress_trans (odd_gap_S g j (1 + v * 2) d HP) ?_ + exact step_end_plus_eq (S_odd_progress (j + g) (g * 2) v d) (by cfg_eq) rfl + +theorem odd_last_odd_progress (g j t : Nat) (HP : P (2 + g * 2)) : + (section_481 [(2 + g * 2) + (3 + g * 2), 1 + j * 2, t]) [target_tm]⊢⁺ + (section_481 [2 + g * 2, 4 + (j + g) * 2, 2 + t]) := by + refine evstep_progress_trans ?_ (evstep_progress (step_end (bare_root t (1 + j + g) (1 + g * 2)) + (by cfg_eq) (by cfg_eq)) (by ne_cfg)) + refine step_bridge (return_last ((([1, 1, 0] : zF) ^ (1 + j * 2)) +> ((([1, 0] : zF) ^ t) + +> default)) g HP) (by cfg_eq) ?_ + refine step_bridge (odd_block ((([1, 0] : zF) ^ t) +> default) ((([0, 1, 1, 0, 1, 0] : zF) + ^ (2 + g)) +> ((([1, 0] : zF) ^ (1 + g * 2)) +> default)) j) (by cfg_eq) ?_ + exact step_end (sr_2 t default (([1, 0, 1, 0] : zF) +> ((([0, 1, 1, 0, 1, 0] : zF) ^ (2 + j + g)) + +> ((([1, 0] : zF) ^ (1 + g * 2)) +> default)))) (by cfg_eq) (by cfg_eq) + +def odd_output (p e k b t : Nat) : List Nat := + if t < p + 2 + e - k then [p, b + k + t, p + 2 + e - k - t] + else [p, p + b + 2 + e, t - (p + 2 + e - k)] + +theorem odd_odd_section (p e k b t : Nat) + (HP : P p) (Hp : 3 ≤ p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) + (Hk : k % 2 = 1) (Hkp : k ≤ p + e) (Hb : b % 2 = 1) : + (section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 [p, b + k, t + p + 2 + e - k]) := by + rcases parity k with ⟨g, rfl | rfl⟩ <;> try omega + rcases parity b with ⟨j, rfl | rfl⟩ <;> try omega + by_cases Hle : 1 + g * 2 ≤ p + · have HD : (p - (1 + g * 2)) % 2 = e := by omega + exact section_step_eq (odd_gap_odd_progress g j t (p - (1 + g * 2)) (P_eq HP)) + · rcases g with _ | g + · omega + · exact section_step_eq (odd_last_odd_progress g j t (P_eq HP)) + +theorem odd_even_section (p e k b t : Nat) + (HP : P p) (Hp : 3 ≤ p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) + (Hk : k % 2 = 1) (Hkp : k ≤ p + e) (Hb : b % 2 = 0) (Ht : t % 2 = 1) : + (section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 (odd_output p e k b t)) := by + rcases parity k with ⟨g, rfl | rfl⟩ <;> try omega + rcases parity b with ⟨j, rfl | rfl⟩ <;> try omega + rcases parity t with ⟨v, rfl | rfl⟩ <;> try omega + by_cases Hle : 1 + g * 2 ≤ p + · have HD : (p - (1 + g * 2)) % 2 = e := by omega + refine section_step_eq (odd_gap_even_progress g j v (p - (1 + g * 2)) (P_eq HP)) + (by list_nat_eq) ?_ + dsimp [odd_output, S_odd_output] + by_cases hlt : 1 + v * 2 < p - (1 + g * 2) + 2 + (p - (1 + g * 2)) % 2 + · rw [ite_eq_left hlt, ite_eq_left (by omega)]; list_nat_eq + · rw [ite_eq_right hlt, ite_eq_right (by omega)]; list_nat_eq + · rcases g with _ | g + · omega + · refine section_step_eq (odd_last_even_formula g j v (P_eq HP)) (by list_nat_eq) ?_ + dsimp [odd_output, S_odd_output] + by_cases hlt : 1 + v * 2 < 0 + 2 + 0 % 2 + · rw [ite_eq_left hlt, ite_eq_left (by omega)]; list_nat_eq + · rw [ite_eq_right hlt, ite_eq_right (by omega)]; list_nat_eq + +theorem predecessor_P (p : Nat) (H : Chain p) : PP (next_p p - 1) := by + rcases Chain_spec p H with ⟨Hp, HP, _⟩ + rcases parity p with ⟨a, rfl | rfl⟩ <;> dsimp [next_p] + · rcases a with _ | a + · omega + · exact PP_eq (pred_even a (P_eq HP)) + · exact PP_eq (pred_odd a HP) + +theorem predecessor_section (p b t : Nat) (HP : Chain p) (Hb : 2 ≤ b) (Hbp : b % 2 = 0) + (Htp : t % 2 = 1) : + (section_481 [next_p p - 1, b, t]) [target_tm]⊢⁺ (section_481 (pred_output (next_p p - 1) + b t)) := by + rcases parity b with ⟨a, rfl | rfl⟩ <;> try omega + rcases parity t with ⟨v, rfl | rfl⟩ <;> try omega + rcases a with _ | a + · omega + · have heq : (a + 1) * 2 = 2 + a * 2 := by omega + rw [heq] + exact pred_section (next_p p - 1) a v (predecessor_P p HP) + +theorem even_odd_section (p e k b t : Nat) (xs : List Nat) + (HP : P p) (He : e ≤ 1) (Hpar : p % 2 = e) (Hk : 2 ≤ k) (Hkp : k ≤ p) (Hke : k % 2 = 0) + (Hb : b % 2 = 1) + (HC : CleanLast ((p + k * 3 + b + e - 2) / 2) (p + b - k / 2) t xs) : + (section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 xs) := by + rcases parity k with ⟨g, rfl | rfl⟩ <;> try omega + rcases parity b with ⟨j, rfl | rfl⟩ <;> try omega + rcases g with _ | g + · omega + · have Hd : p = 2 + g * 2 + (((p - 2 - g * 2 - e) / 2) * 2 + e) := by omega + exact section_step_eq (cleanup_odd_triple_section g j ((p - 2 - g * 2 - e) / 2) e t xs (P_eq HP) + He (CleanLast_eq HC)) + +theorem even_normal_stair (g b d e s : Nat) + (HP : P (2 + g * 2 + (d * 2 + e))) (He : e ≤ 1) (Hb : b ≤ 1 + g * 2 + d) (Hs : s ≤ b + d) : + ∃ ys, ((section_481 [(2 + g * 2 + (d * 2 + e)) + (2 + g * 2), 2 + b * 2, 3 + s * 2]) + [target_tm]⊢⁺ (section_481 ys)) ∧ + Stair (2 + g * 2 + (d * 2 + e)) e ys := by + refine ⟨[2 + g * 2 + (d * 2 + e), 2 + g * 2, 2 + b * 2, 2 + s * 2, 5 + (b + d - s) * 2], ?_, ?_⟩ + · exact section_step_eq (gap_normal_section g b d e [] (b + d) s HP (ColumnRun.Columns_nil _) + Hs He) + · refine Stair_eq (@Stair.Stair_good (2 + g * 2 + (d * 2 + e)) e (g + d) g [(b, s)] + (1 + g * 2 + d - b + s) (1 + b + d - s) (by omega) ?_ (by omega)) + exact BoundedRun.Bounded_cons _ b s [] _ (by omega) (by omega) + (Bounded_eq (@BoundedRun.Bounded_nil (2 + g * 2 + (d * 2 + e) - 1 - e) + (1 + g * 2 + d - b + s) (by omega))) + +theorem even_overflow_clean (g b d e r : Nat) (xs : List Nat) + (HP : P (2 + g * 2 + (d * 2 + e))) (He : e ≤ 1) (Hb : b ≤ 1 + g * 2 + d) + (HC : CleanLast ((2 + g * 2 + (d * 2 + e)) + (1 + b) * 4) + ((2 + g * 2 + (d * 2 + e)) * 2 + 3 - e + (1 + b)) (r * 2) xs) : + (section_481 [(2 + g * 2 + (d * 2 + e)) + (2 + g * 2), 2 + b * 2, 5 + (b + d) * 2 + r * 2]) + [target_tm]⊢⁺ + (section_481 xs) := by + refine progress_trans (section_step_eq (gap_overflow_section g b d e [] (b + d) + r HP (ColumnRun.Columns_nil _) He)) ?_ + have HR : BoundedRun (2 + g * 2 + (d * 2 + e) - 1 - e) (b + d) [] (b + d) := + BoundedRun.Bounded_nil _ (by omega) + exact section_step_eq (clean_after_gap g b d e [] (b + d) (r * 2) xs HP He HR (CleanLast_eq HC + (by dsimp [column_U]) (by dsimp [column_U]) rfl rfl)) + +theorem even_parameters (p e k b : Nat) + (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 2 ≤ k) (Hkp : k ≤ p) (Hke : k % 2 = 0) (Hb : 2 ≤ b) + (Hbe : b % 2 = 0) : + ∃ g j d, k = 2 + g * 2 ∧ b = 2 + j * 2 ∧ p = 2 + g * 2 + (d * 2 + (1 - e)) := + ⟨(k - 2) / 2, (b - 2) / 2, (p - k - (1 - e)) / 2, by omega, by omega, by omega⟩ + +theorem even_normal_section (p e k b t : Nat) + (HP : P p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 2 ≤ k) (Hkp : k ≤ p) (Hke : k % 2 = 0) + (Hb : 2 ≤ b) (Hbe : b % 2 = 0) (Ht : 3 ≤ t) (Hte : t % 2 = 1) + (Hbn : b ≤ p + k) (Hcap : t + k ≤ p + b + e) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Stair p (1 - e) ys := by + rcases even_parameters p e k b He Hpar Hk Hkp Hke Hb Hbe with ⟨g, j, d, rfl, rfl, rfl⟩ + have Et : t = 3 + ((t - 3) / 2) * 2 := by omega + rw [Et] + exact even_normal_stair g j d (1 - e) ((t - 3) / 2) HP (by omega) (by omega) (by omega) + +theorem even_overflow_section (p e k b t : Nat) (xs : List Nat) + (HP : P p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 2 ≤ k) (Hkp : k ≤ p) (Hke : k % 2 = 0) + (Hb : 2 ≤ b) (Hbe : b % 2 = 0) (Hte : t % 2 = 1) (Hbn : b ≤ p + k) (Hcap : p + b + e < t + k) + (HC : CleanLast (p + b * 2) (next_p p + b / 2) (t + k - (p + b + 2 + e)) xs) : + (section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 xs) := by + rcases even_parameters p e k b He Hpar Hk Hkp Hke Hb Hbe with ⟨g, j, d, rfl, rfl, rfl⟩ + have Hr : t = 5 + (j + d) * 2 + ((t - (5 + (j + d) * 2)) / 2) * 2 := by omega + refine section_step_eq (even_overflow_clean g j d (1 - e) ((t - (5 + (j + d) * 2)) / 2) xs HP + (by omega) (by omega) ?_) + exact CleanLast_eq HC (by omega) (by dsimp [next_p]; omega) (by omega) rfl + +theorem even_short_section (p e k b : Nat) + (HP : P p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 2 ≤ k) (Hkp : k ≤ p) (Hke : k % 2 = 0) + (Hb : b % 2 = 0) : + (section_481 [p + k, b, 1]) [target_tm]⊢⁺ (section_481 [p, k, p + b * 2 + 4 + e - k]) := by + rcases parity k with ⟨g, rfl | rfl⟩ <;> try omega + rcases parity b with ⟨j, rfl | rfl⟩ <;> try omega + rcases g with _ | g + · omega + · exact section_step_eq (short_section g j (p - (2 + g * 2)) (P_eq HP)) + +def Diagonal (n b t : Nat) : Prop := + 2 ≤ b ∧ b % 2 = 0 ∧ 1 ≤ t ∧ t % 2 = 1 ∧ + (b + t = n + 2 + (1 - n % 2) ∨ (5 ≤ t ∧ b + t = n + 4 + (1 - n % 2))) + +inductive Core : List Nat → Prop where + | Core_entry (xs : List Nat) : CoreEntry xs → Core xs + | Core_diagonal (n b t : Nat) : 3 ≤ n → Diagonal n b t → Core [n, b, t] + +theorem Last_core (t m : Nat) (xs : List Nat) (Hm : 3 ≤ m) (Ht : t ≤ m + 1 + (1 - m % 2)) + (HL : Last t m xs) : + Core xs := by + rw [Last_output t m xs HL] + dsimp only [last_output] + split_ifs with h1 h2 + · exact Core.Core_entry _ (CoreEntry.Entry_unary _) + · refine Core.Core_diagonal m (t - t % 2) (m + 2 + t % 2 * 3 + (1 - m % 2) - t) Hm + ⟨by omega, by omega, by omega, by omega, ?_⟩ + by_cases hr : t % 2 = 0 + · exact Or.inl (by omega) + · exact Or.inr ⟨by omega, by omega⟩ + · omega + +theorem unary_core_progress (n : Nat) : + ∃ ys, ((section_481 [n]) [target_tm]⊢⁺ (section_481 ys)) ∧ Core ys := by + by_cases Hn : n < 3 + · rcases n with _ | _ | _ | n + · exact ⟨[3], unary_zero, Core.Core_entry _ (CoreEntry.Entry_unary _)⟩ + · exact ⟨[5], unary_one, Core.Core_entry _ (CoreEntry.Entry_unary _)⟩ + · exact ⟨[9], unary_two, Core.Core_entry _ (CoreEntry.Entry_unary _)⟩ + · omega + · rcases Band_total n (by omega) with ⟨p, HP, Hlo, Hhi⟩ + rcases Chain_spec p HP with ⟨Hp, HP', _⟩ + rcases Last_total (n - p) p (by omega) with ⟨ys, HL⟩ + refine ⟨ys, ?_, Last_core (n - p) p ys (by omega) (by dsimp [next_p] at Hhi; omega) HL⟩ + rw [Last_output (n - p) p ys HL] + exact section_step_eq (unary_progress p (n - p) HP' (by omega)) + +theorem good_core_or_overflow (p b t : Nat) (HChain : Chain p) (Hb : 1 ≤ b) : + ∃ ys, ((section_481 [p, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ + (Core ys ∨ ∃ u, ys = [p + b, p + b + 2 + (1 - (p + b) % 2), u] ∧ + t = p + b + 2 + (1 - (p + b) % 2) + u) := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + rcases Last_total t (p + b) (by omega) with ⟨ys, HL⟩ + refine ⟨ys, ?_, ?_⟩ + · rw [Last_output t (p + b) ys HL] + exact good_section_formula p b t HP (by omega) + · by_cases Ht : t ≤ p + b + 1 + (1 - (p + b) % 2) + · exact Or.inl (Last_core t (p + b) ys (by omega) Ht HL) + · refine Or.inr ⟨t - (p + b + 2 + (1 - (p + b) % 2)), ?_, by omega⟩ + rw [Last_output t (p + b) ys HL] + dsimp only [last_output] + rw [ite_eq_right (by omega), ite_eq_right (by omega)] + +theorem good_bounded_core (p b t : Nat) (HChain : Chain p) (Ht : t ≤ p + b + 1 + (1 - (p + b) + % 2)) : + ∃ ys, ((section_481 [p, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Core ys := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + rcases Last_total t (p + b) (by omega) with ⟨ys, HL⟩ + exact ⟨ys, good_relation p b t ys HP (by omega) HL, Last_core t (p + b) ys (by omega) Ht HL⟩ + +theorem odd_even_core (p e k b t : Nat) + (HChain : Chain p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : k % 2 = 1) (Hkp : k ≤ p + e) + (Hb : 2 ≤ b) (Hbe : b % 2 = 0) (Hte : t % 2 = 1) (Hcap : t + k ≤ p + b + e) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Core ys := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + have Hstep := odd_even_section p e k b t HP Hp He Hpar Hk Hkp Hbe Hte + dsimp [odd_output] at Hstep + by_cases E : t < p + 2 + e - k + · rw [ite_eq_left E] at Hstep + rcases good_bounded_core p (b + k + t) (p + 2 + e - k - t) HChain (by omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, progress_trans Hstep HT, HY⟩ + · rw [ite_eq_right E] at Hstep + rcases good_bounded_core p (p + b + 2 + e) (t - (p + 2 + e - k)) HChain (by omega) with ⟨ys, HT, + HY⟩ + exact ⟨ys, progress_trans Hstep HT, HY⟩ + +theorem even_short_core (p e k b : Nat) + (HChain : Chain p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 2 ≤ k) (Hkp : k ≤ p) + (Hke : k % 2 = 0) + (Hbe : b % 2 = 0) (Hb : b < k) : + ∃ ys, ((section_481 [p + k, b, 1]) [target_tm]⊢⁺ (section_481 ys)) ∧ Core ys := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + rcases good_bounded_core p k (p + b * 2 + 4 + e - k) HChain (by omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, progress_trans (even_short_section p e k b HP He Hpar Hk Hkp Hke Hbe) HT, HY⟩ + +theorem odd_recovery_core (p e k b t : Nat) + (HChain : Chain p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 1 ≤ k) (Hkp : k * 4 ≤ p) + (Hke : k % 2 = 1) + (Hbe : b % 2 = 1) (Ht : 1 ≤ t) (Hte : t % 2 = 1) (Hb : p + k * 8 + 2 + e ≤ b) + (Hsum : b + t + 4 ≤ p * 3) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Core ys := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + have Hfirst := odd_odd_section p e k b t HP Hp He Hpar Hke (by omega) Hbe + rcases good_core_or_overflow p (b + k) (t + p + 2 + e - k) HChain (by omega) with ⟨zs, Hsecond, + HZ | ⟨u, rfl, HU⟩⟩ + · exact ⟨zs, progress_trans Hfirst Hsecond, HZ⟩ + · let P_val := next_p p + have HC : Chain P_val := Chain.ChainS p HChain + have EP : P_val = p * 2 + 2 + e := by dsimp [P_val, next_p]; omega + have HPpar : P_val % 2 + (1 - e) = 1 := by omega + rcases Chain_spec P_val HC with ⟨HPlo, HPP, _⟩ + let j := p + (b + k) - P_val + have Hje : j % 2 = 1 := by dsimp [j]; omega + have Hj : j ≤ P_val + (1 - e) := by dsimp [j]; omega + have ET : (section_481 [p + (b + k), p + (b + k) + 2 + (1 - (p + (b + k)) % 2), u]) + [target_tm]⊢⁺ + (section_481 [P_val, p + (b + k) + 2 + e + j, u + P_val + 2 + (1 - e) - j]) := + section_step_eq (odd_odd_section P_val (1 - e) j (p + (b + k) + 2 + e) u HPP HPlo (by omega) + HPpar Hje Hj (by omega)) + (by dsimp [j]; list_nat_eq) rfl + rcases good_bounded_core P_val (p + (b + k) + 2 + e + j) (u + P_val + 2 + (1 - e) - j) HC + (by dsimp [j]; omega) with ⟨ys, Hlast, HY⟩ + exact ⟨ys, progress_trans Hfirst (progress_trans Hsecond (progress_trans ET Hlast)), HY⟩ + +theorem even_recovery_core (p e k b t : Nat) + (HChain : Chain p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 1 ≤ k) (Hkp : k * 4 ≤ p) + (Hke : k % 2 = 0) + (Hbe : b % 2 = 1) (Ht : 1 ≤ t) (Hte : t % 2 = 1) (Hb : p + k * 8 + 2 + e ≤ b) + (Hsum : b + t + 4 ≤ p * 3) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Core ys := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + let N := (p + k * 3 + b + (1 - e) - 2) / 2 + let X := p + b - k / 2 + let P_val := next_p p + have HN : N * 2 + 5 = p + k * 3 + b + 3 - e := by dsimp [N]; omega + have EP : P_val = p * 2 + 2 + e := by dsimp [P_val, next_p]; omega + have EX : Band P_val X := ⟨Chain.ChainS p HChain, by dsimp [X, P_val, next_p]; omega, + by dsimp [X, P_val, next_p]; omega⟩ + rcases CleanLast_total N X t with ⟨ys, HC⟩ + refine ⟨ys, even_odd_section p (1 - e) k b t ys HP (by omega) (by omega) (by omega) (by omega) + Hke Hbe HC, ?_⟩ + cases HC with + | Clean0 => exact Core.Core_entry _ (CoreEntry.Entry_unary _) + | Clean1 => exact Core.Core_entry _ (CoreEntry.Entry_unary _) + | CleanEven s Hs => omega + | CleanOdd s Hs => + exact Core.Core_entry _ (CoreEntry.Entry_small P_val X (2 + s * 2) (5 + (N - s) * 2) EX + (by omega) (by omega) (by omega) (by omega) (by omega) (by dsimp [X]; omega)) + | CleanBorder => omega + | CleanOver a => omega + +theorem recovery_core (p k b t : Nat) + (HChain : Chain p) (Hk : 1 ≤ k) (Hkp : k * 4 ≤ p) (Hbe : b % 2 = 1) (Ht : 1 ≤ t) + (Hte : t % 2 = 1) + (Hb : p + k * 8 + 2 + (1 - p % 2) ≤ b) (Hsum : b + t + 4 ≤ p * 3) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Core ys := by + rcases parity k with ⟨a, rfl | rfl⟩ + · exact even_recovery_core p (1 - p % 2) (a * 2) b t HChain (by omega) (by omega) Hk Hkp + (by omega) Hbe Ht Hte Hb Hsum + · exact odd_recovery_core p (1 - p % 2) (1 + a * 2) b t HChain (by omega) (by omega) Hk Hkp + (by omega) Hbe Ht Hte Hb Hsum + +theorem negative_positive_small (a n e d b t u : Nat) + (HP : P (3 + a * 2 - e)) (He : e ≤ 1) (Hn : n ≤ a) (Hd : d ≤ a + n + 3) + (Hu : b + n * 4 + 2 = d * 2 + e + u) (Ht : t + b * 2 = 13 + a * 4 + d * 2) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (3 + a * 2 - e) + n d e) [target_tm]⊢* + (section_481 [9 + a * 4 + n - e, 14 + a * 4 + d * 4, 1 + u * 2]) := by + rcases u with _ | u + · rcases e with _ | _ | e + · exact step_end (negativeN_one_odd a n d b (a + n + 3 - d) (a - n) t (P_eq HP) (by omega) + (by omega) (by omega) (by omega)) (by cfg_eq) (by cfg_eq) + · exact step_end (negativeN_one_even a n d b (a + n + 3 - d) (a - n) t (P_eq HP) (by omega) + (by omega) (by omega) (by omega)) (by cfg_eq) (by cfg_eq) + · omega + · by_cases Hcross : u + e + n ≤ a + · rcases e with _ | _ | e + · exact step_end (negativeN_positive_odd a n d b (a + n + 3 - d) u (a - n - u) t (P_eq HP) + (by omega) (by omega) (by omega) (by omega)) (by cfg_eq) (by cfg_eq) + · exact step_end (negativeN_positive_even a n d b (a + n + 3 - d) u (a - 1 - n - u) + t (P_eq HP) (by omega) (by omega) (by omega) (by omega)) (by cfg_eq) (by cfg_eq) + · omega + · rcases e with _ | _ | e + · exact step_end (negativeN_root_odd a n d b (a + n + 3 - d) (a - n) ((t - 1) / 2) + (u - (a - n) - 1) (P_eq HP) (by omega) (by omega) (by omega) (by omega)) (by cfg_eq) + (by cfg_eq) + · exact step_end (negativeN_root_even a n d b (a + n + 3 - d) (a - n) ((t - 1) / 2) + (u - (a - n)) (P_eq HP) (by omega) (by omega) (by omega) (by omega)) (by cfg_eq) + (by cfg_eq) + · omega + +theorem negative_negative_small (a n e d b t u : Nat) + (HP : P (3 + a * 2 - e)) (He : e ≤ 1) (Hn : n ≤ a) (Hd : d ≤ a + n + 3) + (Hu : d * 2 + e = b + n * 4 + 3 + u) (Ht : t + b * 2 = 13 + a * 4 + d * 2) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (3 + a * 2 - e) + n d e) [target_tm]⊢* + (section_481 [9 + a * 4 + n - e, 19 + a * 4 + n * 8 + b * 2 - e * 2, 1 + u * 2]) := by + rcases e with _ | _ | e + · exact step_end (negativeN_bounded_odd a n d b (a + n + 3 - d) (a - n) u t (P_eq HP) (by omega) + (by omega) (by omega) (by omega)) (by cfg_eq) (by cfg_eq) + · exact step_end (negativeN_bounded_even a n d b (a + n + 3 - d) (a - n) u t (P_eq HP) (by omega) + (by omega) (by omega) (by omega)) (by cfg_eq) (by cfg_eq) + · omega + +theorem negative_positive_large (a n e k b t u : Nat) + (HP : P (3 + a * 2 - e)) (He : e ≤ 1) (Hn : n ≤ a) (Hk : k ≤ 5 + n * 3 + a - e) + (Hu : b + n * 4 + 2 = (a + n + 3 + k) * 2 + e + u) + (Ht : t + b * 2 = 13 + a * 4 + (a + n + 3 + k) * 2) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (3 + a * 2 - e) + n (a + n + 3 + k) e) [target_tm]⊢* + (section_481 [9 + a * 4 + n - e, 14 + a * 4 + (a + n + 3 + k) * 4, 1 + u * 2]) := by + rcases u with _ | u + · exact step_end (negativeN_large_short (3 + a * 2 - e) n e (a + n + 3) k + (3 + a * 2 - e - (2 + n * 2)) (1 + a - n - e) (5 + n * 3 + a - e) b ((t - 1) / 2) + HP (by omega) (by omega) (by omega) He (by omega) (by omega) (by omega)) (by cfg_eq) + (by cfg_eq) + · exact step_end (negativeN_large_root (3 + a * 2 - e) n e (a + n + 3) k + (3 + a * 2 - e - (2 + n * 2)) (1 + a - n - e) (5 + n * 3 + a - e) b ((t - 1) / 2) u + HP (by omega) (by omega) (by omega) He (by omega) (by omega) (by omega)) (by cfg_eq) + (by cfg_eq) + +theorem negative_negative_large (a n e k b t u : Nat) + (HP : P (3 + a * 2 - e)) (He : e ≤ 1) (Hn : n ≤ a) (Hk : k ≤ 5 + n * 3 + a - e) + (Hu : (a + n + 3 + k) * 2 + e = b + n * 4 + 3 + u) + (Ht : t + b * 2 = 13 + a * 4 + (a + n + 3 + k) * 2) : + (negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (3 + a * 2 - e) + n (a + n + 3 + k) e) [target_tm]⊢* + (section_481 [9 + a * 4 + n - e, 19 + a * 4 + n * 8 + b * 2 - e * 2, 1 + u * 2]) := by + exact step_end (negativeN_large_late (3 + a * 2 - e) n e (a + n + 3) k + (3 + a * 2 - e - (2 + n * 2)) (1 + a - n - e) (5 + n * 3 + a - e) b ((5 + n * 3 + a - e) - k) u + HP (by omega) (by omega) (by omega) He (by omega) (by omega) (by omega)) (by cfg_eq) (by cfg_eq) + +theorem lone_positive (a n e b t : Nat) + (HP : P (3 + a * 2 - e)) (He : e ≤ 1) (Hn : n ≤ a) (Ht : 3 ≤ t) (HE : t + b * 2 = 11 + a * 4) : + (loneN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) +> default)) (3 + a * 2 - e) n e) + [target_tm]⊢* + (section_481 [9 + a * 4 + n - e, 10 + a * 4, 9 + n * 8 + b * 2 - e * 2]) := by + by_cases Hcross : 3 + n * 5 + b ≤ a + · rcases e with _ | _ | e + · exact step_end (loneN_odd a n b (a - 3 - n * 5 - b) t (P_eq HP) (by omega) (by omega)) + (by cfg_eq) (by cfg_eq) + · exact step_end (loneN_even a n b (a - 3 - n * 5 - b) t (P_eq HP) (by omega) (by omega)) + (by cfg_eq) (by cfg_eq) + · omega + · rcases e with _ | _ | e + · exact step_end (loneN_root_odd a n b (a - n) ((t - 3) / 2) (n * 5 + b + 2 - a) (P_eq HP) + (by omega) (by omega) (by omega)) (by cfg_eq) (by cfg_eq) + · exact step_end (loneN_root_even a n b (a - n) ((t - 3) / 2) (n * 5 + b + 2 - a) (P_eq HP) + (by omega) (by omega) (by omega)) (by cfg_eq) (by cfg_eq) + · omega + +inductive Repair (p e A delta B : Nat) : List Nat → Prop where + | Repair_positive (x : Nat) : 1 ≤ x → x + delta * 2 = B + A * 4 + 3 → + Repair p e A delta B [next_p p + A / 2, p * 2 + delta * 2 + 2, x] + | Repair_negative (x : Nat) : 1 ≤ x → B + A * 4 + 3 + x = delta * 2 → + Repair p e A delta B [next_p p + A / 2, p * 2 + A * 4 + B + 5, x] + +theorem Repair_eq {p1 p2 e1 e2 A1 A2 d1 d2 B1 B2 : Nat} {xs1 xs2 : List Nat} + (H : Repair p1 e1 A1 d1 B1 xs1) + (hp : p1 = p2 := by omega) (he : e1 = e2 := by omega) (hA : A1 = A2 := by omega) + (hd : d1 = d2 := by omega) (hB : B1 = B2 := by omega) (hxs : xs1 = xs2 := by list_nat_eq) : + Repair p2 e2 A2 d2 B2 xs2 := by + subst hp; subst he; subst hA; subst hd; subst hB; subst hxs; exact H + +theorem wide_section (p e A delta B t : Nat) (xs : List Nat) + (HP : P p) (Hp : 3 ≤ p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) + (HA : 2 ≤ A) (HAp : A ≤ p) (HAe : A % 2 = 0) (HB : 2 ≤ B) (HBe : B % 2 = 0) + (HD : 1 + e ≤ delta) (HDe : (delta + e) % 2 = 1) (HDhi : delta < p * 2 + A * 4 + 7 + e) + (Hbal : t + B = p * 2 + 4 + e + delta) (Hlone : delta = 1 + e → 3 ≤ t) + (HR : Repair p e A delta B xs) : + (section_481 [p, A, p + A + delta, B, t]) [target_tm]⊢* (section_481 xs) := by + have hparams : ∃ a n b, p = 3 + a * 2 - e ∧ A = 2 + n * 2 ∧ B = b * 2 ∧ n ≤ a := + ⟨(p + e - 3) / 2, (A - 2) / 2, B / 2, by omega, by omega, by omega, by omega⟩ + rcases hparams with ⟨a, n, b, rfl, rfl, rfl, Hn⟩ + by_cases Hdelta : delta = 1 + e + · subst Hdelta + refine ReachesStar.trans (c₂ := loneN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) + +> default)) (3 + a * 2 - e) n e) ?_ ?_ + · rcases e with _ | _ | e + · exact step_end (loneN_first_odd ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) + +> default)) a n (P_eq HP)) (by cfg_eq) (by cfg_eq) + · exact step_end (loneN_first_even ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) + +> default)) a n (P_eq HP)) (by cfg_eq) (by cfg_eq) + · omega + · cases HR with + | Repair_positive x Hx Hex => + exact step_end (lone_positive a n e b t HP He Hn (Hlone rfl) (by omega)) rfl + (by dsimp [next_p]; cfg_eq) + | Repair_negative x Hx Hex => omega + · have hd_ex : ∃ d, delta = 3 + e + d * 2 := ⟨(delta - 3 - e) / 2, by omega⟩ + rcases hd_ex with ⟨d, rfl⟩ + refine ReachesStar.trans (c₂ := negativeN ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) + +> default)) (3 + a * 2 - e) n d e) ?_ ?_ + · rcases e with _ | _ | e + · exact step_end (negativeN_first_odd ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) + +> default)) a n d (P_eq HP)) (by cfg_eq) (by cfg_eq) + · exact step_end (negativeN_first_even ((([1, 1, 0] : zF) ^ (b * 2)) +> ((([1, 0] : zF) ^ t) + +> default)) a n d (P_eq HP)) (by cfg_eq) (by cfg_eq) + · omega + · cases HR with + | Repair_positive x Hx Hex => + by_cases Hsmall : d ≤ a + n + 3 + · exact step_end (negative_positive_small a n e d b t ((x - 1) / 2) HP He Hn Hsmall + (by omega) (by omega)) rfl (by dsimp [next_p]; cfg_eq) + · exact step_end (negative_positive_large a n e (d - (a + n + 3)) b t ((x - 1) / 2) HP He Hn + (by omega) (by omega) (by omega)) (by cfg_eq) (by dsimp [next_p]; cfg_eq) + | Repair_negative x Hx Hex => + by_cases Hsmall : d ≤ a + n + 3 + · exact step_end (negative_negative_small a n e d b t ((x - 1) / 2) HP He Hn Hsmall + (by omega) (by omega)) rfl (by dsimp [next_p]; cfg_eq) + · exact step_end (negative_negative_large a n e (d - (a + n + 3)) b t ((x - 1) / 2) HP He Hn + (by omega) (by omega) (by omega)) (by cfg_eq) (by dsimp [next_p]; cfg_eq) + +theorem Repair_total (p e A delta B : Nat) (HB : B % 2 = 0) : ∃ xs, Repair p e A delta B xs := by + by_cases hle : delta * 2 ≤ B + A * 4 + 3 + · exact ⟨_, Repair.Repair_positive (B + A * 4 + 3 - delta * 2) (by omega) (by omega)⟩ + · exact ⟨_, Repair.Repair_negative (delta * 2 - (B + A * 4 + 3)) (by omega) (by omega)⟩ + +theorem wide_triple (p e k b t : Nat) (xs : List Nat) + (HP : P p) (Hp : 3 ≤ p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 2 ≤ k) (Hkp : k ≤ p) + (Hke : k % 2 = 0) + (Hb : 2 ≤ b) (Hbe : b % 2 = 0) (Ht : 3 ≤ t) (Hte : t % 2 = 1) (Hbn : p + k < b) + (Hcap : t + k ≤ p + b + e) + (Hdelta : b - (p + k) < p * 2 + k * 4 + 7 + e) + (HR : Repair p e k (b - (p + k)) (t - 1) xs) : + (section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 xs) := by + rcases even_parameters p e k b He Hpar Hk Hkp Hke Hb Hbe with ⟨g, j, d, Ek, Eb, Ep⟩ + refine progress_evstep_trans (c₂ := section_481 [p, k, b, t - 1, p + b + 5 + e - k - t]) ?_ ?_ + · exact section_step_eq (gap_normal_section g j d (1 - e) [] (j + d) ((t - 3) / 2) (P_eq HP) + (ColumnRun.Columns_nil _) (by omega) (by omega)) + · exact section_evstep_eq (wide_section p e k (b - (p + k)) (t - 1) (p + b + 5 + e - k - t) xs + HP Hp He Hpar Hk Hkp Hke (by omega) (by omega) (by omega) (by omega) Hdelta (by omega) + (by omega) HR) + +theorem short_overflow_output (p e k b : Nat) + (_Hp : 3 ≤ p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (_Hk : 2 ≤ k) (Hkp : k ≤ p) (Hke : k % 2 = 0) + (Hb : k ≤ b) : + last_output (p + b * 2 + 4 + e - k) (p + k) = [p + k, p + k + 2 + e, (b - k) * 2 + 2] := by + dsimp [last_output] + rw [ite_eq_right (by omega), ite_eq_right (by omega)] + list_nat_eq + +theorem even_short_clean (p e k b : Nat) (xs : List Nat) + (HChain : Chain p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 2 ≤ k) (Hkp : k ≤ p) + (Hke : k % 2 = 0) + (Hb : b % 2 = 0) (Hbk : k ≤ b) + (HC : CleanLast (p + k * 2) (next_p p + k / 2) ((b - k) * 2 + 2) xs) : + (section_481 [p + k, b, 1]) [target_tm]⊢⁺ (section_481 xs) := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + refine progress_trans (even_short_section p e k b HP He Hpar Hk Hkp Hke Hb) ?_ + refine progress_trans (c₂ := section_481 [p + k, p + k + 2 + e, (b - k) * 2 + 2]) ?_ ?_ + · rw [← short_overflow_output p e k b Hp He Hpar Hk Hkp Hke Hbk] + exact good_section_formula p k (p + b * 2 + 4 + e - k) HP (by omega) + · exact even_odd_section p (1 - e) k (p + k + 2 + e) ((b - k) * 2 + 2) xs HP + (by omega) (by omega) Hk Hkp Hke (by omega) (CleanLast_eq HC (by omega) + (by dsimp [next_p]; omega) rfl rfl) + +theorem short_repair (p e k b : Nat) (xs : List Nat) + (HChain : Chain p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 2 ≤ k) (Hkp : k ≤ p) + (Hke : k % 2 = 0) + (Hb : b % 2 = 0) (Hbn : p + k < b) (HR : Repair p e k (b - (p + k)) 0 xs) : + (section_481 [p + k, b, 1]) [target_tm]⊢⁺ (section_481 xs) := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + refine even_short_clean p e k b xs HChain He Hpar Hk Hkp Hke Hb (by omega) ?_ + cases HR with + | Repair_positive x Hx HE => + by_cases Hx1 : x = 1 + · subst Hx1 + exact CleanLast_eq (@CleanLast.CleanBorder (p + k * 2) (p * 2 + 2 + (1 - p % 2) + k / 2)) + rfl (by dsimp [next_p]) (by omega) (by dsimp [next_p] ; list_nat_eq) + · exact CleanLast_eq (@CleanLast.CleanEven (p + k * 2) (p * 2 + 2 + (1 - p % 2) + k / 2) (b - k) + (by omega)) + rfl (by dsimp [next_p]) (by omega) (by dsimp [next_p] ; list_nat_eq) + | Repair_negative x Hx HE => + exact CleanLast_eq (@CleanLast.CleanOver (p + k * 2) (p * 2 + 2 + (1 - p % 2) + k / 2) x) + rfl (by dsimp [next_p]) (by omega) (by dsimp [next_p] ; list_nat_eq) + +theorem halving_step (p e k d t : Nat) (xs : List Nat) + (HChain : Chain p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 2 ≤ k) (Hkp : k * 4 ≤ p) + (Hke : k % 2 = 0) + (Hd : 1 ≤ d) (Hdp : d ≤ p * 2) (Hde : (p + d) % 2 = 0) (Ht : 1 ≤ t) (Hte : t % 2 = 1) + (Hcap : t ≤ p * 2 + d + e) + (HR : Repair p e k d (t - 1) xs) : + (section_481 [p + k, p + k + d, t]) [target_tm]⊢⁺ (section_481 xs) := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + by_cases Ht1 : t = 1 + · subst Ht1 + exact short_repair p e k (p + k + d) xs HChain He Hpar Hk (by omega) Hke (by omega) (by omega) + (Repair_eq HR) + · exact wide_triple p e k (p + k + d) t xs HP Hp He Hpar Hk (by omega) Hke (by omega) (by omega) + (by omega) Hte (by omega) (by omega) (by omega) (Repair_eq HR) + +inductive Safe : List Nat → Prop where + | Safe_core (xs : List Nat) : Core xs → Safe xs + | Safe_stair (p e : Nat) (xs : List Nat) : Chain p → e ≤ 1 → Stair p e xs → Safe xs + | Safe_half (p k d t : Nat) : + Chain p → 2 ≤ k → k * 4 ≤ p → k % 2 = 0 → + 1 ≤ d → d ≤ p * 2 → (p + d) % 2 = 0 → 1 ≤ t → t % 2 = 1 → + t ≤ p * 2 + d + (1 - p % 2) → Safe [p + k, p + k + d, t] + +theorem Safe_eq {xs1 xs2 : List Nat} (H : Safe xs1) (hxs : xs1 = xs2 := + by list_nat_eq) : Safe xs2 := by + subst hxs; exact H + +theorem near_core (p e k b t : Nat) + (HChain : Chain p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 1 ≤ k) (Hkp : k * 4 ≤ p) + (Hb : p < b) (Hbn : b ≤ p + k) (Hbe : b % 2 = 0) (Ht : 1 ≤ t) (Hte : t % 2 = 1) + (Hcap : t + k ≤ p + b + e) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Safe ys := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + by_cases Hko : k % 2 = 1 + · rcases odd_even_core p e k b t HChain He Hpar Hko (by omega) (by omega) Hbe Hte Hcap with ⟨ys, + HT, HY⟩ + exact ⟨ys, HT, Safe.Safe_core ys HY⟩ + · have Hk0 : k % 2 = 0 := by omega + by_cases Ht1 : t = 1 + · subst Ht1 + refine ⟨[next_p p + k / 2, (b - k) * 2 + 2, 3 + (p + k * 2 - (b - k)) * 2], ?_, ?_⟩ + · refine even_short_clean p e k b _ HChain He Hpar (by omega) (by omega) Hk0 Hbe (by omega) ?_ + exact CleanLast_eq (@CleanLast.CleanEven (p + k * 2) (next_p p + k / 2) (b - k) (by omega)) + · refine Safe.Safe_core _ (Core.Core_entry _ (CoreEntry.Entry_small (next_p p) + (next_p p + k / 2) + ((b - k) * 2 + 2) (3 + (p + k * 2 - (b - k)) * 2) ?_ + (by omega) (by omega) (by omega) (by omega) + (by dsimp [next_p]; omega) (by dsimp [next_p]; omega))) + exact ⟨Chain.ChainS p HChain, by dsimp [next_p]; omega, by dsimp [next_p]; omega⟩ + · rcases even_normal_section p e k b t HP He Hpar (by omega) (by omega) Hk0 (by omega) Hbe + (by omega) Hte Hbn Hcap with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Safe.Safe_stair p (1 - e) ys HChain (by omega) HY⟩ + +theorem halving_progress (p k d t : Nat) + (HChain : Chain p) (Hk : 2 ≤ k) (Hkp : k * 4 ≤ p) (Hke : k % 2 = 0) (Hd : 1 ≤ d) + (Hdp : d ≤ p * 2) + (Hde : (p + d) % 2 = 0) (Ht : 1 ≤ t) (Hte : t % 2 = 1) (Hcap : t ≤ p * 2 + d + (1 - p % 2)) : + ∃ ys, ((section_481 [p + k, p + k + d, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Safe ys := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + let e := 1 - p % 2 + have He : e ≤ 1 := by dsimp [e]; omega + have Hpar : p % 2 + e = 1 := by dsimp [e]; omega + rcases Repair_total p e k d (t - 1) (by omega) with ⟨xs, HR⟩ + have HT := halving_step p e k d t xs HChain He Hpar Hk Hkp Hke Hd Hdp Hde Ht Hte Hcap HR + let P_val := next_p p + let K := k / 2 + have EP : P_val = p * 2 + 2 + e := by dsimp [P_val, next_p, e] + have HPpar : P_val % 2 + (1 - e) = 1 := by omega + have HC : Chain P_val := Chain.ChainS p HChain + have HK : 1 ≤ K := by dsimp [K]; omega + have HKP : K * 4 ≤ P_val := by dsimp [K]; omega + have EK : k = K * 2 := by dsimp [K]; omega + cases HR with + | Repair_positive x Hx Hex => + let B := p * 2 + d * 2 + 2 + have HBe : B % 2 = 0 := by dsimp [B]; omega + have HX : x % 2 = 1 := by dsimp [B] at *; omega + have Hcap' : x + K ≤ P_val + B + (1 - e) := by dsimp [B] at *; omega + by_cases Hko : K % 2 = 1 + · rcases odd_even_core P_val (1 - e) K B x HC (by omega) HPpar Hko (by omega) + (by dsimp [B]; omega) HBe HX Hcap' with ⟨ys, HY, HZ⟩ + exact ⟨ys, progress_trans HT HY, Safe.Safe_core ys HZ⟩ + · have HK0 : K % 2 = 0 := by omega + by_cases Hnear : B ≤ P_val + K + · rcases near_core P_val (1 - e) K B x HC (by omega) HPpar HK HKP (by dsimp [B]; omega) + Hnear HBe Hx HX Hcap' with ⟨ys, HY, HZ⟩ + exact ⟨ys, progress_trans HT HY, HZ⟩ + · refine ⟨[P_val + K, B, x], HT, ?_⟩ + exact Safe_eq (Safe.Safe_half P_val K (B - (P_val + K)) x HC (by omega) HKP HK0 + (by omega) (by dsimp [B, P_val, next_p, e] at *; omega) + (by dsimp [B, P_val, next_p, e] at *; omega) Hx HX + (by dsimp [B, P_val, next_p, e] at *; omega)) + | Repair_negative x Hx Hex => + have HX : x % 2 = 1 := by omega + rcases recovery_core P_val K (p * 2 + k * 4 + (t - 1) + 5) x HC HK HKP + (by omega) Hx HX (by dsimp [P_val, next_p]; omega) (by omega) with ⟨ys, HY, HZ⟩ + exact ⟨ys, progress_trans HT HY, Safe.Safe_core ys HZ⟩ + +theorem clean_small_core (p X N t : Nat) + (HP : Chain p) (HX : p ≤ X) (Hte : t % 2 = 0) (Htp : t ≤ p) (Ht : t < N * 2 + 5) + (HN : N * 2 + 5 ≤ X * 8) : + ∃ xs, CleanLast N X t xs ∧ Core xs := by + rcases Band_above p X HP HX with ⟨q, Hq, HQ⟩ + rcases CleanLast_total N X t with ⟨xs, HC⟩ + refine ⟨xs, HC, ?_⟩ + cases HC with + | Clean0 => exact Core.Core_entry _ (CoreEntry.Entry_unary _) + | Clean1 => omega + | CleanEven s Hs => + exact Core.Core_entry _ (CoreEntry.Entry_small q X (2 + s * 2) (3 + (N - s) * 2) HQ + (by omega) (by omega) (by omega) (by omega) (by omega) (by omega)) + | CleanOdd s Hs => omega + | CleanBorder => + exact Core.Core_entry _ (CoreEntry.Entry_small q X (4 + N * 2) 1 HQ + (by omega) (by omega) (by omega) (by omega) (by omega) (by omega)) + | CleanOver a => omega + +theorem even_overflow_core (p e k b t : Nat) + (HChain : Chain p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 2 ≤ k) (Hkp : k ≤ p) + (Hke : k % 2 = 0) + (Hb : 2 ≤ b) (Hbe : b % 2 = 0) (Hte : t % 2 = 1) (Hbn : b ≤ p + k) (Hcap : p + b + e < t + k) + (Hmax : t + k ≤ p + b + 2 + e + next_p p) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Core ys := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + rcases clean_small_core (next_p p) (next_p p + b / 2) (p + b * 2) (t + k - (p + b + 2 + e)) + (Chain.ChainS p HChain) (by omega) (by omega) (by dsimp [next_p] at *; omega) + (by dsimp [next_p] at *; omega) (by dsimp [next_p] at *; omega) with ⟨ys, HC, HY⟩ + exact ⟨ys, even_overflow_section p e k b t ys HP He Hpar Hk Hkp Hke Hb Hbe Hte Hbn Hcap HC, HY⟩ + +theorem odd_even_bounded_core (p e k b t : Nat) + (HChain : Chain p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : k % 2 = 1) (Hkp : k ≤ p + e) + (Hb : 2 ≤ b) (Hbe : b % 2 = 0) (Hte : t % 2 = 1) (Hcap : t + k ≤ p * 3 + b + 6 + e) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Core ys := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + have Hstep := odd_even_section p e k b t HP Hp He Hpar Hk Hkp Hbe Hte + dsimp [odd_output] at Hstep + by_cases E : t < p + 2 + e - k + · rw [ite_eq_left E] at Hstep + rcases good_bounded_core p (b + k + t) (p + 2 + e - k - t) HChain (by omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, progress_trans Hstep HT, HY⟩ + · rw [ite_eq_right E] at Hstep + rcases good_bounded_core p (p + b + 2 + e) (t - (p + 2 + e - k)) HChain (by omega) with ⟨ys, HT, + HY⟩ + exact ⟨ys, progress_trans Hstep HT, HY⟩ + +theorem bounded_small_advance (p e k b t : Nat) + (HChain : Chain p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 1 ≤ k) (Hkp : k * 4 ≤ p) + (Hb : p < b) (Hbhi : b ≤ p + 3) + (Hbe : b % 2 = 0) (Ht : 1 ≤ t) (Hte : t % 2 = 1) (Hthi : t ≤ k * 8 + 1) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Safe ys := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + by_cases Hko : k % 2 = 1 + · rcases odd_even_bounded_core p e k b t HChain He Hpar Hko (by omega) (by omega) Hbe Hte + (by omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Safe.Safe_core ys HY⟩ + · have Hk0 : k % 2 = 0 := by omega + by_cases Hnear : b ≤ p + k + · by_cases Hcap : t + k ≤ p + b + e + · exact near_core p e k b t HChain He Hpar Hk Hkp Hb Hnear Hbe Ht Hte Hcap + · rcases even_overflow_core p e k b t HChain He Hpar (by omega) (by omega) Hk0 (by omega) + Hbe Hte Hnear (by omega) (by dsimp [next_p]; omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Safe.Safe_core ys HY⟩ + · rcases halving_progress p k (b - (p + k)) t HChain (by omega) Hkp Hk0 (by omega) (by omega) + (by omega) Ht Hte (by omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, section_step_eq HT, HY⟩ + +theorem short_diagonal_safe (p e k : Nat) + (HChain : Chain p) (He : e ≤ 1) (Hpar : p % 2 + e = 1) (Hk : 2 ≤ k) (Hkp : k ≤ p) + (Hke : k % 2 = 0) : + ∃ ys, ((section_481 [p + k, p + k + 1 + e, 1]) [target_tm]⊢⁺ (section_481 ys)) ∧ Safe ys := by + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + let P_val := next_p p + let K := k / 2 + have EP : P_val = p * 2 + 2 + e := by dsimp [P_val, next_p]; omega + have HC : Chain P_val := Chain.ChainS p HChain + have ET : (section_481 [p + k, p + k + 1 + e, 1]) + [target_tm]⊢⁺ (section_481 [P_val + K, P_val + 2 + e, k * 4 + 1 - e * 2]) := by + refine even_short_clean p e k (p + k + 1 + e) _ HChain He Hpar Hk Hkp Hke (by omega) (by omega) + ?_ + exact CleanLast_eq (@CleanLast.CleanEven (p + k * 2) (next_p p + k / 2) (p + 1 + e) (by omega)) + rfl rfl (by omega) (by dsimp [P_val, K]; list_nat_eq) + rcases bounded_small_advance P_val (1 - e) K (P_val + 2 + e) (k * 4 + 1 - e * 2) HC + (by omega) (by omega) (by dsimp [K]; omega) (by dsimp [K]; omega) (by omega) (by omega) + (by omega) (by omega) (by omega) (by dsimp [K]; omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, progress_trans ET HT, HY⟩ + +theorem predecessor_core (p b t : Nat) + (HChain : Chain p) (Hb : 2 ≤ b) (Hbe : b % 2 = 0) (Ht : 1 ≤ t) (Hte : t % 2 = 1) + (Hhi : t < next_p p + 3 + (1 - next_p p % 2)) : + ∃ ys, ((section_481 [next_p p - 1, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Core ys := by + have HP := next_p_grows p + have HT := predecessor_section p b t HChain Hb Hbe Hte + dsimp [pred_output] at HT + rw [ite_eq_left (by omega)] at HT + rcases good_bounded_core (next_p p) (b + t - 1) (next_p p + 3 + (1 - next_p p % 2) - t) + (Chain.ChainS p HChain) (by omega) with ⟨ys, HY, HZ⟩ + exact ⟨ys, progress_trans (section_step_eq HT) HY, HZ⟩ + +theorem diagonal_progress (n b t : Nat) (Hn : 3 ≤ n) (HD : Diagonal n b t) : + ∃ ys, ((section_481 [n, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Safe ys := by + rcases HD with ⟨Hb, Hbe, Ht, Hte, Hsum⟩ + rcases Band_total n Hn with ⟨p, HChain, Hlo, Hhi⟩ + rcases Chain_spec p HChain with ⟨Hp, HP, _⟩ + let e := 1 - p % 2 + let k := n - p + have He : e ≤ 1 := by dsimp [e]; omega + have Hpar : p % 2 + e = 1 := by dsimp [e]; omega + have En : n = p + k := by dsimp [k]; omega + by_cases Hk0 : k = 0 + · have Enp : n = p := by omega + rw [Enp] + rcases good_bounded_core p b t HChain (by omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Safe.Safe_core ys HY⟩ + · by_cases Enp : n = next_p p - 1 + · subst Enp + rcases predecessor_core p b t HChain Hb Hbe Ht Hte (by dsimp [next_p] at *; omega) with ⟨ys, + HT, HY⟩ + exact ⟨ys, HT, Safe.Safe_core ys HY⟩ + · rw [En] + dsimp [next_p] at Hhi + by_cases Hko : k % 2 = 1 + · rcases odd_even_bounded_core p e k b t HChain He Hpar Hko (by dsimp [next_p] at Enp; omega) + Hb Hbe Hte (by omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Safe.Safe_core ys HY⟩ + · have Hk : 2 ≤ k := by dsimp [next_p] at Enp; omega + have Hkp : k ≤ p := by dsimp [next_p] at Enp; omega + have Hke0 : k % 2 = 0 := by omega + by_cases Ht1 : t = 1 + · subst Ht1 + rcases short_diagonal_safe p e k HChain He Hpar Hk Hkp Hke0 with ⟨ys, HT, HY⟩ + exact ⟨ys, section_step_eq HT, HY⟩ + · have Hbn : b ≤ p + k := by omega + by_cases Hcap : t + k ≤ p + b + e + · rcases even_normal_section p e k b t HP He Hpar Hk Hkp Hke0 Hb Hbe (by omega) + Hte Hbn Hcap with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Safe.Safe_stair p (1 - e) ys HChain (by omega) HY⟩ + · rcases even_overflow_core p e k b t HChain He Hpar Hk Hkp Hke0 Hb Hbe Hte Hbn (by omega) + (by dsimp [next_p]; omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Safe.Safe_core ys HY⟩ + +theorem small_cleanup_low (p k b t : Nat) + (HC : Chain p) (Hk : 1 ≤ k) (Hkp : k * 4 ≤ p) (Hb : 2 ≤ b) (Hbe : b % 2 = 0) + (Ht : 1 ≤ t) (Hte : t % 2 = 1) (Hsum : b + t = p + k * 8 + 2 + (1 - p % 2)) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢* (section_481 ys)) ∧ Safe ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + let e := 1 - p % 2 + have He : e ≤ 1 := by dsimp [e]; omega + have Hpe : p % 2 + e = 1 := by dsimp [e]; omega + by_cases Hsmall : b ≤ p + · refine ⟨[p + k, b, t], ⟨0, rfl⟩, ?_⟩ + exact Safe.Safe_core _ (Core.Core_entry _ (CoreEntry.Entry_small p (p + k) b t + ⟨HC, by omega, by dsimp [next_p]; omega⟩ Hb Hbe Ht Hte Hsmall (by omega))) + · by_cases Hko : k % 2 = 1 + · rcases odd_even_bounded_core p e k b t HC He Hpe Hko (by omega) Hb Hbe Hte + (by dsimp [e] at *; omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, ReachesPlus.to_star HT, Safe.Safe_core ys HY⟩ + · have Hke0 : k % 2 = 0 := by omega + have Hk2 : 2 ≤ k := by omega + by_cases Hnear : b ≤ p + k + · by_cases Hcap : t + k ≤ p + b + e + · rcases near_core p e k b t HC He Hpe Hk Hkp (by omega) Hnear Hbe Ht Hte Hcap with ⟨ys, HT, + HY⟩ + exact ⟨ys, ReachesPlus.to_star HT, HY⟩ + · rcases even_overflow_core p e k b t HC He Hpe Hk2 (by omega) Hke0 Hb Hbe Hte Hnear + (by omega) (by dsimp [next_p, e] at *; omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, ReachesPlus.to_star HT, Safe.Safe_core ys HY⟩ + · refine ⟨[p + k, b, t], ⟨0, rfl⟩, ?_⟩ + exact Safe_eq (Safe.Safe_half p k (b - (p + k)) t HC Hk2 Hkp Hke0 (by omega) + (by dsimp [e] at *; omega) (by dsimp [e] at *; omega) Ht Hte (by dsimp [e] at *; omega)) + +theorem cleanup_low_reaches (p k N t : Nat) (xs : List Nat) + (HC : Chain p) (Hk : 1 ≤ k) (Hkp : k * 4 ≤ p) + (Hsum : N * 2 + 5 = p + k * 8 + 2 + (1 - p % 2)) (Hte : t % 2 = 0) (Ht : t < N * 2 + 5) + (HL : CleanLast N (p + k) t xs) : + ∃ ys, ((section_481 xs) [target_tm]⊢* (section_481 ys)) ∧ Safe ys := by + cases HL with + | Clean0 => + exact ⟨[p + k + 5 + N * 2], ⟨0, rfl⟩, + Safe.Safe_core _ (Core.Core_entry _ (CoreEntry.Entry_unary _))⟩ + | Clean1 => omega + | CleanEven s Hs => + exact small_cleanup_low p k (2 + s * 2) (3 + (N - s) * 2) HC Hk Hkp (by omega) (by omega) + (by omega) (by omega) (by omega) + | CleanOdd s Hs => omega + | CleanBorder => + exact small_cleanup_low p k (4 + N * 2) 1 HC Hk Hkp (by omega) (by omega) (by omega) (by omega) + (by omega) + | CleanOver a => omega + +inductive HighExit : List Nat → Prop where + | High_exit (p k t : Nat) : + Chain p → 1 ≤ k → k * 4 ≤ p → 1 ≤ t → t % 2 = 1 → + t + k * 12 + 2 + (1 - p % 2) ≤ p * 7 → + HighExit [p + k, p + k * 8 + 2 + (1 - p % 2), t] + +def EntryExit (xs : List Nat) : Prop := Safe xs ∨ HighExit xs + +theorem cleanup_entry_exit (p k N t : Nat) (xs : List Nat) + (HC : Chain p) (Hk : 1 ≤ k) (Hkp : k * 4 ≤ p) + (Hsum : N * 2 + 5 = p + k * 8 + 2 + (1 - p % 2)) (Hte : t % 2 = 0) (Hcap : t + k * 4 ≤ p * 8) + (HL : CleanLast N (p + k) t xs) : + ∃ ys, ((section_481 xs) [target_tm]⊢* (section_481 ys)) ∧ EntryExit ys := by + by_cases Hlow : t < N * 2 + 5 + · rcases cleanup_low_reaches p k N t xs HC Hk Hkp Hsum Hte Hlow HL with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Or.inl HY⟩ + · cases HL with + | CleanOver a => + refine ⟨[p + k, 5 + N * 2, a], ⟨0, rfl⟩, Or.inr ?_⟩ + have heq : 5 + N * 2 = p + k * 8 + 2 + (1 - p % 2) := by omega + rw [heq] + exact HighExit.High_exit p k a HC Hk Hkp (by omega) (by omega) (by omega) + | _ => omega + +theorem post_good_cleanup (p e b t : Nat) (xs : List Nat) + (HP : P p) (He : e ≤ 1) (Hpe : p % 2 + e = 1) (Hb : 2 ≤ b) (Hbp : b ≤ p) (Hbe : b % 2 = 0) + (HL : CleanLast (p + b * 2) (next_p p + b / 2) t xs) : + (section_481 [p + b, p + b + 2 + e, t]) [target_tm]⊢⁺ (section_481 xs) := + even_odd_section p (1 - e) b (p + b + 2 + e) t xs HP (by omega) (by omega) Hb Hbp Hbe (by omega) + (CleanLast_eq HL (by omega) (by dsimp [next_p]; omega) rfl rfl) + +theorem good_even_cleanup (p e b t : Nat) (xs : List Nat) + (HP : P p) (Hp : 3 ≤ p) (He : e ≤ 1) (Hpe : p % 2 + e = 1) + (Hb : 2 ≤ b) (Hbp : b ≤ p) (Hbe : b % 2 = 0) (Ht : p + b + 1 + e < t) + (HL : CleanLast (p + b * 2) (next_p p + b / 2) (t - (p + b + 2 + e)) xs) : + (section_481 [p, b, t]) [target_tm]⊢⁺ (section_481 xs) := by + have HT := good_section_formula p b t HP (by omega) + have E : last_output t (p + b) = [p + b, p + b + 2 + e, t - (p + b + 2 + e)] := by + dsimp [last_output] + rw [ite_eq_right (by omega), ite_eq_right (by omega)] + list_nat_eq + rw [E] at HT + exact progress_trans HT (post_good_cleanup p e b (t - (p + b + 2 + e)) xs HP He Hpe Hb Hbp Hbe HL) + +theorem mixed_good_entry (p b t : Nat) + (HC : Chain p) (Hb : 2 ≤ b) (Hbp : b ≤ p) (Hbe : b % 2 = 0) (Hte : t % 2 = 1) + (Hsum : b + t ≤ p * 18) : + ∃ ys, ((section_481 [p, p + b + 2 + (1 - p % 2), t]) [target_tm]⊢⁺ (section_481 ys)) + ∧ EntryExit ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + let e := 1 - p % 2 + let q := next_p p + have HQ : Chain q := Chain.ChainS p HC + rcases Chain_spec q HQ with ⟨Hq, HPq, _⟩ + rcases good_core_or_overflow p (p + b + 2 + e) t HC (by omega) with ⟨xs, HT, HY | ⟨u, rfl, EU⟩⟩ + · exact ⟨xs, HT, Or.inl (Safe.Safe_core xs HY)⟩ + · rcases CleanLast_total (q + b * 2) (next_p q + b / 2) u with ⟨zs, HL⟩ + have HU := post_good_cleanup q (1 - e) b u zs HPq (by dsimp [e]; omega) + (by dsimp [q, next_p, e]; omega) + Hb (by dsimp [q, next_p]; omega) Hbe HL + rcases cleanup_entry_exit (next_p q) (b / 2) (q + b * 2) u zs (Chain.ChainS q HQ) + (by omega) (by dsimp [q, next_p]; omega) (by dsimp [q, next_p, e]; omega) + (by dsimp [q, next_p, e] at *; omega) (by dsimp [q, next_p, e] at *; omega) HL with ⟨ys, HV, + HY⟩ + exact ⟨ys, progress_trans HT (progress_evstep_trans (section_step_eq HU + (by dsimp [q, next_p, e]; list_nat_eq) rfl) HV), HY⟩ + +theorem odd_entry_exit (p k b t : Nat) + (HC : Chain p) (Hko : k % 2 = 1) (Hkp : k ≤ p + (1 - p % 2)) + (Hb : 2 ≤ b) (Hbp : b ≤ p) (Hbe : b % 2 = 0) (Hte : t % 2 = 1) (Hsum : b + t ≤ (p + k) * 8) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ EntryExit ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + let e := 1 - p % 2 + have He : e ≤ 1 := by dsimp [e]; omega + have Hpe : p % 2 + e = 1 := by dsimp [e]; omega + have HT := odd_even_section p e k b t HP Hp He Hpe Hko Hkp Hbe Hte + dsimp [odd_output] at HT + by_cases E : t < p + 2 + e - k + · rw [ite_eq_left E] at HT + rcases good_bounded_core p (b + k + t) (p + 2 + e - k - t) HC (by omega) with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_trans HT HU, Or.inl (Safe.Safe_core ys HY)⟩ + · rw [ite_eq_right E] at HT + rcases mixed_good_entry p b (t - (p + 2 + e - k)) HC Hb Hbp Hbe (by omega) + (by dsimp [e] at *; omega) with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_trans HT HU, HY⟩ + +theorem predecessor_entry_exit (p b t : Nat) + (HC : Chain p) (Hb : 2 ≤ b) (Hbp : b ≤ p) (Hbe : b % 2 = 0) (Hte : t % 2 = 1) + (Hsum : b + t ≤ (next_p p - 1) * 8) : + ∃ ys, ((section_481 [next_p p - 1, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ EntryExit ys := by + have HT := predecessor_section p b t HC Hb Hbe Hte + let q := next_p p + have HQ : Chain q := Chain.ChainS p HC + rcases Chain_spec q HQ with ⟨Hq, HPq, _⟩ + dsimp [pred_output] at HT + by_cases E : t < (next_p p - 1) + 4 + (next_p p - 1) % 2 + · rw [ite_eq_left E] at HT + rcases good_bounded_core q (b + t - 1) (q + 3 + (1 - q % 2) - t) HQ (by dsimp [q] at *; omega) + with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_trans (section_step_eq HT (by rfl) (by dsimp [q] at *; list_nat_eq)) HU, + Or.inl (Safe.Safe_core ys HY)⟩ + · rw [ite_eq_right E] at HT + rcases mixed_good_entry q b (t - (q + 3 + (1 - q % 2))) HQ Hb (by dsimp [q, next_p]; omega) Hbe + (by dsimp [q] at *; omega) (by dsimp [q] at *; omega) with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_trans (section_step_eq HT (by rfl) (by dsimp [q] at *; list_nat_eq)) HU, HY⟩ + +theorem good_entry_exit (p b t : Nat) + (HC : Chain p) (Hb : 2 ≤ b) (Hbp : b ≤ p) (Hbe : b % 2 = 0) (Hte : t % 2 = 1) + (Hsum : b + t ≤ p * 8) : + ∃ ys, ((section_481 [p, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ EntryExit ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + let e := 1 - p % 2 + have He : e ≤ 1 := by dsimp [e]; omega + have Hpe : p % 2 + e = 1 := by dsimp [e]; omega + by_cases Hlow : t ≤ p + b + 1 + e + · rcases good_bounded_core p b t HC (by dsimp [e] at *; omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Or.inl (Safe.Safe_core ys HY)⟩ + · rcases CleanLast_total (p + b * 2) (next_p p + b / 2) (t - (p + b + 2 + e)) with ⟨xs, HL⟩ + have HT := good_even_cleanup p e b t xs HP Hp He Hpe Hb Hbp Hbe (by omega) HL + rcases cleanup_entry_exit (next_p p) (b / 2) (p + b * 2) (t - (p + b + 2 + e)) xs + (Chain.ChainS p HC) (by omega) (by dsimp [next_p]; omega) (by dsimp [next_p, e]; omega) + (by dsimp [e] at *; omega) (by dsimp [next_p, e] at *; omega) HL with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_evstep_trans HT HU, HY⟩ + +theorem even_entry_exit (p k b t : Nat) + (HC : Chain p) (Hk : 2 ≤ k) (Hkp : k ≤ p) (Hke : k % 2 = 0) + (Hb : 2 ≤ b) (Hbp : b ≤ p) (Hbe : b % 2 = 0) (Hte : t % 2 = 1) (Hsum : b + t ≤ (p + k) * 8) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ EntryExit ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + let e := 1 - p % 2 + have He : e ≤ 1 := by dsimp [e]; omega + have Hpe : p % 2 + e = 1 := by dsimp [e]; omega + by_cases Ht1 : t = 1 + · subst Ht1 + by_cases Hsmall : b < k + · rcases even_short_core p e k b HC He Hpe Hk Hkp Hke Hbe Hsmall with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Or.inl (Safe.Safe_core ys HY)⟩ + · rcases CleanLast_total (p + k * 2) (next_p p + k / 2) ((b - k) * 2 + 2) with ⟨xs, HL⟩ + have HT := even_short_clean p e k b xs HC He Hpe Hk Hkp Hke Hbe (by omega) HL + rcases cleanup_entry_exit (next_p p) (k / 2) (p + k * 2) ((b - k) * 2 + 2) xs + (Chain.ChainS p HC) (by omega) (by dsimp [next_p]; omega) (by dsimp [next_p, e]; omega) + (by omega) (by dsimp [next_p, e] at *; omega) HL with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_evstep_trans HT HU, HY⟩ + · by_cases Hnormal : t + k ≤ p + b + e + · rcases even_normal_section p e k b t HP He Hpe Hk Hkp Hke Hb Hbe (by omega) Hte (by omega) + Hnormal with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Or.inl (Safe.Safe_stair p (1 - e) ys HC (by omega) HY)⟩ + · rcases CleanLast_total (p + b * 2) (next_p p + b / 2) (t + k - (p + b + 2 + e)) with ⟨xs, HL⟩ + have HT := even_overflow_section p e k b t xs HP He Hpe Hk Hkp Hke Hb Hbe Hte (by omega) + (by omega) HL + rcases cleanup_entry_exit (next_p p) (b / 2) (p + b * 2) (t + k - (p + b + 2 + e)) xs + (Chain.ChainS p HC) (by omega) (by dsimp [next_p]; omega) (by dsimp [next_p, e]; omega) + (by dsimp [e] at *; omega) (by dsimp [next_p, e] at *; omega) HL with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_evstep_trans HT HU, HY⟩ + +theorem entry_exit (p n b t : Nat) + (HB : Band p n) (Hb : 2 ≤ b) (Hbp : b ≤ p) (Hbe : b % 2 = 0) (Hte : t % 2 = 1) + (Hsum : b + t ≤ n * 8) : + ∃ ys, ((section_481 [n, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ EntryExit ys := by + rcases HB with ⟨HC, Hpn, Hnp⟩ + let k := n - p + have En : n = p + k := by dsimp [k]; omega + by_cases Hk0 : k = 0 + · have heq : n = p := by omega + rw [heq] + exact good_entry_exit p b t HC Hb Hbp Hbe Hte (by omega) + · by_cases Hpred : n = next_p p - 1 + · rw [Hpred] at Hsum ⊢ + exact predecessor_entry_exit p b t HC Hb Hbp Hbe Hte Hsum + · rw [En] at Hsum ⊢ + by_cases Hko : k % 2 = 1 + · exact odd_entry_exit p k b t HC Hko (by dsimp [next_p] at *; omega) Hb Hbp Hbe Hte Hsum + · exact even_entry_exit p k b t HC (by dsimp [next_p] at *; omega) + (by dsimp [next_p] at *; omega) (by omega) Hb Hbp Hbe Hte Hsum + +theorem core_entry_exit (xs : List Nat) (H : Core xs) : + ∃ ys, ((section_481 xs) [target_tm]⊢⁺ (section_481 ys)) ∧ EntryExit ys := by + cases H with + | Core_entry xs H => + cases H with + | Entry_unary n => + rcases unary_core_progress n with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Or.inl (Safe.Safe_core ys HY)⟩ + | Entry_small p n b t HB Hb Hbe Ht Hte Hbp Hsum => + exact entry_exit p n b t HB Hb Hbp Hbe Hte Hsum + | Core_diagonal n b t Hn HD => + rcases diagonal_progress n b t Hn HD with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Or.inl HY⟩ + +theorem entry_exit_progress + (Hhigh : ∀ xs, HighExit xs → ∃ ys, ((section_481 xs) [target_tm]⊢⁺ (section_481 ys)) + ∧ EntryExit ys) + (xs : List Nat) (H : EntryExit xs) : + ∃ ys, ((section_481 xs) [target_tm]⊢⁺ (section_481 ys)) ∧ EntryExit ys := by + rcases H with H | H + · cases H with + | Safe_core xs H => exact core_entry_exit xs H + | Safe_stair p e xs HP He H => + rcases Stair_progress p e xs HP He H with ⟨ys, HT, HY | HY⟩ + · exact ⟨ys, HT, Or.inl (Safe.Safe_stair p e ys HP He HY)⟩ + · exact ⟨ys, HT, Or.inl (Safe.Safe_core ys (Core.Core_entry ys HY))⟩ + | Safe_half p k d t HP Hk Hkp Hke Hd Hdp Hde Ht Hte Hcap => + rcases halving_progress p k d t HP Hk Hkp Hke Hd Hdp Hde Ht Hte Hcap with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Or.inl HY⟩ + · exact Hhigh xs H + +theorem odd_post_good_finish (p e k t : Nat) + (HC : Chain p) (He : e ≤ 1) (Hpe : p % 2 + e = 1) (Hko : k % 2 = 1) (Hkp : k ≤ p + e) + (Hcap : t + e ≤ p + k * 3 + 2) : + ∃ ys, ((section_481 [p + k, p + k + 2 + (1 - (p + k) % 2), t]) [target_tm]⊢⁺ (section_481 ys)) + ∧ Core ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + have HT := odd_odd_section p e k (p + k + 2 + (1 - (p + k) % 2)) t HP Hp He Hpe Hko Hkp (by omega) + rcases good_bounded_core p (p + k + 2 + (1 - (p + k) % 2) + k) (t + p + 2 + e - k) HC (by omega) + with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_trans HT HU, HY⟩ + +theorem odd_post_good_core (p e k t : Nat) + (HC : Chain p) (He : e ≤ 1) (Hpe : p % 2 + e = 1) (Hko : k % 2 = 1) (Hkp : k ≤ p + e) + (Hcap : t ≤ (p + k) * 3) : + ∃ ys, ((section_481 [p + k, p + k + 2 + (1 - (p + k) % 2), t]) [target_tm]⊢⁺ (section_481 ys)) + ∧ Core ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + have HT := odd_odd_section p e k (p + k + 2 + (1 - (p + k) % 2)) t HP Hp He Hpe Hko Hkp (by omega) + let b := p + k + 2 + (1 - (p + k) % 2) + k + rcases good_core_or_overflow p b (t + p + 2 + e - k) HC (by dsimp [b]; omega) with ⟨xs, HU, + HY | ⟨u, rfl, EU⟩⟩ + · exact ⟨xs, progress_trans HT HU, HY⟩ + · let q := next_p p + let j := k * 2 + 1 - e * 2 + have HQ : Chain q := Chain.ChainS p HC + have E : p + b = q + j := by dsimp [b, q, j, next_p]; omega + rcases odd_post_good_finish q (1 - e) j u HQ (by omega) (by dsimp [q, next_p]; omega) + (by dsimp [j]; omega) (by dsimp [q, j, next_p]; omega) + (by dsimp [q, j, b, next_p] at *; omega) with ⟨ys, HV, HY⟩ + exact ⟨ys, progress_trans HT (progress_trans (section_step_eq HU rfl (by rw [E])) HV), HY⟩ + +theorem post_good_even_entry (p n t : Nat) + (HB : Band p n) (Hpred : n ≠ next_p p - 1) (Hte : t % 2 = 0) (Hcap : t ≤ n * 3) : + ∃ ys, ((section_481 [n, n + 2 + (1 - n % 2), t]) [target_tm]⊢⁺ (section_481 ys)) + ∧ EntryExit ys := by + rcases HB with ⟨HC, Hpn, Hnp⟩ + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + let e := 1 - p % 2 + let k := n - p + have He : e ≤ 1 := by dsimp [e]; omega + have Hpe : p % 2 + e = 1 := by dsimp [e]; omega + have En : n = p + k := by dsimp [k]; omega + by_cases Hk0 : k = 0 + · have heq : n = p := by omega + rw [heq] + rcases good_core_or_overflow p (p + 2 + e) t HC (by omega) with ⟨xs, HT, HY | ⟨u, rfl, EU⟩⟩ + · exact ⟨xs, HT, Or.inl (Safe.Safe_core xs HY)⟩ + · rcases good_bounded_core (next_p p) (next_p p + 2 + (1 - next_p p % 2)) u + (Chain.ChainS p HC) (by dsimp [next_p, e] at *; omega) with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_trans (section_step_eq HT rfl (by dsimp [next_p, e] ; list_nat_eq)) HU, + Or.inl (Safe.Safe_core ys HY)⟩ + · rw [En] at Hcap ⊢ + by_cases Hko : k % 2 = 1 + · rcases odd_post_good_core p e k t HC He Hpe Hko (by dsimp [next_p, k] at *; omega) + Hcap with ⟨ys, HT, HY⟩ + exact ⟨ys, HT, Or.inl (Safe.Safe_core ys HY)⟩ + · have Hk : 2 ≤ k := by dsimp [next_p, k] at *; omega + have Hkp : k ≤ p := by dsimp [next_p, k] at *; omega + have Hke0 : k % 2 = 0 := by omega + rcases CleanLast_total (p + k * 2) (next_p p + k / 2) t with ⟨xs, HL⟩ + have HT := post_good_cleanup p e k t xs HP He Hpe Hk Hkp Hke0 HL + rcases cleanup_entry_exit (next_p p) (k / 2) (p + k * 2) t xs (Chain.ChainS p HC) + (by omega) (by dsimp [next_p]; omega) (by dsimp [next_p, e]; omega) + Hte (by dsimp [next_p, e] at *; omega) HL with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_evstep_trans (section_step_eq HT) HU, HY⟩ + +theorem high_odd_progress (p e k t : Nat) + (HC : Chain p) (He : e ≤ 1) (Hpe : p % 2 + e = 1) (Hk : 1 ≤ k) (Hkp : k * 4 ≤ p) + (Hko : k % 2 = 1) + (Ht : 1 ≤ t) (Hte : t % 2 = 1) (Hcap : t + k * 12 + 2 + e ≤ p * 7) : + ∃ ys, ((section_481 [p + k, p + k * 8 + 2 + e, t]) [target_tm]⊢⁺ (section_481 ys)) + ∧ EntryExit ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + have HT := odd_odd_section p e k (p + k * 8 + 2 + e) t HP Hp He Hpe Hko (by omega) (by omega) + rcases good_core_or_overflow p (p + k * 8 + 2 + e + k) (t + p + 2 + e - k) HC (by omega) with ⟨xs, + HU, HY | ⟨u, rfl, EU⟩⟩ + · exact ⟨xs, progress_trans HT HU, Or.inl (Safe.Safe_core xs HY)⟩ + · let q := next_p p + have HQ : Chain q := Chain.ChainS p HC + have E : p + (p + k * 8 + 2 + e + k) = q + k * 9 := by dsimp [q, next_p]; omega + have Hbound : u ≤ (q + k * 9) * 3 := by dsimp [q, next_p] at *; omega + have Hue : u % 2 = 0 := by dsimp [q, next_p] at *; omega + have HR : ∃ r, Band r (q + k * 9) ∧ q + k * 9 ≠ next_p r - 1 := by + by_cases Hlo : q + k * 9 < next_p q + · exact ⟨q, ⟨HQ, by dsimp [q, next_p] at *; omega, Hlo⟩, by dsimp [q, next_p] at *; omega⟩ + · exact ⟨next_p q, ⟨Chain.ChainS q HQ, by dsimp [q, next_p] at *; omega, + by dsimp [q, next_p] at *; omega⟩, by dsimp [q, next_p] at *; omega⟩ + rcases HR with ⟨r, HB, Hpred⟩ + rcases post_good_even_entry r (q + k * 9) u HB Hpred Hue Hbound with ⟨ys, HV, HY⟩ + exact ⟨ys, progress_trans HT (progress_trans (section_step_eq HU rfl (by rw [E])) HV), HY⟩ + +theorem small_cleanup_upper (p k b t : Nat) + (HC : Chain p) (Hk : 1 ≤ k) (Hkp : k * 4 + 2 ≤ p) (Hb : 2 ≤ b) (Hbe : b % 2 = 0) + (Ht : 1 ≤ t) (Hte : t % 2 = 1) (Hsum : b + t ≤ p + k * 8 + 4 + (1 - p % 2)) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢* (section_481 ys)) ∧ Safe ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + let e := 1 - p % 2 + have He : e ≤ 1 := by dsimp [e]; omega + have Hpe : p % 2 + e = 1 := by dsimp [e]; omega + by_cases Hsmall : b ≤ p + · refine ⟨[p + k, b, t], ⟨0, rfl⟩, ?_⟩ + exact Safe.Safe_core _ (Core.Core_entry _ (CoreEntry.Entry_small p (p + k) b t + ⟨HC, by omega, by dsimp [next_p]; omega⟩ Hb Hbe Ht Hte Hsmall (by omega))) + · by_cases Hko : k % 2 = 1 + · rcases odd_even_bounded_core p e k b t HC He Hpe Hko (by omega) Hb Hbe Hte + (by dsimp [e] at *; omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, ReachesPlus.to_star HT, Safe.Safe_core ys HY⟩ + · have Hke0 : k % 2 = 0 := by omega + have Hk2 : 2 ≤ k := by omega + by_cases Hnear : b ≤ p + k + · by_cases Hcap : t + k ≤ p + b + e + · rcases near_core p e k b t HC He Hpe Hk (by omega) (by omega) + Hnear Hbe Ht Hte Hcap with ⟨ys, HT, HY⟩ + exact ⟨ys, ReachesPlus.to_star HT, HY⟩ + · rcases even_overflow_core p e k b t HC He Hpe Hk2 (by omega) Hke0 Hb Hbe Hte Hnear + (by omega) (by dsimp [next_p, e] at *; omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, ReachesPlus.to_star HT, Safe.Safe_core ys HY⟩ + · refine ⟨[p + k, b, t], ⟨0, rfl⟩, ?_⟩ + exact Safe_eq (Safe.Safe_half p k (b - (p + k)) t HC Hk2 (by omega) Hke0 (by omega) + (by dsimp [e] at *; omega) (by dsimp [e] at *; omega) Ht Hte (by dsimp [e] at *; omega)) + +theorem small_near_reaches (p k b t : Nat) + (HC : Chain p) (Hk : 1 ≤ k) (Hkp : k * 4 ≤ p) (Hb : p < b) (Hbe : b % 2 = 0) + (Ht : 1 ≤ t) (Hte : t % 2 = 1) (Hdelta : b - (p + k) ≤ p * 2) + (Hbound : t + k ≤ p + b + 2 + (1 - p % 2) + next_p p) + (Hcap : b ≤ p + k ∨ t + k ≤ p + b + (1 - p % 2)) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢* (section_481 ys)) ∧ Safe ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + let e := 1 - p % 2 + have He : e ≤ 1 := by dsimp [e]; omega + have Hpe : p % 2 + e = 1 := by dsimp [e]; omega + by_cases Hko : k % 2 = 1 + · rcases odd_even_bounded_core p e k b t HC He Hpe Hko (by omega) (by omega) Hbe Hte + (by dsimp [next_p, e] at *; omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, ReachesPlus.to_star HT, Safe.Safe_core ys HY⟩ + · have Hke0 : k % 2 = 0 := by omega + have Hk2 : 2 ≤ k := by omega + by_cases Hnear : b ≤ p + k + · by_cases Hnormal : t + k ≤ p + b + e + · rcases near_core p e k b t HC He Hpe Hk Hkp Hb Hnear Hbe Ht Hte Hnormal with ⟨ys, HT, HY⟩ + exact ⟨ys, ReachesPlus.to_star HT, HY⟩ + · rcases even_overflow_core p e k b t HC He Hpe Hk2 (by omega) Hke0 (by omega) Hbe Hte Hnear + (by omega) Hbound with ⟨ys, HT, HY⟩ + exact ⟨ys, ReachesPlus.to_star HT, Safe.Safe_core ys HY⟩ + · refine ⟨[p + k, b, t], ⟨0, rfl⟩, ?_⟩ + exact Safe_eq (Safe.Safe_half p k (b - (p + k)) t HC Hk2 Hkp Hke0 (by omega) Hdelta + (by dsimp [e] at *; omega) Ht Hte (by dsimp [e] at *; omega)) + +theorem odd_block_short (p e k b t : Nat) + (HC : Chain p) (He : e ≤ 1) (Hpe : p % 2 + e = 1) (Hk : 1 ≤ k) (Hkp : k * 4 ≤ p) + (Hb : p ≤ b) (Hbo : b % 2 = 1) (Ht : t ≤ p) : + ∃ ys, ((section_481 [p + k, b, t]) [target_tm]⊢⁺ (section_481 ys)) ∧ Core ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + by_cases Hko : k % 2 = 1 + · have HT := odd_odd_section p e k b t HP Hp He Hpe Hko (by omega) Hbo + rcases good_bounded_core p (b + k) (t + p + 2 + e - k) HC (by omega) with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_trans HT HU, HY⟩ + · let N := (p + k * 3 + b + (1 - e) - 2) / 2 + let X := p + b - k / 2 + rcases Band_above p X HC (by dsimp [X]; omega) with ⟨q, Hq, HB⟩ + rcases CleanLast_total N X t with ⟨ys, HL⟩ + refine ⟨ys, even_odd_section p (1 - e) k b t ys HP (by omega) (by omega) (by omega) (by omega) + (by omega) Hbo HL, ?_⟩ + cases HL with + | Clean0 => exact Core.Core_entry _ (CoreEntry.Entry_unary _) + | Clean1 => exact Core.Core_entry _ (CoreEntry.Entry_unary _) + | CleanEven s Hs => + exact Core.Core_entry _ (CoreEntry.Entry_small q X (2 + s * 2) (3 + (N - s) * 2) HB + (by omega) (by omega) (by omega) (by omega) (by dsimp [N, X] at *; omega) + (by dsimp [N, X] at *; omega)) + | CleanOdd s Hs => + exact Core.Core_entry _ (CoreEntry.Entry_small q X (2 + s * 2) (5 + (N - s) * 2) HB + (by omega) (by omega) (by omega) (by omega) (by dsimp [N, X] at *; omega) + (by dsimp [N, X] at *; omega)) + | CleanBorder => omega + | CleanOver a => omega + +theorem high_even_low (p e j b u : Nat) + (HC : Chain p) (He : e ≤ 1) (Hpe : p % 2 + e = 1) (Hj : 1 ≤ j) (Hjp : j * 8 ≤ p) + (Hb : 2 ≤ b) (Hbe : b % 2 = 0) (Hu : 5 ≤ u) (Hue : u % 2 = 1) + (Hsum : b + u = p * 2 + j * 22 + 7) (Hcap : b + j * 24 + 3 + e ≤ p * 7) : + ∃ ys, ((section_481 [next_p p + j * 15, b, u]) [target_tm]⊢* (section_481 ys)) ∧ Safe ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + let q := next_p p + have HQ : Chain q := Chain.ChainS p HC + rcases Chain_spec q HQ with ⟨Hq, HPq, _⟩ + have Hqe : q % 2 = e := by dsimp [q, next_p]; omega + by_cases Hsmall : b ≤ q + · refine ⟨[q + j * 15, b, u], ⟨0, rfl⟩, ?_⟩ + exact Safe.Safe_core _ (Core.Core_entry _ (CoreEntry.Entry_small q (q + j * 15) b u + ⟨HQ, by omega, by dsimp [q, next_p] at *; omega⟩ Hb Hbe (by omega) Hue Hsmall + (by dsimp [q, next_p] at *; omega))) + · by_cases Hjo : j % 2 = 1 + · rcases odd_even_bounded_core q (1 - e) (j * 15) b u HQ (by omega) (by omega) (by omega) + (by dsimp [q, next_p]; omega) Hb Hbe Hue (by dsimp [q, next_p] at *; omega) with ⟨ys, HT, + HY⟩ + exact ⟨ys, ReachesPlus.to_star HT, Safe.Safe_core ys HY⟩ + · have Hje0 : j % 2 = 0 := by omega + by_cases Hnear : b ≤ q + j * 15 + · by_cases Hnormal : u + j * 15 ≤ q + b + (1 - e) + · rcases even_normal_section q (1 - e) (j * 15) b u HPq (by omega) (by omega) (by omega) + (by dsimp [q, next_p]; omega) (by omega) Hb Hbe (by omega) Hue Hnear Hnormal with ⟨ys, + HT, HY⟩ + exact ⟨ys, ReachesPlus.to_star HT, Safe.Safe_stair q e ys HQ He (Stair_eq HY)⟩ + · rcases even_overflow_core q (1 - e) (j * 15) b u HQ (by omega) (by omega) (by omega) + (by dsimp [q, next_p]; omega) (by omega) Hb Hbe Hue Hnear (by omega) + (by dsimp [q, next_p] at *; omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, ReachesPlus.to_star HT, Safe.Safe_core ys HY⟩ + · rcases Repair_total q (1 - e) (j * 15) (b - (q + j * 15)) (u - 1) (by omega) with ⟨xs, HR⟩ + have HT := wide_triple q (1 - e) (j * 15) b u xs HPq Hq (by omega) (by omega) (by omega) + (by dsimp [q, next_p]; omega) (by omega) Hb Hbe (by omega) Hue (by omega) + (by dsimp [q, next_p] at *; omega) (by dsimp [q, next_p] at *; omega) HR + cases HR with + | Repair_positive x Hx HX => + rcases small_near_reaches (next_p q) (j * 15 / 2) (q * 2 + (b - (q + j * 15)) * 2 + 2) x + (Chain.ChainS q HQ) (by omega) (by dsimp [q, next_p] at *; omega) + (by dsimp [q, next_p] at *; omega) + (by omega) Hx (by omega) (by dsimp [q, next_p] at *; omega) + (by dsimp [q, next_p] at *; omega) + (by dsimp [q, next_p] at *; omega) with ⟨ys, HU, HY⟩ + exact ⟨ys, ReachesStar.trans (ReachesPlus.to_star HT) HU, HY⟩ + | Repair_negative x Hx HX => dsimp [q, next_p] at *; omega + +theorem high_second_low (p e j b u : Nat) + (HC : Chain p) (He : e ≤ 1) (Hpe : p % 2 + e = 1) (Hj : 1 ≤ j) (_Hjp : j * 8 ≤ p) + (Hje : j % 2 = 0) + (Hb : 2 ≤ b) (Hbe : b % 2 = 0) (Hu : 1 ≤ u) (Hue : u % 2 = 1) + (Hsum : b + u = (next_p p + (j / 2) * 67) * 2 + 5) (Hcap : b + j * 46 + 7 + e ≤ p * 5) : + ∃ ys, ((section_481 [next_p (next_p p) + (j / 2) * 29, b, u]) [target_tm]⊢* (section_481 ys)) + ∧ Safe ys := by + let q := next_p (next_p p) + have HQ : Chain q := Chain.ChainS _ (Chain.ChainS p HC) + by_cases Hsmall : b ≤ q + · refine ⟨[q + (j / 2) * 29, b, u], ⟨0, rfl⟩, ?_⟩ + exact Safe.Safe_core _ (Core.Core_entry _ (CoreEntry.Entry_small q (q + (j / 2) * 29) b u + ⟨HQ, by omega, by dsimp [q, next_p] at *; omega⟩ Hb Hbe Hu Hue Hsmall + (by dsimp [q, next_p] at *; omega))) + · exact small_cleanup_upper q ((j / 2) * 29) b u HQ (by omega) (by dsimp [q, next_p] at *; omega) + Hb Hbe Hu Hue (by dsimp [q, next_p] at *; omega) + +theorem high_even_high (p e j c : Nat) + (HC : Chain p) (He : e ≤ 1) (Hpe : p % 2 + e = 1) (Hj : 1 ≤ j) (Hjp : j * 8 ≤ p) + (Hce : c % 2 = 0) (Hcap : c + j * 46 + 7 + e ≤ p * 5) : + ∃ ys, ((section_481 [next_p p + j * 15, p * 2 + j * 22 + 5, c]) [target_tm]⊢⁺ (section_481 ys)) + ∧ Safe ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + let q := next_p p + have HQ : Chain q := Chain.ChainS p HC + rcases Chain_spec q HQ with ⟨Hq, HPq, _⟩ + have Hqe : q % 2 = e := by dsimp [q, next_p]; omega + by_cases Hjo : j % 2 = 1 + · have HT := odd_odd_section q (1 - e) (j * 15) (p * 2 + j * 22 + 5) c HPq Hq + (by omega) (by omega) (by omega) (by dsimp [q, next_p]; omega) (by omega) + rcases good_core_or_overflow q (p * 2 + j * 22 + 5 + j * 15) (c + q + 2 + (1 - e) - j * 15) HQ + (by omega) with ⟨xs, HU, HY | ⟨u, rfl, EU⟩⟩ + · exact ⟨xs, progress_trans HT HU, Safe.Safe_core xs HY⟩ + · let r := next_p q + have HR : Chain r := Chain.ChainS q HQ + have E : q + (p * 2 + j * 22 + 5 + j * 15) = r + j * 37 := by dsimp [r, q, next_p]; omega + rcases odd_post_good_core r e (j * 37) u HR He (by dsimp [r, q, next_p]; omega) + (by omega) (by dsimp [r, q, next_p] at *; omega) (by dsimp [r, q, next_p] at *; omega) + with ⟨ys, HV, HY⟩ + exact ⟨ys, progress_trans HT (progress_trans (section_step_eq HU rfl (by rw [E])) HV), + Safe.Safe_core ys HY⟩ + · have Hje0 : j % 2 = 0 := by omega + let N := q + (j / 2) * 67 + let X := next_p q + (j / 2) * 29 + rcases CleanLast_total N X c with ⟨xs, HL⟩ + have HT : (section_481 [q + j * 15, p * 2 + j * 22 + 5, c]) [target_tm]⊢⁺ (section_481 xs) := by + refine even_odd_section q e (j * 15) (p * 2 + j * 22 + 5) c xs HPq He Hqe (by omega) + (by dsimp [q, next_p]; omega) (by omega) (by omega) ?_ + exact CleanLast_eq HL (by dsimp [N, X, q, next_p]; omega) (by dsimp [N, X, q, next_p]; omega) + rfl rfl + cases HL with + | Clean0 => exact ⟨_, HT, Safe.Safe_core _ (Core.Core_entry _ (CoreEntry.Entry_unary _))⟩ + | Clean1 => omega + | CleanEven s Hs => + rcases high_second_low p e j (2 + s * 2) (3 + (N - s) * 2) HC He Hpe Hj Hjp Hje0 + (by omega) (by omega) (by omega) (by omega) (by dsimp [N, q] at *; omega) + (by dsimp [N, q, next_p] at *; omega) with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_evstep_trans HT HU, HY⟩ + | CleanOdd s Hs => omega + | CleanBorder => + rcases high_second_low p e j (4 + N * 2) 1 HC He Hpe Hj Hjp Hje0 + (by omega) (by omega) (by omega) (by omega) (by dsimp [N, q] at *; omega) + (by dsimp [N, q, next_p] at *; omega) with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_evstep_trans HT HU, HY⟩ + | CleanOver a => + rcases odd_block_short (next_p q) e ((j / 2) * 29) (5 + N * 2) a (Chain.ChainS q HQ) He + (by dsimp [q, next_p]; omega) (by omega) (by dsimp [q, next_p] at *; omega) + (by dsimp [N, q, next_p] at *; omega) (by omega) (by dsimp [N, q, next_p] at *; omega) + with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_trans HT HU, Safe.Safe_core ys HY⟩ + +theorem high_even_progress (p e j t : Nat) + (HC : Chain p) (He : e ≤ 1) (Hpe : p % 2 + e = 1) (Hj : 1 ≤ j) (Hjp : j * 8 ≤ p) + (Ht : 1 ≤ t) (Hte : t % 2 = 1) (Hcap : t + j * 24 + 2 + e ≤ p * 7) : + ∃ ys, ((section_481 [p + j * 2, p + j * 16 + 2 + e, t]) [target_tm]⊢⁺ (section_481 ys)) + ∧ Safe ys := by + rcases Chain_spec p HC with ⟨Hp, HP, _⟩ + rcases CleanLast_total (p + j * 11) (next_p p + j * 15) t with ⟨xs, HL⟩ + have HT : (section_481 [p + j * 2, p + j * 16 + 2 + e, t]) [target_tm]⊢⁺ (section_481 xs) := by + refine even_odd_section p (1 - e) (j * 2) (p + j * 16 + 2 + e) t xs HP (by omega) (by omega) + (by omega) (by omega) (by omega) (by omega) ?_ + exact CleanLast_eq HL (by omega) (by dsimp [next_p]; omega) rfl rfl + cases HL with + | Clean0 => omega + | Clean1 => exact ⟨_, HT, Safe.Safe_core _ (Core.Core_entry _ (CoreEntry.Entry_unary _))⟩ + | CleanEven s Hs => omega + | CleanOdd s Hs => + rcases high_even_low p e j (2 + s * 2) (5 + (p + j * 11 - s) * 2) HC He Hpe Hj Hjp + (by omega) (by omega) (by omega) (by omega) (by omega) (by omega) with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_evstep_trans HT HU, HY⟩ + | CleanBorder => omega + | CleanOver a => + rcases high_even_high p e j a HC He Hpe Hj Hjp (by omega) (by omega) with ⟨ys, HU, HY⟩ + exact ⟨ys, progress_trans HT (section_step_eq HU), HY⟩ + +theorem high_exit_progress (xs : List Nat) (H : HighExit xs) : + ∃ ys, ((section_481 xs) [target_tm]⊢⁺ (section_481 ys)) ∧ EntryExit ys := by + cases H with + | High_exit p k t HC Hk Hkp Ht Hte Hcap => + by_cases Hko : k % 2 = 1 + · exact high_odd_progress p (1 - p % 2) k t HC (by omega) (by omega) Hk Hkp Hko Ht Hte Hcap + · rcases high_even_progress p (1 - p % 2) (k / 2) t HC (by omega) (by omega) (by omega) + (by omega) Ht Hte (by omega) with ⟨ys, HT, HY⟩ + exact ⟨ys, section_step_eq HT, Or.inl HY⟩ + +theorem closed_progress (xs : List Nat) (H : EntryExit xs) : + ∃ ys, ((section_481 xs) [target_tm]⊢⁺ (section_481 ys)) ∧ EntryExit ys := + entry_exit_progress high_exit_progress xs H + +theorem entry_unary_in_entryExit (n : Nat) : EntryExit [n] := + Or.inl (Safe.Safe_core [n] (Core.Core_entry [n] (CoreEntry.Entry_unary n))) + +theorem neverHaltsFrom_of_reachesStar {M : Machine (Fin 2) (Fin 6)} {c₁ c₀ : Cfg (Fin 2) (Fin 6)} + (hinit : c₁ [M]⊢* c₀) (h_never : NeverHaltsFrom M c₀) : NeverHaltsFrom M c₁ := by + obtain ⟨k₀, hk₀⟩ := hinit + intro cfg ⟨k, hk⟩ + rcases Nat.lt_or_ge k k₀ with hlt | hge + · rcases hstep_cfg : step M cfg with _ | _ + · have hnone : (step M cfg).isNone := by simp [hstep_cfg] + have hnone_k₀ : multiStep M c₁ k₀ = none := by + have hsplit : k₀ = k + (k₀ - k) := by omega + rw [hsplit] + exact multiStep_eq_none_of_isNone hk hnone (by omega) + rw [hnone_k₀] at hk₀ + cases hk₀ + · rfl + · have hsplit : k = k₀ + (k - k₀) := by omega + rw [hsplit, multiStep_add, hk₀, Option.bind_some] at hk + exact h_never cfg ⟨k - k₀, hk⟩ + +theorem section_nonhalt {xs : List Nat} (h : EntryExit xs) : + NeverHaltsFrom target_tm (section_481 xs) := by + refine NeverHaltsFrom.of_reachesPlus_invariant + (P := fun c => ∃ ys, c = section_481 ys ∧ EntryExit ys) ?_ ⟨xs, rfl, h⟩ + rintro _ ⟨ys, rfl, hys⟩ + rcases closed_progress ys hys with ⟨zs, hstep, hzs⟩ + exact ⟨section_481 zs, hstep, zs, rfl, hzs⟩ + +theorem init_481 : (init []) [target_tm]⊢* section_481 [1] := init_tm1 + +theorem init_221 : ((default : ListBlank (Fin 2)) {{2}}> default) [target_tm]⊢* section_481 [2] := + step_end (simSteps_star_ex 6 ⟨C, .right, [0], [0, 0]⟩ ⟨B, .right, [1, 0, 1], []⟩ + rfl default default) (by norm_cfg) (by norm_cfg) + +theorem init_554 : ((default : ListBlank (Fin 2)) {{5}}> default) [target_tm]⊢* section_481 [4] := + step_end (simSteps_star_ex 31 ⟨F, .right, [0, 0, 0, 0, 0, 0], [0]⟩ + ⟨B, .right, [1, 0, 1, 0, 1, 0, 1], []⟩ rfl default default) (by norm_cfg) (by norm_cfg) + +end + +public section + +theorem is_not_halt_from_0221 : + ∀ cfg : Cfg (Fin 2) (Fin 6), + (((default : ListBlank (Fin 2)) {{2}}> default) [target]⊢* cfg) → + (step target cfg).isSome := + neverHaltsFrom_of_reachesStar init_221 (section_nonhalt (entry_unary_in_entryExit 2)) + +theorem is_not_halt_from_0554 : + ∀ cfg : Cfg (Fin 2) (Fin 6), + (((default : ListBlank (Fin 2)) {{5}}> default) [target]⊢* cfg) → + (step target cfg).isSome := + neverHaltsFrom_of_reachesStar init_554 (section_nonhalt (entry_unary_in_entryExit 4)) + +theorem is_not_halt : IsNotHalt target := by + exact neverHaltsFrom_of_reachesStar init_481 (section_nonhalt (entry_unary_in_entryExit 1)) + +end + +end BusyBeaver.M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA diff --git a/BusyBeaver/BB6/NonHalt/M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF.lean b/BusyBeaver/BB6/NonHalt/M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF.lean new file mode 100644 index 00000000..58f0ac4e --- /dev/null +++ b/BusyBeaver/BB6/NonHalt/M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF.lean @@ -0,0 +1,4225 @@ +/- +Copyright (c) 2026 Google LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +-/ +module + +import BusyBeaver.Basic +public import BusyBeaver.Bridge +import BusyBeaver.Calculi.Longitudinal +import BusyBeaver.Calculi.SegCount +import Mathlib.Tactic.Ring +import Mathlib.Tactic.Linarith + +open Mathlib Relation Nat Turing BusyBeaver SixState + +namespace BusyBeaver.M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF + +@[expose] public section + +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF" + +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB + +end + +abbrev target_tm : Machine (Fin 2) (Fin 6) := target + +namespace SegCount + +open BusyBeaver.Longitudinal + +variable {Γ Λ : Type*} [Inhabited Γ] [Inhabited Λ] + +export BusyBeaver.SegCount (runSteps runSteps_spec) + +inductive BDigit where + | BA + | BB + deriving DecidableEq, Repr + +open BDigit + +def digit_word (A8 B8 : List Γ) : BDigit → List Γ + | BA => A8 + | BB => B8 + +def digits_word (A8 B8 : List Γ) : List BDigit → List Γ + | [] => [] + | d :: ds' => digit_word A8 B8 d ++ digits_word A8 B8 ds' + +def digits_value : List BDigit → ℕ + | [] => 0 + | BA :: ds' => 2 * digits_value ds' + | BB :: ds' => 1 + 2 * digits_value ds' + +def bfinish_count : List BDigit → ℕ → ℕ + | [], out => out + | BA :: ds', out => 2 * bfinish_count ds' out + 1 + | BB :: ds', out => 2 * bfinish_count ds' out + +omit [Inhabited Γ] [Inhabited Λ] in +theorem bfinish_repeat_BA_formula (w out : ℕ) : + bfinish_count (List.replicate w BA) out = (out + 1) * 2 ^ w - 1 := by + induction w with + | zero => + simp [bfinish_count] + | succ w ih => + simp only [List.replicate_succ, bfinish_count, ih, Nat.pow_succ] + have hpos : 1 ≤ (out + 1) * 2 ^ w := Nat.mul_pos (by omega) Nat.one_le_two_pow + have hmul : (out + 1) * (2 ^ w * 2) = 2 * ((out + 1) * 2 ^ w) := by ring + omega + +theorem bfinish_spec {M : Machine Γ Λ} {hashes : List (DH0 Γ Λ × DH0 Γ Λ)} {A8 B8 : List Γ} + (hash_A_finish : ∀ k, SegRLs M (hashes ^ (2 * k + 1)) (hashes ^ k) A8 B8) + (hash_B_finish : ∀ k, SegRLs M (hashes ^ (2 * k)) (hashes ^ k) B8 B8) + (ds : List BDigit) (out : ℕ) : + SegRLs M (hashes ^ (bfinish_count ds out)) (hashes ^ out) + (digits_word A8 B8 ds) (B8 ^ ds.length) := by + induction ds generalizing out with + | nil => + exact SegRLs.empty M (hashes ^ out) + | cons d ds ih => + rw [List.length_cons, pow_succ_list B8 ds.length] + rcases d with _ | _ + · exact (hash_A_finish (bfinish_count ds out)).concat (ih out) + · exact (hash_B_finish (bfinish_count ds out)).concat (ih out) + +end SegCount + +section + +open BusyBeaver.SixState BusyBeaver.Longitudinal SegCount + +set_option maxRecDepth 100000 + +-- ============================================================================ +-- 1. Symmetry Reduction (`target_tm` -> `source_tm = SOBCv10.tm` at `default {{D}}> default`) +-- ============================================================================ + +/-- `SOBCv10.tm` (`1LB0RD_1LC0RC_1RA1LC_1LE0RB_1LF---_0LA0LE`). -/ +def source_tm : Machine (Fin 2) (Fin 6) + | 0, 0 => some (some 1, Stmt.write 1 Dir.left) + | 0, 1 => some (some 3, Stmt.write 0 Dir.right) + | 1, 0 => some (some 2, Stmt.write 1 Dir.left) + | 1, 1 => some (some 2, Stmt.write 0 Dir.right) + | 2, 0 => some (some 0, Stmt.write 1 Dir.right) + | 2, 1 => some (some 2, Stmt.write 1 Dir.left) + | 3, 0 => some (some 4, Stmt.write 1 Dir.left) + | 3, 1 => some (some 1, Stmt.write 0 Dir.right) + | 4, 0 => some (some 5, Stmt.write 1 Dir.left) + | 4, 1 => none + | 5, 0 => some (some 0, Stmt.write 0 Dir.left) + | 5, 1 => some (some 4, Stmt.write 0 Dir.left) + +/-- State permutation `phi` mapping `flipTM target_tm` to `source_tm` (`PR_SOBCv10.v` line 2892). -/ +def phi : Fin 6 → Fin 6 + | 0 => 3 + | 1 => 4 + | 2 => 5 + | 3 => 0 + | 4 => 1 + | 5 => 2 + +def mapFlipCfg_12 (c : Cfg (Fin 2) (Fin 6)) : Cfg (Fin 2) (Fin 6) := + ⟨c.q.map phi, ⟨c.tape.head, c.tape.right, c.tape.left⟩⟩ + +theorem step_mapFlipCfg_12 (c : Cfg (Fin 2) (Fin 6)) : + step source_tm (mapFlipCfg_12 c) = (step target_tm c).map mapFlipCfg_12 := by + rcases c with ⟨_ | ⟨_ | _ | _ | _ | _ | _ | q, hq⟩, ⟨⟨_ | _ | h, hh⟩, l, r⟩⟩ <;> + (try rfl) <;> + omega + +theorem multiStep_mapFlipCfg_12 (c : Cfg (Fin 2) (Fin 6)) (n : ℕ) : + multiStep source_tm (mapFlipCfg_12 c) n = (multiStep target_tm c n).map mapFlipCfg_12 := by + induction n generalizing c with + | zero => rfl + | succ n ih => + rw [BusyBeaver.multiStep_succ', BusyBeaver.multiStep_succ', ih] + rcases multiStep target_tm c n with _ | c' + · rfl + · exact step_mapFlipCfg_12 c' + +theorem neverHaltsFrom_of_mapFlipCfg_12 {c₀ : Cfg (Fin 2) (Fin 6)} + (h : NeverHaltsFrom source_tm (mapFlipCfg_12 c₀)) : NeverHaltsFrom target_tm c₀ := by + intro cfg ⟨n, hn⟩ + have hm : (mapFlipCfg_12 c₀) [source_tm]⊢* (mapFlipCfg_12 cfg) := by + refine ⟨n, ?_⟩ + rw [multiStep_mapFlipCfg_12, hn] + rfl + have hstep := h (mapFlipCfg_12 cfg) hm + rcases hst : step target_tm cfg with _ | c' + · rw [step_mapFlipCfg_12, hst] at hstep + cases hstep + · rfl + +theorem neverHaltsFrom_of_reachesStar {M : Machine (Fin 2) (Fin 6)} {c₁ c₀ : Cfg (Fin 2) (Fin 6)} + (hinit : c₁ [M]⊢* c₀) (h_never : NeverHaltsFrom M c₀) : NeverHaltsFrom M c₁ := by + obtain ⟨k₀, hk₀⟩ := hinit + intro cfg ⟨k, hk⟩ + rcases Nat.lt_or_ge k k₀ with hlt | hge + · rcases hstep_cfg : step M cfg with _ | _ + · have hnone : (step M cfg).isNone := by simp [hstep_cfg] + have hnone_k₀ : multiStep M c₁ k₀ = none := by + have hsplit : k₀ = k + (k₀ - k) := by omega + rw [hsplit] + exact multiStep_eq_none_of_isNone hk hnone (by omega) + rw [hnone_k₀] at hk₀ + cases hk₀ + · rfl + · have hsplit : k = k₀ + (k - k₀) := by omega + rw [hsplit, BusyBeaver.multiStep_add, hk₀, Option.bind_some] at hk + exact h_never cfg ⟨k - k₀, hk⟩ + +-- ============================================================================ +-- 2. Bounded Stepping Helpers (`runSteps`, `run_r0inf`, `check_r0inf`) +-- ============================================================================ + +theorem run1Steps_spec (M : Machine (Fin 2) (Fin 6)) (n : ℕ) + (x x' : BoundedConfig.BCfg (Fin 2) (Fin 6)) + (h : runSteps M (n + 1) x = x') (hneq : x ≠ x') (l₀ r₀ : ListBlank (Fin 2)) : + (BoundedConfig.toCfg x l₀ r₀) [M]⊢⁺ (BoundedConfig.toCfg x' l₀ r₀) := by + dsimp [runSteps] at h + rcases hstep : BoundedConfig.step M x with _ | y <;> rw [hstep] at h + · exact False.elim (hneq h) + · exact stepPlus_stepStar_trans ⟨1, by decide, BoundedConfig.step_spec M x hstep l₀ r₀⟩ + (runSteps_spec M n y x' h l₀ r₀) + +def run_r0inf (M : Machine (Fin 2) (Fin 6)) : ℕ → BoundedConfig.BCfg (Fin 2) (Fin 6) → + Option (BoundedConfig.BCfg (Fin 2) (Fin 6)) + | 0, x => some x + | n + 1, x => + match BoundedConfig.step_r0inf M x with + | none => none + | some x' => run_r0inf M n x' + +theorem run_r0inf_spec (M : Machine (Fin 2) (Fin 6)) : + ∀ (n : ℕ) (x x' : BoundedConfig.BCfg (Fin 2) (Fin 6)), + run_r0inf M n x = some x' → + ∀ l₀ : ListBlank (Fin 2), + (BoundedConfig.toCfg x l₀ default) [M]⊢* (BoundedConfig.toCfg x' l₀ default) + | 0, x, x', h, l₀ => by cases h; exact ⟨0, rfl⟩ + | n + 1, x, x', h, l₀ => by + dsimp [run_r0inf] at h + rcases hstep : BoundedConfig.step_r0inf M x with _ | y <;> rw [hstep] at h + · cases h + · exact stepStar_trans ⟨1, BoundedConfig.step_r0inf_spec M x hstep l₀⟩ + (run_r0inf_spec M n y x' h l₀) + +theorem run1_r0inf_spec (M : Machine (Fin 2) (Fin 6)) (n : ℕ) + (x x' : BoundedConfig.BCfg (Fin 2) (Fin 6)) + (h : run_r0inf M (n + 1) x = some x') (l₀ : ListBlank (Fin 2)) : + (BoundedConfig.toCfg x l₀ default) [M]⊢⁺ (BoundedConfig.toCfg x' l₀ default) := by + dsimp [run_r0inf] at h + rcases hstep : BoundedConfig.step_r0inf M x with _ | y <;> rw [hstep] at h + · cases h + · exact stepPlus_stepStar_trans ⟨1, by decide, BoundedConfig.step_r0inf_spec M x hstep l₀⟩ + (run_r0inf_spec M n y x' h l₀) + +def check_r0inf (M : Machine (Fin 2) (Fin 6)) (n : ℕ) + (l₁ r₁ l₂ r₂ : List (Fin 2)) (q₁ q₂ : Fin 6) (d₁ d₂ : Dir) : Bool := + match run_r0inf M (n + 1) ⟨l₁, r₁, q₁, d₁⟩ with + | some ⟨l', r', q', .right⟩ => + (d₂ == .right) && (q' == q₂) && (l' == l₂) && BoundedConfig.eqAppR0inf r' r₂ + | some ⟨l', r', q', .left⟩ => + (d₂ == .left) && (q' == q₂) && (r' == r₂) && BoundedConfig.eqAppR0inf l' l₂ + | none => false + +theorem check_r0inf_spec {M : Machine (Fin 2) (Fin 6)} {n : ℕ} + {l₁ r₁ l₂ r₂ : List (Fin 2)} {q₁ q₂ : Fin 6} {d₁ d₂ : Dir} + (h : check_r0inf M n l₁ r₁ l₂ r₂ q₁ q₂ d₁ d₂ = true) (l₀ : ListBlank (Fin 2)) : + (BoundedConfig.toCfg ⟨l₁, r₁, q₁, d₁⟩ l₀ default) [M]⊢⁺ + (BoundedConfig.toCfg ⟨l₂, r₂, q₂, d₂⟩ l₀ default) := by + dsimp [check_r0inf] at h + rcases hstep : run_r0inf M (n + 1) ⟨l₁, r₁, q₁, d₁⟩ with _ | ⟨l', r', q', _ | _⟩ <;> + rw [hstep] at h + · cases h + · simp only [Bool.and_eq_true, beq_iff_eq] at h + rcases h with ⟨⟨⟨hd, hq⟩, hr⟩, hl⟩ + subst hd hq hr + have hrun := run1_r0inf_spec M n ⟨l₁, r₁, q₁, d₁⟩ _ hstep l₀ + have hl_eq := BoundedConfig.eqAppR0inf_spec hl + simpa only [BoundedConfig.toCfg, hl_eq] using hrun + · simp only [Bool.and_eq_true, beq_iff_eq] at h + rcases h with ⟨⟨⟨hd, hq⟩, hl⟩, hr⟩ + subst hd hq hl + have hrun := run1_r0inf_spec M n ⟨l₁, r₁, q₁, d₁⟩ _ hstep l₀ + have hr_eq := BoundedConfig.eqAppR0inf_spec hr + simpa only [BoundedConfig.toCfg, hr_eq] using hrun + +-- ============================================================================ +-- 3. `SOBCv10` Words, Boundary Signals & Core Rules (`sobc_needed.v`) +-- ============================================================================ + +abbrev U : List (Fin 2) := [1, 0, 1, 1] +abbrev A8 : List (Fin 2) := [1, 1, 1, 1, 1, 0, 1, 1] +abbrev B8 : List (Fin 2) := [1, 1, 1, 0, 1, 1, 1, 1] +abbrev C8 : List (Fin 2) := [1, 1, 1, 1, 1, 1, 1, 0] +abbrev D8 : List (Fin 2) := [1, 1, 1, 0, 1, 1, 1, 0] +abbrev E8 : List (Fin 2) := [1, 1, 1, 1, 1, 0, 1, 0] + +abbrev hash : DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6) := ((B, []), (F, [])) +abbrev hashes : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6)) := [hash] + +theorem hash_U : SegRLs source_tm hashes hashes U U := + BoundedConfig.segRLs_c_spec source_tm (T := 100) (by decide) + +theorem hash_A : SegRLs source_tm hashes [] A8 B8 := + BoundedConfig.segRLs_c_spec source_tm (T := 100) (by decide) + +theorem hash_B : SegRLs source_tm hashes hashes B8 A8 := + BoundedConfig.segRLs_c_spec source_tm (T := 100) (by decide) + +theorem hash_CAUU : SegRLs source_tm hashes [] (C8 ++ A8 ++ U ++ U) (D8 ++ C8 ++ A8) := + BoundedConfig.segRLs_c_spec source_tm (T := 200) (by decide) + +theorem hash_E : SegRLs source_tm hashes [] E8 D8 := + BoundedConfig.segRLs_c_spec source_tm (T := 100) (by decide) + +theorem hash_D : SegRLs source_tm hashes [] D8 A8 := + BoundedConfig.segRLs_c_spec source_tm (T := 100) (by decide) + + +open SegCount.BDigit + +theorem hash_A_cycle : SegRLs source_tm (hashes ^ 2) hashes A8 A8 := + hash_A.trans hash_B + +theorem hash_B_cycle : SegRLs source_tm (hashes ^ 2) hashes B8 B8 := + hash_B.trans hash_A + +theorem hash_A_finish (k : ℕ) : + SegRLs source_tm (hashes ^ (2 * k + 1)) (hashes ^ k) A8 B8 := by + have h := SegRLs.addmul_v2 (x := k) (a := 2) (a' := 1) (b := 1) (b' := 0) hash_A hash_B_cycle + simpa only [Nat.mul_comm k 2, Nat.mul_one, Nat.add_zero] using h + +theorem hash_B_finish (k : ℕ) : + SegRLs source_tm (hashes ^ (2 * k)) (hashes ^ k) B8 B8 := by + have h := SegRLs.addmul_v2 (x := k) (a := 2) (a' := 1) (b := 0) (b' := 0) (.nil B8) hash_B_cycle + simpa only [Nat.mul_comm k 2, Nat.mul_one, Nat.add_zero] using h + +theorem hash_A_cycles (k : ℕ) : + SegRLs source_tm (hashes ^ (2 * k)) (hashes ^ k) A8 A8 := by + have h := SegRLs.addmul_v2 (x := k) (a := 2) (a' := 1) (b := 0) (b' := 0) (.nil A8) hash_A_cycle + simpa only [Nat.mul_comm k 2, Nat.mul_one, Nat.add_zero] using h + +theorem hash_E_even (n : ℕ) : + SegRLs source_tm (hashes ^ (2 * n + 2)) (hashes ^ n) E8 A8 := by + rw [show 2 * n + 2 = 1 + (1 + 2 * n) by omega, + pow_add_list hashes 1, pow_add_list hashes 1, pow_one_list] + simpa only [List.nil_append] using hash_E.trans (hash_D.trans (hash_A_cycles n)) + +theorem hash_E_odd (n : ℕ) : + SegRLs source_tm (hashes ^ (2 * n + 3)) (hashes ^ n) E8 B8 := by + rw [show 2 * n + 3 = 1 + (1 + (2 * n + 1)) by omega, + pow_add_list hashes 1, pow_add_list hashes 1, pow_one_list] + simpa only [List.nil_append] using hash_E.trans (hash_D.trans (hash_A_finish n)) + +theorem hashes_U (n : ℕ) : SegRLs source_tm (hashes ^ n) (hashes ^ n) U U := + SegRLs.wall_pow hash_U n + +theorem hashes_U_run (signals width : ℕ) : + SegRLs source_tm (hashes ^ signals) (hashes ^ signals) (U ^ width) (U ^ width) := by + induction width with + | zero => exact SegRLs.empty source_tm (hashes ^ signals) + | succ width ih => + rw [pow_succ_list] + exact (hashes_U signals).concat ih + +theorem segRLs_0inf {hs : List (DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6))} + {input output : List (Fin 2)} + (h : SegRLs source_tm hs [] input output) : + SideRLs source_tm hs (input +> default) (output +> default) := + h.sideRLs_concat (.nil default) + +def Q8 : List (Fin 2) := [0, 0, 1, 0, 0, 1, 0, 1] + +def common_left_wall : ListBlank (Fin 2) := Q8 +> default + +-- Helper 1D scan lemmas for `sobc1_hash_CAB1110` and `fossil_scan` +def W_C : List (Fin 2) := [0, 0, 0, 1, 0, 0, 1] +def W_A : List (Fin 2) := [0, 0, 1, 0, 1, 0, 0, 1] + +theorem scan_C8_fwd (l r : ListBlank (Fin 2)) : + (l {{B}}> (C8 +> r)) [source_tm]⊢⁺ (([1] +> (W_C +> l)) {{A}}> r) := by + have h := + run1Steps_spec source_tm 11 ⟨[], C8, B, .right⟩ ⟨[1] ++ W_C, [], A, + .right⟩ (by decide) (by decide) l r + simpa only [BoundedConfig.toCfg, append_nil, append_assoc] using h + +theorem scan_A8_fwd_one (l r : ListBlank (Fin 2)) : + (([1] +> l) {{A}}> (A8 +> ([1] +> r))) [source_tm]⊢* + (([1] +> (W_A +> l)) {{A}}> ([1] +> r)) := by + have h := + runSteps_spec source_tm 14 ⟨[1], A8 ++ [1], A, .right⟩ ⟨[1] ++ W_A, [1], A, + .right⟩ (by decide) l r + simpa only [BoundedConfig.toCfg, append_nil, append_assoc] using h + +theorem scan_A8_fwd_pow (k : ℕ) (l r : ListBlank (Fin 2)) : + (([1] +> l) {{A}}> ((A8 ^ k) +> ([1] +> r))) [source_tm]⊢* + (([1] +> ((W_A ^ k) +> l)) {{A}}> ([1] +> r)) := by + induction k generalizing l r with + | zero => + simp only [pow_zero_list, append_nil] + exact stepStar_refl source_tm _ + | succ k ih => + rw [pow_succ_list' A8 k, append_assoc] + have ha : (A8 +> ([1] +> r)) = ([1] +> (([1, 1, 1, 1, 0, 1, 1] ++ [1]) +> r)) := rfl + rw [ha] + refine stepStar_trans (ih l (([1, 1, 1, 1, 0, 1, 1] ++ [1]) +> r)) ?_ + rw [← ha] + have h1 := scan_A8_fwd_one (W_A ^ k +> l) r + simpa only [pow_succ_list W_A k, append_assoc] using h1 + +theorem scan_A8_ret_one (l r : ListBlank (Fin 2)) : + (([1] +> (W_A +> l)) <{{F}} r) [source_tm]⊢* + (([1] +> l) <{{F}} (C8 +> r)) := by + have h := + runSteps_spec source_tm 18 ⟨[], [1] ++ W_A, F, .left⟩ ⟨C8, [1], F, .left⟩ (by decide) l r + simpa only [BoundedConfig.toCfg, append_nil, append_assoc] using h + +theorem scan_A8_ret_pow (k : ℕ) (l r : ListBlank (Fin 2)) : + (([1] +> ((W_A ^ k) +> l)) <{{F}} r) [source_tm]⊢* + (([1] +> l) <{{F}} ((C8 ^ k) +> r)) := by + induction k generalizing r with + | zero => + simp only [pow_zero_list, append_nil] + exact stepStar_refl source_tm _ + | succ k ih => + rw [pow_succ_list, append_assoc] + refine stepStar_trans (scan_A8_ret_one _ r) ?_ + have hrec := ih (C8 +> r) + simpa only [pow_succ_list', append_assoc] using hrec + +theorem scan_C8_ret (l r : ListBlank (Fin 2)) : + (([1] +> (W_C +> l)) <{{F}} r) [source_tm]⊢* + (l <{{F}} (D8 +> r)) := by + have h := runSteps_spec source_tm 16 ⟨[], [1] ++ W_C, F, .left⟩ ⟨D8, [], F, .left⟩ (by decide) l r + simpa only [BoundedConfig.toCfg, append_nil, append_assoc] using h + +theorem sobc1_hash_CAB1110 (k : ℕ) : + SegRLs source_tm hashes [] + (C8 ++ A8 ^ k ++ B8 ++ [1, 1, 1, 0]) + (D8 ++ C8 ^ k ++ B8 ++ U) := by + refine .cons (fun l r => ?_) (.nil _) + simp only [toDHCfg, List.append_assoc, append_assoc, append_nil] + refine stepPlus_stepStar_trans (scan_C8_fwd l _) ?_ + have hturn : (∀ l', (([1] +> l') {{A}}> (B8 +> ([1, 1, 1, 0] +> r))) [source_tm]⊢* + (([1] +> l') <{{F}} ((B8 ++ U) +> r))) := by + intro l' + have h := + runSteps_spec source_tm 41 ⟨[1], B8 ++ [1, 1, 1, 0], A, .right⟩ ⟨B8 ++ U, [1], F, + .left⟩ (by decide) l' r + simpa only [BoundedConfig.toCfg, List.append_assoc, append_assoc, append_nil] using h + have hb : (B8 +> ([1, 1, 1, 0] +> r)) = ([1] +> ([1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0] +> r)) := rfl + rw [hb] + refine stepStar_trans (scan_A8_fwd_pow k (W_C +> l) ([1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0] +> r)) ?_ + rw [← hb] + refine stepStar_trans (hturn _) ?_ + refine stepStar_trans (scan_A8_ret_pow k (W_C +> l) ((B8 ++ U) +> r)) ?_ + simpa only [append_assoc] using scan_C8_ret l ((C8 ^ k) +> (B8 +> (U +> r))) + +def pow2 (k : ℕ) : ℤ := (2 : ℤ) ^ k + +theorem pow2_pos (k : ℕ) : 0 < pow2 k := by + unfold pow2; positivity + +theorem pow2_succ (k : ℕ) : pow2 (k + 1) = 2 * pow2 k := by + unfold pow2; ring + +theorem pow2_Zpow (k : ℕ) : pow2 k = (2 : ℤ) ^ k := rfl + +theorem pow2_nat (k : ℕ) : pow2 k = ((2 ^ k : ℕ) : ℤ) := by + unfold pow2; simp + +def initial_u_pair_calls (primary : ℕ) : ℕ → ℕ + | 0 => 0 + | pairs' + 1 => 2 * 2 ^ primary + initial_u_pair_calls (primary + 1) pairs' + +theorem standard_mixed_to_binary_out_spec (e : ℕ) (ds : List BDigit) (out : ℕ) + (hlen : ds.length = e + 1) : + SegRLs source_tm + (hashes ^ ((out + 1) * 2 ^ (e + 1) - 2 + digits_value ds)) + (hashes ^ out) + (E8 ^ e ++ A8) + ((digits_word A8 B8) ds) := by + induction e generalizing ds out with + | zero => + rcases ds with _ | ⟨d, _ | _⟩ + · cases hlen + · rcases d with _ | _ + · have heq : (out + 1) * 2 ^ 1 - 2 + digits_value [BA] = 2 * out := by + dsimp [digits_value]; omega + rw [heq] + simpa [digits_word, digit_word] using hash_A_cycles out + · have heq : (out + 1) * 2 ^ 1 - 2 + digits_value [BB] = 2 * out + 1 := by + dsimp [digits_value]; omega + rw [heq] + simpa [digits_word, digit_word] using hash_A_finish out + · cases hlen + | succ e ih => + rcases ds with _ | ⟨d, ds⟩ + · cases hlen + · have htail : ds.length = e + 1 := by simp at hlen; omega + have hrun := ih ds out htail + have hpow : 2 ≤ 2 ^ (e + 1) := by + have : 1 ≤ 2 ^ e := Nat.one_le_two_pow + rw [Nat.pow_succ] + omega + have hge2 : 2 ≤ (out + 1) * 2 ^ (e + 1) := by nlinarith + rcases d with _ | _ + · rw [pow_succ_list E8 e, List.append_assoc] + have heq : (out + 1) * 2 ^ (e + 1 + 1) - 2 + digits_value (BA :: ds) = + 2 * ((out + 1) * 2 ^ (e + 1) - 2 + digits_value ds) + 2 := by + dsimp [digits_value] + rw [Nat.pow_succ] + have hmul : (out + 1) * (2 ^ (e + 1) * 2) = 2 * ((out + 1) * 2 ^ (e + 1)) := by ring + omega + rw [heq] + exact (hash_E_even _).concat hrun + · rw [pow_succ_list E8 e, List.append_assoc] + have heq : (out + 1) * 2 ^ (e + 1 + 1) - 2 + digits_value (BB :: ds) = + 2 * ((out + 1) * 2 ^ (e + 1) - 2 + digits_value ds) + 3 := by + dsimp [digits_value] + rw [Nat.pow_succ] + have hmul : (out + 1) * (2 ^ (e + 1) * 2) = 2 * ((out + 1) * 2 ^ (e + 1)) := by ring + omega + rw [heq] + exact (hash_E_odd _).concat hrun + +theorem prefix_E_even (k n : ℕ) (input output : List (Fin 2)) (carries : ℕ) + (hrun : SegRLs source_tm (hashes ^ n) (hashes ^ carries) input output) : + SegRLs source_tm (hashes ^ (2 ^ k * n + 2 * (2 ^ k - 1))) (hashes ^ carries) + (E8 ^ k ++ input) (A8 ^ k ++ output) := by + induction k with + | zero => + simpa using hrun + | succ k ih => + rw [pow_succ_list, pow_succ_list, List.append_assoc, List.append_assoc] + have h1 := (hash_E_even (2 ^ k * n + 2 * (2 ^ k - 1))).concat ih + have heq : 2 * (2 ^ k * n + 2 * (2 ^ k - 1)) + 2 = 2 ^ (k + 1) * n + 2 * (2 ^ (k + 1) - 1) := by + have : 1 ≤ 2 ^ k := Nat.one_le_two_pow + rw [Nat.pow_succ] + have hmul : (2 ^ k * 2) * n = 2 * (2 ^ k * n) := by ring + omega + rwa [heq] at h1 + +abbrev X4 : List (Fin 2) := [0, 0, 1, 0] +abbrev V4 : List (Fin 2) := [0, 1, 0, 0] + +def exception_pre_left (n : ℕ) : ListBlank (Fin 2) := + ([1, 0, 1, 0] ++ V4 ^ (2 * n + 2) ++ [1, 0, 1]) +> default + +def exception_call_left (remaining finished : ℕ) : ListBlank (Fin 2) := + (X4 ^ (2 * finished + 5) ++ V4 ^ (2 * remaining) ++ [1, 0, 1]) +> default + +theorem raw_U_to_X : SegRR source_tm (B, []) (B, []) U X4 := by + intro l r + have h := runSteps_spec source_tm 4 ⟨[], U, B, .right⟩ ⟨X4, [], B, .right⟩ (by decide) l r + simpa only [BoundedConfig.toCfg, toDHCfg, append_nil] using h + +theorem segRR_lpow_same (h : DH0 (Fin 2) (Fin 6)) (w v : List (Fin 2)) (k : ℕ) + (hstep : SegRR source_tm h h w v) : + SegRR source_tm h h (w ^ k) (v ^ k) := by + induction k with + | zero => + intro l r + simp only [pow_zero_list, append_nil] + exact stepStar_refl source_tm _ + | succ k ih => + intro l r + rw [pow_succ_list, append_assoc] + refine stepStar_trans (hstep l ((w ^ k) +> r)) ?_ + have hrec := ih (v +> l) r + simpa only [pow_succ_list', append_assoc] using hrec + +theorem raw_Us_to_Xs (k : ℕ) : SegRR source_tm (B, []) (B, []) (U ^ k) (X4 ^ k) := + segRR_lpow_same (B, []) U X4 k raw_U_to_X + +theorem raw_B_forward : SegRR source_tm (B, []) (B, []) B8 Q8 := by + intro l r + have h := runSteps_spec source_tm 14 ⟨[], B8, B, .right⟩ ⟨Q8, [], B, .right⟩ (by decide) l r + simpa only [BoundedConfig.toCfg, toDHCfg, append_nil] using h + +theorem raw_B_return (l r : ListBlank (Fin 2)) : + (([1, 0, 1] +> (Q8 +> l)) <{{F}} r) [source_tm]⊢⁺ + (([1, 0, 1] +> l) <{{F}} (E8 +> r)) := by + have h := + run1Steps_spec source_tm 15 ⟨[], [1, 0, 1] ++ Q8, F, .left⟩ ⟨E8, [1, 0, 1], F, + .left⟩ (by decide) (by decide) l r + simpa only [BoundedConfig.toCfg, append_nil, append_assoc] using h + +private theorem x4_pow_zero_shift (k : ℕ) : + X4 ^ k ++ [0] = [0] ++ V4 ^ k := by + induction k with + | zero => rfl + | succ k ih => + rw [pow_succ_list, List.append_assoc, ih, ← List.append_assoc X4 [0], + show X4 ++ [0] = [0] ++ V4 from rfl, List.append_assoc, ← pow_succ_list V4 k] + +theorem exception_pre_left_direct (n : ℕ) : + ([1, 0, 1] +> (X4 ^ (2 * n + 1) +> (Q8 +> default))) = exception_pre_left n := by + unfold exception_pre_left + rw [← append_assoc, ← append_assoc] + congr 1 + have hq : Q8 = [0] ++ (V4 ++ [1, 0, 1]) := rfl + calc [1, 0, 1] ++ (X4 ^ (2 * n + 1) ++ Q8) + = [1, 0, 1] ++ ((X4 ^ (2 * n + 1) ++ [0]) ++ (V4 ++ [1, 0, 1])) := by + rw [hq, List.append_assoc (X4 ^ (2 * n + 1))] + _ = [1, 0, 1] ++ (([0] ++ V4 ^ (2 * n + 1)) ++ (V4 ++ [1, 0, 1])) := by + rw [x4_pow_zero_shift] + _ = [1, 0, 1, 0] ++ (V4 ^ (2 * n + 1) ++ V4) ++ [1, 0, 1] := by + simp only [List.append_assoc]; rfl + _ = [1, 0, 1, 0] ++ V4 ^ (2 * n + 2) ++ [1, 0, 1] := by + rw [← pow_succ_list' V4 (2 * n + 1), show 2 * n + 1 + 1 = 2 * n + 2 by omega] + +abbrev left_hash : DH0 (Fin 2) (Fin 6) × DH0 (Fin 2) (Fin 6) := ((F, []), (B, [])) + +theorem left_hash_XX : + SegRLs (flipTM source_tm) [left_hash] [left_hash] (X4 ^ 2) (X4 ^ 2) := + BoundedConfig.segRLs_c_spec (flipTM source_tm) (T := 200) (by decide) + +theorem left_relaunch_base : + SegRLs (flipTM source_tm) [left_hash] [] (X4 ^ 5 ++ V4 ^ 2) (X4 ^ 7) := + BoundedConfig.segRLs_c_spec (flipTM source_tm) (T := 500) (by decide) + +theorem left_hash_X_pairs (k : ℕ) : + SegRLs (flipTM source_tm) [left_hash] [left_hash] (X4 ^ (2 * k)) (X4 ^ (2 * k)) := by + induction k with + | zero => exact SegRLs.empty (flipTM source_tm) [left_hash] + | succ k ih => + rw [show 2 * (k + 1) = 2 * k + 2 by omega, pow_add_list] + exact ih.concat left_hash_XX + +theorem left_launch_segment : + SegRLs (flipTM source_tm) [left_hash] [] ([1, 0, 1, 0] ++ V4 ^ 4) (X4 ^ 5) := + BoundedConfig.segRLs_c_spec (flipTM source_tm) (T := 500) (by decide) + +theorem exception_launch (k : ℕ) : + SideRLs (flipTM source_tm) [left_hash] + (exception_pre_left (k + 1)) (exception_call_left k 0) := by + unfold exception_pre_left exception_call_left + rw [show 2 * (k + 1) + 2 = 4 + 2 * k by omega, pow_add_list] + have h := left_launch_segment.sideRLs_concat + (SideRLs.nil (M := flipTM source_tm) ((V4 ^ (2 * k) ++ [1, 0, 1]) +> default)) + simpa only [Nat.mul_zero, Nat.zero_add, List.append_assoc, append_assoc] using h + +theorem exception_relaunch_side (remaining finished : ℕ) : + SideRLs (flipTM source_tm) [left_hash] + (exception_call_left (remaining + 1) finished) + (exception_call_left remaining (finished + 1)) := by + have hseg := (left_hash_X_pairs finished).concat left_relaunch_base + have hside := hseg.sideRLs_concat + (SideRLs.nil (M := flipTM source_tm) ((V4 ^ (2 * remaining) ++ [1, 0, 1]) +> default)) + unfold exception_call_left + rw [show 2 * (remaining + 1) = 2 + 2 * remaining by omega, + show 2 * (finished + 1) + 5 = 2 * finished + 7 by omega, + pow_add_list V4 2 (2 * remaining), + pow_add_list X4 (2 * finished) 5, + pow_add_list X4 (2 * finished) 7] + simpa only [List.append_assoc, append_assoc] using hside + +theorem exception_relaunches (k finished : ℕ) : + SideRLs (flipTM source_tm) ([left_hash] ^ k) + (exception_call_left k finished) + (exception_call_left 0 (finished + k)) := by + induction k generalizing finished with + | zero => + simp only [pow_zero_list, Nat.add_zero] + exact .nil _ + | succ k ih => + rw [pow_succ_list] + have h := (exception_relaunch_side k finished).trans (ih (finished + 1)) + simpa only [Nat.add_right_comm finished 1 k, Nat.add_assoc] using h + +theorem exception_calls (k : ℕ) (input output : List (Fin 2)) + (hseg : SegRLs source_tm (hashes ^ (k + 1)) [] input output) : + ((exception_call_left k 0) {{B}}> (input +> default)) [source_tm]⊢⁺ + ((exception_call_left 0 k) <{{F}} (output +> default)) := by + have hright : SideRLs source_tm (lrcons (B, []) ([left_hash] ^ k) (F, [])) + (input +> default) (output +> default) := by + rw [lrcons_same] + exact segRLs_0inf hseg + have hleft : SideRLs (flipTM source_tm) ([left_hash] ^ k) + (exception_call_left k 0) (exception_call_left 0 k) := by + simpa only [Nat.zero_add] using exception_relaunches k 0 + exact SideRLs.concat hleft hright + +def exception_done (n : ℕ) (output : List (Fin 2)) : Cfg (Fin 2) (Fin 6) := + common_left_wall {{B}}> ((C8 ++ A8 ++ U ^ (2 * n) ++ output) +> default) + +theorem raw_XX_return (l r : ListBlank (Fin 2)) : + ((X4 ^ 2 +> l) <{{F}} r) [source_tm]⊢* (l <{{F}} (U ^ 2 +> r)) := by + have h := runSteps_spec source_tm 20 ⟨[], X4 ^ 2, F, .left⟩ ⟨U ^ 2, [], F, .left⟩ (by decide) l r + simpa only [BoundedConfig.toCfg, append_nil] using h + +theorem raw_XX_returns (k : ℕ) (l r : ListBlank (Fin 2)) : + ((X4 ^ (2 * k) +> l) <{{F}} r) [source_tm]⊢* (l <{{F}} (U ^ (2 * k) +> r)) := by + induction k generalizing r with + | zero => + simp only [Nat.mul_zero, pow_zero_list, append_nil] + exact stepStar_refl source_tm _ + | succ k ih => + rw [show 2 * (k + 1) = 2 + 2 * k by omega, pow_add_list X4 2 (2 * k), append_assoc] + refine stepStar_trans (raw_XX_return _ r) ?_ + have hrec := ih (U ^ 2 +> r) + rw [show 2 + 2 * k = 2 * k + 2 by omega, pow_add_list U (2 * k) 2, append_assoc] + exact hrec + +theorem exception_exit_base (r : ListBlank (Fin 2)) : + (((X4 ^ 5 ++ [1, 0, 1]) +> default) <{{F}} r) [source_tm]⊢⁺ + (common_left_wall {{B}}> ((C8 ++ A8 ++ U ^ 2) +> r)) := by + have h0 : (([0] : List (Fin 2)) ^ 9 +> (default : ListBlank (Fin 2))) = default := + BoundedConfig.all0_spec (a := ([0] : List (Fin 2)) ^ 9) (by decide) + have h := run1Steps_spec source_tm 118 + ⟨[], X4 ^ 5 ++ [1, 0, 1] ++ ([0] : List (Fin 2)) ^ 9, F, .left⟩ + ⟨Q8, C8 ++ A8 ++ U ^ 2, B, .right⟩ + (by decide) (by decide) default r + simpa only [BoundedConfig.toCfg, common_left_wall, List.append_assoc, append_assoc, h0, + append_nil] using h + +theorem exception_exit (k : ℕ) (output : List (Fin 2)) : + ((exception_call_left 0 k) <{{F}} (output +> default)) [source_tm]⊢⁺ + exception_done (k + 1) output := by + unfold exception_call_left exception_done + rw [Nat.mul_zero, pow_zero_list, List.append_nil, pow_add_list X4 (2 * k) 5, + List.append_assoc, append_assoc] + refine stepStar_stepPlus_trans (raw_XX_returns k ((X4 ^ 5 ++ [1, 0, + 1]) +> default) (output +> default)) ?_ + have hbase := exception_exit_base (U ^ (2 * k) +> (output +> default)) + rw [show 2 * (k + 1) = 2 + 2 * k by omega, pow_add_list U 2 (2 * k)] + simpa only [List.append_assoc, append_assoc] using hbase + +theorem exception_launch_progress (k : ℕ) (r : ListBlank (Fin 2)) : + ((exception_pre_left (k + 1)) <{{F}} r) [source_tm]⊢⁺ + ((exception_call_left k 0) {{B}}> r) := + (exception_launch k).elim_single_left r + +theorem exception_exit_zero (output : List (Fin 2)) : + ((exception_pre_left 0) <{{F}} (output +> default)) [source_tm]⊢⁺ + exception_done 0 output := by + unfold exception_pre_left exception_done + have h0 : (([0] : List (Fin 2)) ^ 9 +> (default : ListBlank (Fin 2))) = default := + BoundedConfig.all0_spec (a := ([0] : List (Fin 2)) ^ 9) (by decide) + have h := run1Steps_spec source_tm 114 + ⟨[], [1, 0, 1, 0] ++ V4 ^ 2 ++ [1, 0, 1] ++ ([0] : List (Fin 2)) ^ 9, F, .left⟩ + ⟨Q8, C8 ++ A8, B, .right⟩ + (by decide) (by decide) default (output +> default) + simpa only [BoundedConfig.toCfg, common_left_wall, Nat.mul_zero, Nat.zero_add, pow_zero_list, + List.append_nil, List.append_assoc, append_assoc, append_nil, h0] using h + +theorem exception_pre_from_seg (n : ℕ) (input output : List (Fin 2)) + (hseg : SegRLs source_tm (hashes ^ n) [] input output) : + ((exception_pre_left n) <{{F}} (input +> default)) [source_tm]⊢⁺ + exception_done n output := by + rcases n with _ | k + · cases hseg + exact exception_exit_zero _ + · exact stepPlus_trans (exception_launch_progress k (input +> default)) + (stepPlus_trans (exception_calls k input output hseg) (exception_exit k output)) + +-- Residue & LineagePhase calculus (`sobc_needed.v` lines 499–770) +def even_residue : ℕ → ℤ + | 0 => 3 + | n' + 1 => 4 * even_residue n' + 1 + +def odd_residue : ℕ → ℤ + | 0 => 26 + | n' + 1 => 4 * odd_residue n' - 2 + +def even_residue_width (n : ℕ) : ℕ := 2 * n + 4 +def odd_residue_width (n : ℕ) : ℕ := 2 * n + 5 + +theorem even_residue_bounds (n : ℕ) : + 3 ≤ even_residue n ∧ even_residue n ≤ pow2 (even_residue_width n) - 6 := by + induction n with + | zero => + dsimp [even_residue, even_residue_width, pow2] + omega + | succ n ih => + dsimp [even_residue, even_residue_width] at ih ⊢ + rw [show 2 * (n + 1) + 4 = (2 * n + 4) + 1 + 1 by omega, pow2_succ, pow2_succ] + omega + +theorem even_residue_S_lower (n : ℕ) : 13 ≤ even_residue (n + 1) := by + have := even_residue_bounds n + dsimp [even_residue] + omega + +theorem odd_residue_bounds (n : ℕ) : + 3 ≤ odd_residue n ∧ odd_residue n ≤ pow2 (odd_residue_width n) - 6 := by + induction n with + | zero => + dsimp [odd_residue, odd_residue_width, pow2] + omega + | succ n ih => + dsimp [odd_residue, odd_residue_width] at ih ⊢ + rw [show 2 * (n + 1) + 5 = (2 * n + 5) + 1 + 1 by omega, pow2_succ, pow2_succ] + omega + +theorem odd_residue_complement (n : ℕ) : + odd_residue n = 2 * (pow2 (even_residue_width n) - even_residue n) := by + induction n with + | zero => + dsimp [odd_residue, even_residue, even_residue_width, pow2] + | succ n ih => + dsimp [odd_residue, even_residue, even_residue_width] at ih ⊢ + rw [show 2 * (n + 1) + 4 = (2 * n + 4) + 1 + 1 by omega, pow2_succ, pow2_succ] + omega + +theorem even_residue_complement (n : ℕ) : + even_residue (n + 1) = 2 * (pow2 (odd_residue_width n) - odd_residue n) + 1 := by + have hodd := odd_residue_complement n + dsimp [even_residue, odd_residue_width, even_residue_width] at hodd ⊢ + rw [show 2 * n + 5 = (2 * n + 4) + 1 by omega, pow2_succ] + omega + +theorem low_step_odd_to_even (n : ℕ) : + pow2 (even_residue_width n) - odd_residue n / 2 = even_residue n := by + rw [odd_residue_complement] + omega + +theorem low_step_even_to_odd (n : ℕ) : + pow2 (odd_residue_width n) - even_residue (n + 1) / 2 = odd_residue n := by + rw [even_residue_complement] + omega + +def z_birth_value (n : ℕ) : ℤ := + 2 * (pow2 (even_residue_width (n + 1)) - even_residue (n + 1)) + 1 + +def z_birth_width (n : ℕ) : ℕ := 2 * n + 7 + +theorem z_birth_complement (n : ℕ) : + z_birth_value n = 2 * (pow2 (even_residue_width (n + 1)) - even_residue (n + 1)) + 1 := rfl + +theorem z_birth_succ (n : ℕ) : + z_birth_value (n + 1) = 4 * z_birth_value n - 5 := by + unfold z_birth_value even_residue_width + dsimp [even_residue] + rw [show 2 * (n + 1 + 1) + 4 = (2 * (n + 1) + 4) + 1 + 1 by omega, pow2_succ, pow2_succ] + omega + +theorem z_birth_bounds (n : ℕ) : + 3 ≤ z_birth_value n ∧ z_birth_value n ≤ pow2 (z_birth_width n) - 6 := by + have he := even_residue_bounds (n + 1) + have he13 := even_residue_S_lower n + unfold z_birth_value z_birth_width even_residue_width at * + rw [show 2 * n + 7 = (2 * (n + 1) + 4) + 1 by omega, pow2_succ (2 * (n + 1) + 4)] + omega + +theorem z_birth_first_low_step (n : ℕ) : + pow2 (even_residue_width (n + 1)) - z_birth_value n / 2 = even_residue (n + 1) := by + rw [z_birth_complement] + omega + +def low_slice (total : ℤ) (m : ℕ) (r v : ℤ) : Prop := + ∃ high capacity : ℤ, + total = capacity * pow2 m ∧ + v = high * pow2 m + r ∧ + 0 ≤ high ∧ high < capacity + +theorem low_slice_safe (total : ℤ) (m : ℕ) (r v : ℤ) + (hslice : low_slice total m r v) + (hr : 3 ≤ r ∧ r ≤ pow2 m - 6) : + 3 ≤ v ∧ v ≤ total - 6 := by + rcases hslice with ⟨high, capacity, htotal, hv, hhigh0, hhigh1⟩ + have hpos := pow2_pos m + have hle : high + 1 ≤ capacity := by omega + have hmul1 : 0 ≤ high * pow2 m := mul_nonneg hhigh0 (le_of_lt hpos) + have hmul2 : (high + 1) * pow2 m ≤ capacity * pow2 m := + mul_le_mul_of_nonneg_right hle (le_of_lt hpos) + constructor <;> linarith + +theorem low_slice_step (total : ℤ) (m : ℕ) (r v : ℤ) (right_odd : Bool) + (hslice : low_slice total (m + 1) r v) + (hr : 3 ≤ r ∧ r < pow2 (m + 1)) : + low_slice total m (pow2 m - r / 2) + ((if right_odd then total / 2 else total) - v / 2) := by + rcases hslice with ⟨high, capacity, htotal, hv, hhigh0, hhigh1⟩ + rw [pow2_succ] at htotal hv hr + have hpos := pow2_pos m + have htotal_half : total / 2 = capacity * pow2 m := by + rw [htotal, show capacity * (2 * pow2 m) = (capacity * pow2 m) * 2 by ring, + Int.mul_ediv_cancel _ (by decide)] + have hv_half : v / 2 = high * pow2 m + r / 2 := by + rw [hv, show high * (2 * pow2 m) + r = r + (high * pow2 m) * 2 by ring, + Int.add_mul_ediv_right _ _ (by decide)] + ring + have hrhalf : 1 ≤ r / 2 ∧ r / 2 < pow2 m := by omega + rcases right_odd with _ | _ + · dsimp + refine ⟨2 * capacity - high - 1, 2 * capacity, ?_, ?_, ?_, ?_⟩ + · linarith + · rw [htotal, hv_half]; ring + · omega + · omega + · dsimp + refine ⟨capacity - high - 1, 2 * capacity, ?_, ?_, ?_, ?_⟩ + · linarith + · rw [htotal_half, hv_half]; ring + · omega + · omega + +theorem z_birth_low_slice (n : ℕ) : + low_slice (pow2 (z_birth_width n)) (z_birth_width n) + (z_birth_value n) (z_birth_value n) := + ⟨0, 1, by ring, by ring, by omega, by omega⟩ + +inductive LineagePhase where + | LBirth (n : ℕ) + | LEven (n : ℕ) + | LOdd (n : ℕ) + deriving DecidableEq, Repr + +open LineagePhase + +def lineage_width : LineagePhase → ℕ + | LBirth n => z_birth_width n + | LEven n => even_residue_width n + | LOdd n => odd_residue_width n + +def lineage_residue : LineagePhase → ℤ + | LBirth n => z_birth_value n + | LEven n => even_residue n + | LOdd n => odd_residue n + +inductive lineage_next : LineagePhase → LineagePhase → Prop where + | lineage_birth (n : ℕ) : lineage_next (LBirth n) (LEven (n + 1)) + | lineage_even (n : ℕ) : lineage_next (LEven (n + 1)) (LOdd n) + | lineage_odd (n : ℕ) : lineage_next (LOdd n) (LEven n) + +def arbitrary_column_step (total : ℤ) (right_odd : Bool) (v : ℤ) : ℤ := + (if right_odd then total / 2 else total) - v / 2 + +theorem lineage_residue_bounds (p : LineagePhase) : + 3 ≤ lineage_residue p ∧ lineage_residue p ≤ pow2 (lineage_width p) - 6 := by + rcases p with n | n | n + · exact z_birth_bounds n + · exact even_residue_bounds n + · exact odd_residue_bounds n + +theorem lineage_next_width (p p' : LineagePhase) (h : lineage_next p p') : + lineage_width p = lineage_width p' + 1 := by + cases h <;> dsimp [lineage_width, z_birth_width, even_residue_width, odd_residue_width] <;> omega + +theorem lineage_next_low_step (p p' : LineagePhase) (h : lineage_next p p') : + pow2 (lineage_width p') - lineage_residue p / 2 = lineage_residue p' := by + cases h + · exact z_birth_first_low_step _ + · exact low_step_even_to_odd _ + · exact low_step_odd_to_even _ + +theorem lineage_step_preserves_slice (total : ℤ) (p p' : LineagePhase) (v : ℤ) (right_odd : Bool) + (hnext : lineage_next p p') + (hslice : low_slice total (lineage_width p) (lineage_residue p) v) : + low_slice total (lineage_width p') (lineage_residue p') + (arbitrary_column_step total right_odd v) := by + have hwidth := lineage_next_width p p' hnext + have hres := lineage_next_low_step p p' hnext + have hbounds := lineage_residue_bounds p + unfold arbitrary_column_step + rw [hwidth] at hslice hbounds + rw [← hres] + exact low_slice_step total (lineage_width p') (lineage_residue p) v right_odd hslice + ⟨hbounds.1, by omega⟩ + +def lineage_fuel : LineagePhase → ℕ + | LBirth n => 2 * n + 3 + | LEven n => 2 * n + | LOdd n => 2 * n + 1 + +def ordinary_left (u : ℕ) : ListBlank (Fin 2) := X4 ^ u +> common_left_wall + +theorem left_emit_zero : + SideRLs (flipTM source_tm) [left_hash] (ordinary_left 0) (ordinary_left 1) := by + unfold ordinary_left common_left_wall + have h := BoundedConfig.sideRLs_c_spec (flipTM source_tm) + (hs := [left_hash]) (r := Q8) (r' := X4 ++ Q8) (T := 500) (by decide) + simpa only [pow_zero_list, pow_one_list, append_nil, append_assoc] using h + +theorem left_emit_one : + SideRLs (flipTM source_tm) [left_hash] (ordinary_left 1) (ordinary_left 2) := by + unfold ordinary_left common_left_wall + have h := BoundedConfig.sideRLs_c_spec (flipTM source_tm) + (hs := [left_hash]) (r := X4 ++ Q8) (r' := X4 ^ 2 ++ Q8) (T := 500) (by decide) + simpa only [pow_one_list, append_assoc] using h + +theorem left_emit_call (u : ℕ) : + SideRLs (flipTM source_tm) [left_hash] (ordinary_left u) (ordinary_left (u + 1)) := by + induction u using Nat.strong_induction_on with + | h u ih => + rcases u with _ | _ | u + · exact left_emit_zero + · exact left_emit_one + · have hrec := ih u (by omega) + have h := left_hash_XX.sideRLs_concat hrec + unfold ordinary_left at h ⊢ + rw [show u + 1 + 1 = 2 + u by omega, show 2 + u + 1 = 2 + (u + 1) by omega, + pow_add_list, pow_add_list, append_assoc, append_assoc] + exact h + +theorem left_emit_calls (k u : ℕ) : + SideRLs (flipTM source_tm) ([left_hash] ^ k) (ordinary_left u) (ordinary_left (u + k)) := by + induction k generalizing u with + | zero => + simp only [pow_zero_list, Nat.add_zero] + exact .nil _ + | succ k ih => + rw [pow_succ_list] + have h := (left_emit_call u).trans (ih (u + 1)) + simpa only [Nat.add_right_comm u 1 k, Nat.add_assoc] using h + +theorem ordinary_emit_progress (u : ℕ) (r : ListBlank (Fin 2)) : + ((ordinary_left u) <{{F}} r) [source_tm]⊢⁺ ((ordinary_left (u + 1)) {{B}}> r) := + (left_emit_call u).elim_single_left r + +theorem ordinary_seg_return (k u : ℕ) (input output : List (Fin 2)) (r : ListBlank (Fin 2)) + (hseg : SegRLs source_tm (hashes ^ (k + 1)) [] input output) : + ((ordinary_left u) {{B}}> (input +> r)) [source_tm]⊢⁺ + ((ordinary_left (u + k)) <{{F}} (output +> r)) := by + have hright : SideRLs source_tm (lrcons (B, []) ([left_hash] ^ k) (F, [])) + (input +> r) (output +> r) := by + rw [lrcons_same] + exact hseg.sideRLs_concat (.nil r) + exact SideRLs.concat (left_emit_calls k u) hright + +theorem ordinary_seg_run (k u : ℕ) (input output : List (Fin 2)) (r : ListBlank (Fin 2)) + (hseg : SegRLs source_tm (hashes ^ (k + 1)) [] input output) : + ((ordinary_left u) {{B}}> (input +> r)) [source_tm]⊢⁺ + ((ordinary_left (u + (k + 1))) {{B}}> (output +> r)) := by + refine stepPlus_trans (ordinary_seg_return k u input output r hseg) ?_ + simpa only [Nat.add_assoc] using ordinary_emit_progress (u + k) (output +> r) + +theorem ordinary_seg_run_pos (calls u : ℕ) (input output : List (Fin 2)) (r : ListBlank (Fin 2)) + (hcalls : 1 ≤ calls) + (hseg : SegRLs source_tm (hashes ^ calls) [] input output) : + ((ordinary_left u) {{B}}> (input +> r)) [source_tm]⊢⁺ + ((ordinary_left (u + calls)) {{B}}> (output +> r)) := by + have hsplit : calls = (calls - 1) + 1 := by omega + rw [hsplit] at hseg ⊢ + exact ordinary_seg_run (calls - 1) u input output r hseg + +theorem ordinary_side_run (calls u : ℕ) (input output : ListBlank (Fin 2)) + (hside : SideRLs source_tm (hashes ^ calls) input output) : + ((ordinary_left u) {{B}}> input) [source_tm]⊢* + ((ordinary_left (u + calls)) {{B}}> output) := by + rcases calls with _ | k + · cases hside + simp only [Nat.add_zero] + exact stepStar_refl source_tm _ + · refine stepPlus_to_stepStar ?_ + have hright : SideRLs source_tm (lrcons (B, []) ([left_hash] ^ k) (F, [])) input output := by + rwa [lrcons_same] + refine stepPlus_trans (SideRLs.concat (left_emit_calls k u) hright) ?_ + simpa only [toDHCfg, append_nil, Nat.add_assoc] using ordinary_emit_progress (u + k) output + + +def z_tail_digits : ℕ → List BDigit + | 0 => [BA, BA, BB, BB] + | n' + 1 => BA :: BB :: z_tail_digits n' + +def z_digits (n : ℕ) : List BDigit := + BB :: BB :: BB :: z_tail_digits n + +theorem z_tail_digits_length (n : ℕ) : (z_tail_digits n).length = 2 * n + 4 := by + induction n with + | zero => rfl + | succ n ih => simp [z_tail_digits, ih]; omega + +theorem z_digits_length (n : ℕ) : (z_digits n).length = z_birth_width n := by + unfold z_digits z_birth_width + simp only [List.length_cons, z_tail_digits_length] + +theorem z_digits_value_succ (n : ℕ) : + digits_value (z_digits (n + 1)) + 5 = 4 * digits_value (z_digits n) := by + unfold z_digits + dsimp [z_tail_digits, digits_value] + omega + +theorem z_digits_value (n : ℕ) : + (digits_value (z_digits n) : ℤ) = z_birth_value n := by + induction n with + | zero => rfl + | succ n ih => + have hstep := z_digits_value_succ n + rw [z_birth_succ] + omega + +theorem digits_exist (width value : ℕ) (hval : value < 2 ^ width) : + ∃ ds : List BDigit, ds.length = width ∧ digits_value ds = value := by + induction width generalizing value with + | zero => + have : value = 0 := by simp at hval; omega + subst this + exact ⟨[], rfl, rfl⟩ + | succ width ih => + rw [Nat.pow_succ] at hval + obtain ⟨ds, hlen, hdig⟩ := ih (value / 2) (by omega) + rcases Nat.mod_two_eq_zero_or_one value with hmod | hmod + · refine ⟨BA :: ds, ?_, ?_⟩ + · simp [hlen] + · dsimp [digits_value]; omega + · refine ⟨BB :: ds, ?_, ?_⟩ + · simp [hlen] + · dsimp [digits_value]; omega + +theorem cd_start : + SegRLs source_tm (hashes ^ 2) [] (C8 ++ A8 ++ U ^ 2) (A8 ++ C8 ++ A8) := + BoundedConfig.segRLs_c_spec source_tm (T := 200) (by decide) + +def cd_calls (n : ℕ) : ℕ := 2 * (2 ^ n - 1) +def cd_input (n : ℕ) : List (Fin 2) := C8 ++ A8 ++ U ^ (2 * n) +def cd_output (n : ℕ) : List (Fin 2) := A8 ^ n ++ C8 ++ A8 + +theorem cd_batch (n : ℕ) : + SegRLs source_tm (hashes ^ cd_calls n) [] (cd_input n) (cd_output n) := by + induction n with + | zero => + exact .nil _ + | succ n ih => + have hstart := cd_start.concat (SegRLs.nil (M := source_tm) (U ^ (2 * n))) + have hrest := (hash_A_cycles (cd_calls n)).concat ih + have hcomb := hstart.trans hrest + dsimp [cd_calls, cd_input, cd_output] at hcomb ⊢ + rw [show 2 * (n + 1) = 2 + 2 * n by omega, pow_add_list U 2 (2 * n)] + have hcalls : hashes ^ 2 ++ hashes ^ (2 * (2 * (2 ^ n - 1))) = + hashes ^ (2 * (2 ^ (n + 1) - 1)) := by + rw [← pow_add_list] + congr 1 + have : 1 ≤ 2 ^ n := Nat.one_le_two_pow + rw [Nat.pow_succ] + omega + rw [← hcalls] + convert hcomb using 1 <;> + simp only [pow_succ_list, pow_zero_list, hashes, U, + List.cons_append, List.nil_append, List.append_nil] + +def after_cd (n : ℕ) (tail : List (Fin 2)) : Cfg (Fin 2) (Fin 6) := + (ordinary_left (cd_calls n)) {{B}}> ((cd_output n ++ tail) +> default) + +theorem cd_calls_positive (n : ℕ) (hn : 1 ≤ n) : 1 ≤ cd_calls n := by + unfold cd_calls + rcases n with _ | n + · omega + · have : 1 ≤ 2 ^ n := Nat.one_le_two_pow + rw [Nat.pow_succ] + omega + +theorem exception_done_cd (n : ℕ) (tail : List (Fin 2)) (hn : 1 ≤ n) : + (exception_done n tail) [source_tm]⊢⁺ (after_cd n tail) := by + unfold exception_done after_cd + have hseg := (cd_batch n).concat (SegRLs.nil (M := source_tm) tail) + have hrun := ordinary_seg_run_pos (cd_calls n) 0 (cd_input n ++ tail) (cd_output n ++ tail) + default (cd_calls_positive n hn) hseg + dsimp [cd_input, ordinary_left] at hrun ⊢ + simpa only [pow_zero_list, Nat.zero_add, append_nil, List.append_assoc] using hrun + +theorem all_A_cycles (width signals : ℕ) : + SegRLs source_tm (hashes ^ (signals * 2 ^ width)) (hashes ^ signals) + (A8 ^ width) (A8 ^ width) := by + induction width generalizing signals with + | zero => + simp only [Nat.pow_zero, Nat.mul_one, pow_zero_list] + exact SegRLs.empty source_tm (hashes ^ signals) + | succ width ih => + rw [pow_succ_list, Nat.pow_succ, ← Nat.mul_assoc] + have h := (hash_A_cycles (signals * 2 ^ width)).concat (ih signals) + rwa [Nat.mul_comm 2 (signals * 2 ^ width)] at h + +theorem primary_lift (signals width : ℕ) (input output : List (Fin 2)) + (h : SegRLs source_tm (hashes ^ signals) [] input output) : + SegRLs source_tm (hashes ^ (signals * 2 ^ width)) [] + (A8 ^ width ++ input) (A8 ^ width ++ output) := + (all_A_cycles width signals).concat h + +theorem primary_one_rule (p : ℕ) (w₁ w₂ : List (Fin 2)) + (hrule : SegRLs source_tm hashes [] w₁ w₂) : + SegRLs source_tm (hashes ^ (2 ^ p)) [] (A8 ^ p ++ w₁) (A8 ^ p ++ w₂) := by + have h := primary_lift 1 p w₁ w₂ (by simpa only [pow_one_list] using hrule) + simpa only [Nat.one_mul] using h + +def ca_pair_calls (width : ℕ) : ℕ := 2 * 2 ^ width + +theorem ca_pair0 : SegRLs source_tm (hashes ^ 2) [] (C8 ++ C8) (A8 ^ 2) := + BoundedConfig.segRLs_c_spec source_tm (T := 200) (by decide) + +theorem ca_pair (width : ℕ) (rest : List (Fin 2)) : + SegRLs source_tm (hashes ^ ca_pair_calls width) [] + (A8 ^ width ++ C8 ++ C8 ++ rest) + (A8 ^ (width + 2) ++ rest) := by + unfold ca_pair_calls + rw [pow_add_list A8 width 2] + have h := (primary_lift 2 width (C8 ++ C8) (A8 ^ 2) ca_pair0).concat + (SegRLs.nil (M := source_tm) rest) + simpa only [List.append_assoc] using h + +def c_sweep_calls (width : ℕ) : ℕ → ℕ + | 0 => 0 + | pairs' + 1 => ca_pair_calls width + c_sweep_calls (width + 2) pairs' + +theorem c_sweep (width pairs : ℕ) (rest : List (Fin 2)) : + SegRLs source_tm (hashes ^ c_sweep_calls width pairs) [] + (A8 ^ width ++ C8 ^ (2 * pairs + 1) ++ rest) + (A8 ^ (width + 2 * pairs) ++ C8 ++ rest) := by + induction pairs generalizing width with + | zero => + simp only [c_sweep_calls, Nat.mul_zero, Nat.add_zero, pow_zero_list, + List.append_assoc] + exact .nil _ + | succ pairs ih => + rw [show 2 * (pairs + 1) + 1 = 2 + (2 * pairs + 1) by omega, + pow_add_list C8 2 (2 * pairs + 1), + show width + 2 * (pairs + 1) = (width + 2) + 2 * pairs by omega] + dsimp [c_sweep_calls] + have hpair := ca_pair width (C8 ^ (2 * pairs + 1) ++ rest) + have htail := ih (width + 2) + rw [List.append_assoc] at htail + have hcomb := hpair.trans htail + rw [← pow_add_list] at hcomb + convert hcomb using 1 <;> + simp only [pow_succ_list, C8, A8, + List.cons_append, List.nil_append, List.append_nil, List.append_assoc] + +def ca_finish_calls (width : ℕ) : ℕ := 4 * 2 ^ width + +theorem ca_finish0 : + SegRLs source_tm (hashes ^ 4) [] + (C8 ++ B8 ++ U ++ [1, 1, 1, 1] ++ A8 ++ B8 ++ A8) + (A8 ^ 3 ++ U ^ 2 ++ B8 ++ B8) := + BoundedConfig.segRLs_c_spec source_tm (T := 500) (by decide) + +theorem ca_finish (width : ℕ) (rest : List (Fin 2)) : + SegRLs source_tm (hashes ^ ca_finish_calls width) [] + (A8 ^ width ++ C8 ++ B8 ++ U ++ [1, 1, 1, 1] ++ A8 ++ B8 ++ A8 ++ rest) + (A8 ^ (width + 3) ++ U ^ 2 ++ B8 ++ B8 ++ rest) := by + unfold ca_finish_calls + rw [pow_add_list A8 width 3] + have h := (primary_lift 4 width _ _ ca_finish0).concat (SegRLs.nil (M := source_tm) rest) + simpa only [List.append_assoc] using h + +def ca_start_calls (width : ℕ) : ℕ := 2 * 2 ^ width + +theorem ca_start0 (k : ℕ) : + SegRLs source_tm (hashes ^ 2) [] + (C8 ++ A8 ^ k ++ B8 ++ B8 ++ A8 ++ B8 ++ A8) + (A8 ++ C8 ^ k ++ B8 ++ U ++ [1, 1, 1, 1] ++ A8 ++ B8 ++ A8) := by + have h1 := (sobc1_hash_CAB1110 k).concat + (SegRLs.nil (M := source_tm) ([1, 1, 1, 1] ++ A8 ++ B8 ++ A8)) + have h2 := hash_D.concat + (SegRLs.nil (M := source_tm) (C8 ^ k ++ B8 ++ U ++ [1, 1, 1, 1] ++ A8 ++ B8 ++ A8)) + have h1' : SegRLs source_tm hashes [] + (C8 ++ (A8 ^ k ++ (B8 ++ (B8 ++ (A8 ++ (B8 ++ A8)))))) + (D8 ++ (C8 ^ k ++ (B8 ++ (U ++ ([1, 1, 1, 1] ++ (A8 ++ (B8 ++ A8))))))) := by + have hsplit : B8 ++ (A8 ++ (B8 ++ A8)) = [1, 1, 1, 0] ++ ([1, 1, 1, 1] ++ (A8 ++ (B8 ++ A8))) := + rfl + simpa only [List.append_assoc, hsplit] using h1 + have h2' : SegRLs source_tm hashes [] + (D8 ++ (C8 ^ k ++ (B8 ++ (U ++ ([1, 1, 1, 1] ++ (A8 ++ (B8 ++ A8))))))) + (A8 ++ (C8 ^ k ++ (B8 ++ (U ++ ([1, 1, 1, 1] ++ (A8 ++ (B8 ++ A8))))))) := by + simpa only [List.append_assoc] using h2 + have hcomb := h1'.trans h2' + simpa only [pow_succ_list, pow_zero_list, List.append_nil, List.nil_append, + List.append_assoc] using hcomb + +theorem ca_start (width k : ℕ) (rest : List (Fin 2)) : + SegRLs source_tm (hashes ^ ca_start_calls width) [] + (A8 ^ width ++ C8 ++ A8 ^ k ++ B8 ++ B8 ++ A8 ++ B8 ++ A8 ++ rest) + (A8 ^ (width + 1) ++ C8 ^ k ++ B8 ++ U ++ [1, 1, 1, 1] ++ A8 ++ B8 ++ A8 ++ rest) := by + unfold ca_start_calls + rw [pow_add_list A8 width 1, pow_one_list] + have h := (primary_lift 2 width _ _ (ca_start0 k)).concat (SegRLs.nil (M := source_tm) rest) + simpa only [List.append_assoc] using h + +def ca_calls (primary pairs : ℕ) : ℕ := + ca_start_calls primary + + (c_sweep_calls (primary + 1) pairs + ca_finish_calls (primary + 1 + 2 * pairs)) + +theorem ca_batch (primary pairs : ℕ) (rest : List (Fin 2)) : + SegRLs source_tm (hashes ^ ca_calls primary pairs) [] + (A8 ^ primary ++ C8 ++ A8 ^ (2 * pairs + 1) ++ B8 ++ B8 ++ A8 ++ B8 ++ A8 ++ rest) + (A8 ^ (primary + 2 * pairs + 4) ++ U ^ 2 ++ B8 ++ B8 ++ rest) := by + have hstart := ca_start primary (2 * pairs + 1) rest + have hsweep := c_sweep (primary + 1) pairs (B8 ++ U ++ [1, 1, 1, 1] ++ A8 ++ B8 ++ A8 ++ rest) + have hfinish := ca_finish (primary + 1 + 2 * pairs) rest + unfold ca_calls + rw [pow_add_list, pow_add_list, + show primary + 2 * pairs + 4 = (primary + 1 + 2 * pairs) + 3 by omega] + have h1 : SegRLs source_tm (hashes ^ ca_start_calls primary) [] + (A8 ^ primary ++ (C8 ++ (A8 ^ (2 * pairs + 1) ++ (B8 ++ (B8 ++ (A8 ++ (B8 ++ (A8 ++ + rest)))))))) + (A8 ^ (primary + 1) ++ (C8 ^ (2 * pairs + 1) ++ (B8 ++ (U ++ ([1, 1, 1, + 1] ++ (A8 ++ (B8 ++ (A8 ++ rest)))))))) := by + simpa only [List.append_assoc] using hstart + have h2 : SegRLs source_tm (hashes ^ c_sweep_calls (primary + 1) pairs) [] + (A8 ^ (primary + 1) ++ (C8 ^ (2 * pairs + 1) ++ (B8 ++ (U ++ ([1, 1, 1, + 1] ++ (A8 ++ (B8 ++ (A8 ++ rest)))))))) + (A8 ^ (primary + 1 + 2 * pairs) ++ (C8 ++ (B8 ++ (U ++ ([1, 1, 1, + 1] ++ (A8 ++ (B8 ++ (A8 ++ rest)))))))) := by + simpa only [List.append_assoc] using hsweep + have h3 : SegRLs source_tm (hashes ^ ca_finish_calls (primary + 1 + 2 * pairs)) [] + (A8 ^ (primary + 1 + 2 * pairs) ++ (C8 ++ (B8 ++ (U ++ ([1, 1, 1, + 1] ++ (A8 ++ (B8 ++ (A8 ++ rest)))))))) + (A8 ^ (primary + 1 + 2 * pairs + 3) ++ (U ^ 2 ++ (B8 ++ (B8 ++ rest)))) := by + simpa only [List.append_assoc] using hfinish + simpa only [List.nil_append, List.append_assoc] using h1.trans (h2.trans h3) + +structure BinaryColumn where + column_e : ℕ + column_digits : List BDigit + column_length : column_digits.length = column_e + 1 + +def mixed_column_word (c : BinaryColumn) : List (Fin 2) := + E8 ^ c.column_e ++ A8 + +def binary_column_word (c : BinaryColumn) : List (Fin 2) := + (digits_word A8 B8) c.column_digits + +def column_required (out : ℕ) (c : BinaryColumn) : ℕ := + (out + 1) * 2 ^ (c.column_e + 1) - 2 + digits_value c.column_digits + +def spaced_words : List (List (Fin 2)) → List (Fin 2) + | [] => [] + | [word] => word + | word :: w₂ :: words' => word ++ U ^ 2 ++ spaced_words (w₂ :: words') + +theorem mixed_column_spec (c : BinaryColumn) (out : ℕ) : + SegRLs source_tm (hashes ^ column_required out c) (hashes ^ out) + (mixed_column_word c) (binary_column_word c) := + standard_mixed_to_binary_out_spec c.column_e c.column_digits out c.column_length + +def columns_widths (columns : List BinaryColumn) : List ℕ := + (columns.map BinaryColumn.column_e).map (· + 1) + +def columns_width_sum (columns : List BinaryColumn) : ℕ := + (columns_widths columns).foldr (· + ·) 0 + +theorem columns_width_sum_cons (c : BinaryColumn) (columns : List BinaryColumn) : + columns_width_sum (c :: columns) = (c.column_e + 1) + columns_width_sum columns := rfl + +def geom4n : ℕ → ℕ + | 0 => 0 + | n' + 1 => 1 + 4 * geom4n n' + +def half_parameter (n : ℕ) : ℕ := 2 * n + 6 + +def round_primary_width (current previous : ℕ) : ℕ := + half_parameter current + half_parameter previous + 6 + +def round_outer_suffix (previous : ℕ) : List BDigit := + [BB, BB, BA, BB, BA, BB] ++ z_tail_digits previous + +def round_outer_digits (current previous : ℕ) : List BDigit := + List.replicate (half_parameter current + 2) BA ++ round_outer_suffix previous + +def round_post_unary (current previous : ℕ) : ℕ := + cd_calls (half_parameter current) + ca_calls (half_parameter current) (previous + 4) + +theorem geom4n_succ (n : ℕ) : geom4n (n + 1) = 1 + 4 * geom4n n := rfl + +theorem c_sweep_calls_formula (width pairs : ℕ) : + c_sweep_calls width pairs = 2 ^ (width + 1) * geom4n pairs := by + induction pairs generalizing width with + | zero => simp [c_sweep_calls, geom4n] + | succ pairs ih => + dsimp [c_sweep_calls, geom4n, ca_pair_calls] + rw [ih (width + 2), show width + 2 + 1 = (width + 1) + 2 by omega, + Nat.pow_add 2 (width + 1) 2, Nat.pow_succ 2 width] + ring + +theorem ca_calls_formula (primary pairs : ℕ) : + ca_calls primary pairs = + 2 ^ (primary + 1) + (2 ^ (primary + 2) * geom4n pairs + 2 ^ (primary + 2 * pairs + 3)) := by + unfold ca_calls ca_start_calls ca_finish_calls + rw [c_sweep_calls_formula, + show 2 * 2 ^ primary = 2 ^ (primary + 1) by rw [Nat.pow_succ]; ring, + show primary + 1 + 1 = primary + 2 by omega, + show 4 * 2 ^ (primary + 1 + 2 * pairs) = 2 ^ (primary + 2 * pairs + 3) by + rw [show primary + 2 * pairs + 3 = (primary + 1 + 2 * pairs) + 2 by omega, + Nat.pow_add]; ring] + +theorem cd_calls_formula (n : ℕ) (_hn : 1 ≤ n) : cd_calls n = 2 ^ (n + 1) - 2 := by + unfold cd_calls + have : 1 ≤ 2 ^ n := Nat.one_le_two_pow + rw [Nat.pow_succ] + omega + +theorem round_post_unary_formula (current previous : ℕ) : + round_post_unary current previous = + 2 ^ (half_parameter current + 2) * + (1 + geom4n (previous + 4) + 2 ^ (2 * (previous + 4) + 1)) - 2 := by + unfold round_post_unary + rw [cd_calls_formula _ (by unfold half_parameter; omega), ca_calls_formula] + have hstep : 2 ^ (half_parameter current + 2) = 2 * 2 ^ (half_parameter current + 1) := by + rw [show half_parameter current + 2 = (half_parameter current + 1) + 1 by omega, Nat.pow_succ] + ring + have h2 : 2 ^ (half_parameter current + 2 * (previous + 4) + 3) = + (2 * 2 ^ (half_parameter current + 1)) * 2 ^ (2 * (previous + 4) + 1) := by + rw [← hstep, ← Nat.pow_add] + congr 1; omega + have hpos : 2 ≤ 2 ^ (half_parameter current + 1) := by + have : 1 ≤ 2 ^ (half_parameter current) := Nat.one_le_two_pow + rw [Nat.pow_succ]; omega + rw [hstep, h2] + have hmul : 2 * 2 ^ (half_parameter current + 1) * + (1 + geom4n (previous + 4) + 2 ^ (2 * (previous + 4) + 1)) = + 2 * 2 ^ (half_parameter current + 1) + + 2 * 2 ^ (half_parameter current + 1) * geom4n (previous + 4) + + 2 * 2 ^ (half_parameter current + 1) * 2 ^ (2 * (previous + 4) + 1) := by ring + omega + +theorem digits_value_app (ds₁ ds₂ : List BDigit) : + digits_value (ds₁ ++ ds₂) = digits_value ds₁ + 2 ^ ds₁.length * digits_value ds₂ := by + induction ds₁ with + | nil => simp [digits_value] + | cons d ds₁ ih => + rcases d with _ | _ <;> dsimp [digits_value, List.length] <;> rw [ih, Nat.pow_succ] <;> ring + +theorem digits_value_repeat_BA (n : ℕ) : digits_value (List.replicate n BA) = 0 := by + induction n with + | zero => rfl + | succ n ih => simp [List.replicate_succ, digits_value, ih] + +theorem round_outer_suffix_length (previous : ℕ) : + (round_outer_suffix previous).length = 2 * previous + 10 := by + unfold round_outer_suffix + simp only [List.length_append, z_tail_digits_length, List.length] + omega + +theorem round_outer_digits_length (current previous : ℕ) : + (round_outer_digits current previous).length = round_primary_width current previous := by + unfold round_outer_digits round_primary_width half_parameter + simp only [List.length_append, List.length_replicate, round_outer_suffix_length] + omega + +theorem round_outer_suffix_succ (previous : ℕ) : + digits_value (round_outer_suffix (previous + 1)) + 1 = + 4 * digits_value (round_outer_suffix previous) := by + unfold round_outer_suffix + rw [digits_value_app, digits_value_app] + dsimp [z_tail_digits, digits_value, List.length] + omega + +theorem round_outer_suffix_formula (previous : ℕ) : + 2 * digits_value (round_outer_suffix previous) = + 1 + geom4n (previous + 4) + 2 ^ (2 * (previous + 4) + 1) + 2 ^ (2 * (previous + 4) + 2) := by + induction previous with + | zero => rfl + | succ previous ih => + have hstep := round_outer_suffix_succ previous + rw [show previous + 1 + 4 = (previous + 4) + 1 by omega, geom4n_succ, + show 2 * (previous + 4 + 1) + 1 = (2 * (previous + 4) + 1) + 2 by omega, + show 2 * (previous + 4 + 1) + 2 = (2 * (previous + 4) + 2) + 2 by omega, + Nat.pow_add 2 (2 * (previous + 4) + 1) 2, + Nat.pow_add 2 (2 * (previous + 4) + 2) 2] + omega + +theorem round_outer_digits_value (current previous : ℕ) : + digits_value (round_outer_digits current previous) = + 2 ^ (half_parameter current + 1) * + (1 + geom4n (previous + 4) + 2 ^ (2 * (previous + 4) + 1) + 2 ^ (2 * (previous + 4) + 2)) := + by + unfold round_outer_digits + rw [digits_value_app, digits_value_repeat_BA, List.length_replicate, Nat.zero_add, + show half_parameter current + 2 = (half_parameter current + 1) + 1 by omega, + Nat.pow_succ, Nat.mul_assoc, round_outer_suffix_formula] + +theorem round_unary_decodes_outer (current previous : ℕ) : + round_post_unary current previous / 2 + 1 + 2 ^ (round_primary_width current previous - 1) = + digits_value (round_outer_digits current previous) := by + rw [round_post_unary_formula, round_outer_digits_value] + have hhalf : ∀ n q, 1 ≤ q → (2 ^ (n + 2) * q - 2) / 2 + 1 = 2 ^ (n + 1) * q := by + intro n q hq + have hpow : 2 ^ (n + 2) = 2 * 2 ^ (n + 1) := by + rw [show n + 2 = (n + 1) + 1 by omega, Nat.pow_succ]; ring + have hpos : 1 ≤ 2 ^ (n + 1) := Nat.one_le_two_pow + have hmul : 1 ≤ 2 ^ (n + 1) * q := Nat.mul_pos hpos hq + have hmul2 : 2 * 2 ^ (n + 1) * q = (2 ^ (n + 1) * q) * 2 := by ring + rw [hpow, hmul2, show (2 ^ (n + 1) * q) * 2 - 2 = (2 ^ (n + 1) * q - 1) * 2 by omega, + Nat.mul_div_cancel _ (by decide)] + omega + have hq : 1 ≤ 1 + geom4n (previous + 4) + 2 ^ (2 * (previous + 4) + 1) := by + rw [Nat.add_assoc]; exact Nat.le_add_right 1 _ + rw [hhalf (half_parameter current) _ hq] + have hp : 2 ^ (round_primary_width current previous - 1) = + 2 ^ (half_parameter current + 1) * 2 ^ (2 * (previous + 4) + 2) := by + rw [← Nat.pow_add] + congr 1 + unfold round_primary_width half_parameter; omega + rw [hp] + ring + +theorem digits_word_repeat_BA (n : ℕ) : (digits_word A8 B8) (List.replicate n BA) = A8 ^ n := by + induction n with + | zero => rfl + | succ n ih => simp [List.replicate_succ, digits_word, digit_word, ih] + +theorem digits_word_app (ds₁ ds₂ : List BDigit) : + (digits_word A8 B8) (ds₁ ++ ds₂) = (digits_word A8 B8) ds₁ ++ (digits_word A8 B8) ds₂ := by + induction ds₁ with + | nil => rfl + | cons d ds₁ ih => simp [digits_word, ih, List.append_assoc] + +theorem round_outer_digits_word (current previous : ℕ) : + (digits_word A8 B8) (round_outer_digits current previous) = + A8 ^ (half_parameter current + 2) ++ + B8 ++ B8 ++ A8 ++ B8 ++ A8 ++ B8 ++ (digits_word A8 B8) (z_tail_digits previous) := by + unfold round_outer_digits round_outer_suffix + rw [digits_word_app, digits_word_app, digits_word_repeat_BA] + have h6 : (digits_word A8 B8) [BB, BB, BA, BB, BA, BB] = B8 ++ B8 ++ A8 ++ B8 ++ A8 ++ B8 := rfl + rw [h6] + simp only [List.append_assoc] + +theorem z_digits_word_split (previous : ℕ) : + (digits_word A8 B8) (z_digits previous) = + B8 ++ B8 ++ B8 ++ (digits_word A8 B8) (z_tail_digits previous) := rfl + +theorem raw_separator_return (l r : ListBlank (Fin 2)) : + (([1, 0, 1] +> (X4 ^ 2 +> (Q8 +> l))) <{{F}} r) [source_tm]⊢⁺ + (([1, 0, 1] +> l) <{{F}} ((A8 ++ U ^ 2) +> r)) := by + have h := run1Steps_spec source_tm 57 + ⟨[], [1, 0, 1] ++ X4 ^ 2 ++ Q8, F, .left⟩ + ⟨A8 ++ U ^ 2, [1, 0, 1], F, .left⟩ (by decide) (by decide) l r + simpa only [BoundedConfig.toCfg, List.append_assoc, append_assoc, append_nil] using h + +theorem raw_Bs_to_Qs (k : ℕ) : SegRR source_tm (B, []) (B, []) (B8 ^ k) (Q8 ^ k) := + segRR_lpow_same (B, []) B8 Q8 k raw_B_forward + +theorem raw_B_returns (k : ℕ) (l r : ListBlank (Fin 2)) : + (([1, 0, 1] +> (Q8 ^ k +> l)) <{{F}} r) [source_tm]⊢* + (([1, 0, 1] +> l) <{{F}} (E8 ^ k +> r)) := by + induction k generalizing l r with + | zero => + simp only [pow_zero_list, append_nil] + exact stepStar_refl source_tm _ + | succ k ih => + rw [pow_succ_list, append_assoc] + refine stepStar_trans (stepPlus_to_stepStar (raw_B_return (Q8 ^ k +> l) r)) ?_ + have hrec := ih l (E8 +> r) + simpa only [pow_succ_list', append_assoc] using hrec + +theorem primary_D_absorb (primary : ℕ) (rest : List (Fin 2)) : + SegRLs source_tm (hashes ^ (2 ^ primary)) [] + (A8 ^ primary ++ D8 ++ rest) + (A8 ^ (primary + 1) ++ rest) := by + have h := primary_one_rule primary (D8 ++ rest) (A8 ++ rest) + (hash_D.concat (SegRLs.nil (M := source_tm) rest)) + rw [pow_succ_list' A8 primary] + simpa only [List.append_assoc] using h + +theorem initial_u_pairs (primary pairs : ℕ) (rest : List (Fin 2)) : + SegRLs source_tm (hashes ^ initial_u_pair_calls primary pairs) [] + (A8 ^ primary ++ C8 ++ A8 ++ U ^ (2 * pairs) ++ rest) + (A8 ^ (primary + pairs) ++ C8 ++ A8 ++ rest) := by + induction pairs generalizing primary with + | zero => + simp only [initial_u_pair_calls, Nat.mul_zero, Nat.add_zero, pow_zero_list, List.append_nil] + exact .nil _ + | succ pairs ih => + dsimp [initial_u_pair_calls] + have hca := primary_one_rule primary + (C8 ++ A8 ++ U ++ U ++ (U ^ (2 * pairs) ++ rest)) + (D8 ++ C8 ++ A8 ++ (U ^ (2 * pairs) ++ rest)) + (hash_CAUU.concat (SegRLs.nil (M := source_tm) (U ^ (2 * pairs) ++ rest))) + have hd := primary_D_absorb primary (C8 ++ A8 ++ U ^ (2 * pairs) ++ rest) + have hrec := ih (primary + 1) + rw [show 2 * 2 ^ primary + initial_u_pair_calls (primary + 1) pairs = + 2 ^ primary + (2 ^ primary + initial_u_pair_calls (primary + 1) pairs) by omega, + pow_add_list, pow_add_list, + show 2 * (pairs + 1) = 2 + 2 * pairs by omega, + pow_add_list U 2 (2 * pairs), + show primary + (pairs + 1) = (primary + 1) + pairs by omega] + have hca' : SegRLs source_tm (hashes ^ (2 ^ primary)) [] + (A8 ^ primary ++ (C8 ++ (A8 ++ (U ^ 2 ++ (U ^ (2 * pairs) ++ rest))))) + (A8 ^ primary ++ (D8 ++ (C8 ++ (A8 ++ (U ^ (2 * pairs) ++ rest))))) := by + simpa only [pow_succ_list, pow_zero_list, List.append_nil, List.append_assoc] using hca + have hd' : SegRLs source_tm (hashes ^ (2 ^ primary)) [] + (A8 ^ primary ++ (D8 ++ (C8 ++ (A8 ++ (U ^ (2 * pairs) ++ rest))))) + (A8 ^ (primary + 1) ++ (C8 ++ (A8 ++ (U ^ (2 * pairs) ++ rest)))) := by + simpa only [List.append_assoc] using hd + have hrec' : SegRLs source_tm (hashes ^ initial_u_pair_calls (primary + 1) pairs) [] + (A8 ^ (primary + 1) ++ (C8 ++ (A8 ++ (U ^ (2 * pairs) ++ rest)))) + (A8 ^ (primary + 1 + pairs) ++ (C8 ++ (A8 ++ rest))) := by + simpa only [List.append_assoc] using hrec + simpa only [List.nil_append, List.append_assoc] using hca'.trans (hd'.trans hrec') + +theorem zero_primary_finish_seg (width : ℕ) (rest : List (Fin 2)) : + SegRLs source_tm (hashes ^ (2 ^ width - 1)) [] + (A8 ^ width ++ rest) (B8 ^ width ++ rest) := by + have h := + ((bfinish_spec hash_A_finish hash_B_finish) (List.replicate width BA) 0).concat (SegRLs.nil + (M := source_tm) rest) + rw [bfinish_repeat_BA_formula, digits_word_repeat_BA, List.length_replicate] at h + simpa only [Nat.zero_add, Nat.one_mul, pow_zero_list, List.append_nil] using h + +theorem bfinish_count_value (ds : List BDigit) (out : ℕ) : + bfinish_count ds out + digits_value ds + 1 = (out + 1) * 2 ^ ds.length := by + induction ds generalizing out with + | nil => simp [bfinish_count, digits_value] + | cons d ds ih => + have hrec := ih out + rcases d with _ | _ <;> dsimp [bfinish_count, digits_value, List.length] <;> + rw [Nat.pow_succ] <;> linarith + +theorem digits_value_bound (ds : List BDigit) : digits_value ds < 2 ^ ds.length := by + induction ds with + | nil => simp [digits_value] + | cons d ds ih => + rcases d with _ | _ <;> dsimp [digits_value, List.length] <;> rw [Nat.pow_succ] <;> omega + +theorem binary_column_value_bound (c : BinaryColumn) : + digits_value c.column_digits < 2 ^ (c.column_e + 1) := by + have h := digits_value_bound c.column_digits + rwa [c.column_length] at h + +def column_value (c : BinaryColumn) : ℕ := digits_value c.column_digits +def column_width (c : BinaryColumn) : ℕ := c.column_e + 1 + +def column_safe (c : BinaryColumn) : Prop := + 3 ≤ column_value c ∧ column_value c ≤ 2 ^ (column_width c) - 6 + +theorem column_safe_lower (c : BinaryColumn) (h : column_safe c) : 3 ≤ column_value c := h.1 + +def column_next_value (right_odd : Bool) (c : BinaryColumn) : ℕ := + (if right_odd then 2 ^ c.column_e else 2 ^ (c.column_e + 1)) - column_value c / 2 + +def column_step (right_odd : Bool) (c c' : BinaryColumn) : Prop := + c'.column_e = c.column_e ∧ column_value c' = column_next_value right_odd c + +theorem column_next_value_bound (right_odd : Bool) (c : BinaryColumn) (hlower : 3 ≤ column_value c) + : + column_next_value right_odd c < 2 ^ (column_width c) := by + unfold column_next_value column_width + have hpos : 1 ≤ 2 ^ c.column_e := Nat.one_le_two_pow + rcases right_odd with _ | _ <;> dsimp <;> rw [Nat.pow_succ] <;> omega + +theorem column_step_exists (right_odd : Bool) (c : BinaryColumn) (hlower : 3 ≤ column_value c) : + ∃ c', column_step right_odd c c' := by + have hbound := column_next_value_bound right_odd c hlower + obtain ⟨ds, hlen, hval⟩ := digits_exist (column_width c) (column_next_value right_odd c) hbound + exact ⟨⟨c.column_e, ds, hlen⟩, rfl, hval⟩ + +def ceil_half (n : ℕ) : ℕ := (n + 1) / 2 + +theorem ceil_half_scaled_sub (t w v : ℕ) (ht : 1 ≤ t) (hw : 1 ≤ w) (hv : v < 2 ^ w) : + ceil_half (t * 2 ^ w - v) = t * 2 ^ (w - 1) - v / 2 := by + have hpow : 2 ^ w = 2 * 2 ^ (w - 1) := by + conv_lhs => rw [show w = (w - 1) + 1 by omega, Nat.pow_succ] + ring + have hmul : 2 ^ w ≤ t * 2 ^ w := Nat.le_mul_of_pos_left _ ht + unfold ceil_half + rw [hpow] at hv hmul ⊢ + have hrewrite : t * (2 * 2 ^ (w - 1)) = 2 * (t * 2 ^ (w - 1)) := by ring + rw [hrewrite] at hmul ⊢ + omega + +theorem round_primary_width_positive (current previous : ℕ) : + 1 ≤ round_primary_width current previous := by + unfold round_primary_width half_parameter; omega + +def round_outer_column (current previous : ℕ) : BinaryColumn := + ⟨round_primary_width current previous - 1, + round_outer_digits current previous, + by + rw [round_outer_digits_length] + have := round_primary_width_positive current previous + omega⟩ + +theorem round_outer_column_word (current previous : ℕ) : + binary_column_word (round_outer_column current previous) = + A8 ^ (half_parameter current + 2) ++ + B8 ++ B8 ++ A8 ++ B8 ++ A8 ++ B8 ++ (digits_word A8 B8) (z_tail_digits previous) := + round_outer_digits_word current previous + +theorem round_post_unary_half_formula (current previous : ℕ) : + round_post_unary current previous / 2 = + 2 ^ (half_parameter current + 1) * + (1 + geom4n (previous + 4) + 2 ^ (2 * (previous + 4) + 1)) - 1 := by + rw [round_post_unary_formula] + set h := half_parameter current + set body := 1 + geom4n (previous + 4) + 2 ^ (2 * (previous + 4) + 1) + have hbody : 1 ≤ body := by dsimp [body]; rw [Nat.add_assoc]; exact Nat.le_add_right 1 _ + have hpow : 1 ≤ 2 ^ (h + 1) := Nat.one_le_two_pow + have hmul : 1 ≤ 2 ^ (h + 1) * body := Nat.mul_pos hpow hbody + have hmul2 : (2 ^ (h + 1) * 2) * body = (2 ^ (h + 1) * body) * 2 := by ring + rw [show h + 2 = (h + 1) + 1 by omega, Nat.pow_succ, hmul2, + show (2 ^ (h + 1) * body) * 2 - 2 = (2 ^ (h + 1) * body - 1) * 2 by omega, + Nat.mul_div_cancel _ (by decide)] + +def frontier_es (current previous : ℕ) (columns : List BinaryColumn) : List ℕ := + (round_primary_width current previous - 1) :: columns.map BinaryColumn.column_e + +def z_column (previous : ℕ) : BinaryColumn := + ⟨half_parameter previous, + z_digits previous, + by rw [z_digits_length]; unfold z_birth_width half_parameter; omega⟩ + +theorem z_column_word (previous : ℕ) : + binary_column_word (z_column previous) = (digits_word A8 B8) (z_digits previous) := rfl + +theorem z_column_e (previous : ℕ) : + (z_column previous).column_e = half_parameter previous := rfl + +theorem ca_calls_positive (primary pairs : ℕ) : 1 ≤ ca_calls primary pairs := by + unfold ca_calls ca_start_calls + have : 1 ≤ 2 ^ primary := Nat.one_le_two_pow + omega + +theorem exception_done_ca (n pairs : ℕ) (rest : List (Fin 2)) (hn : 1 ≤ n) : + (exception_done n (A8 ^ (2 * pairs) ++ B8 ++ B8 ++ A8 ++ B8 ++ A8 ++ rest)) [source_tm]⊢⁺ + ((ordinary_left (cd_calls n + ca_calls n pairs)) {{B}}> + ((A8 ^ (n + 2 * pairs + 4) ++ U ^ 2 ++ B8 ++ B8 ++ rest) +> default)) := by + refine stepPlus_trans (exception_done_cd n _ hn) ?_ + unfold after_cd + have heq : cd_output n ++ (A8 ^ (2 * pairs) ++ B8 ++ B8 ++ A8 ++ B8 ++ A8 ++ rest) = + A8 ^ n ++ C8 ++ A8 ^ (2 * pairs + 1) ++ B8 ++ B8 ++ A8 ++ B8 ++ A8 ++ rest := by + unfold cd_output + rw [show 2 * pairs + 1 = 1 + 2 * pairs by omega, pow_add_list A8 1 (2 * pairs), pow_one_list] + simp only [List.append_assoc] + rw [heq] + exact ordinary_seg_run_pos (ca_calls n pairs) (cd_calls n) _ _ default + (ca_calls_positive n pairs) (ca_batch n pairs rest) + +theorem pow2_linear_margin (n : ℕ) : 2 * n + 8 ≤ 2 ^ (n + 5) := by + induction n with + | zero => decide + | succ n ih => + rw [show n + 1 + 5 = (n + 5) + 1 by omega, Nat.pow_succ] + omega + +theorem z_column_width (previous : ℕ) : + column_width (z_column previous) = z_birth_width previous := by + unfold column_width z_birth_width + rw [z_column_e] + unfold half_parameter; omega + +theorem z_column_value (previous : ℕ) : + (column_value (z_column previous) : ℤ) = z_birth_value previous := + z_digits_value previous + +theorem z_birth_value_odd (n : ℕ) : z_birth_value n % 2 = 1 := by + rw [z_birth_complement]; omega + +theorem z_column_odd (previous : ℕ) : column_value (z_column previous) % 2 = 1 := by + have h := z_column_value previous + have hodd := z_birth_value_odd previous + omega + +@[ext] +structure AbstractColumn where + abstract_width : ℕ + abstract_value : ℤ + +def abstract_of_column (c : BinaryColumn) : AbstractColumn := + ⟨column_width c, (column_value c : ℤ)⟩ + +def abstract_safe (c : AbstractColumn) : Prop := + 3 ≤ c.abstract_value ∧ c.abstract_value ≤ pow2 c.abstract_width - 6 + +def abstract_step (right_odd : Bool) (c : AbstractColumn) : AbstractColumn := + ⟨c.abstract_width, + arbitrary_column_step (pow2 c.abstract_width) right_odd c.abstract_value⟩ + +theorem column_safe_abstract (c : BinaryColumn) : + column_safe c ↔ abstract_safe (abstract_of_column c) := by + unfold column_safe abstract_safe abstract_of_column + dsimp + rw [pow2_nat] + rcases h : column_width c with _ | _ | _ | k + · unfold column_width at h; omega + · omega + · omega + · have : 1 ≤ 2 ^ k := Nat.one_le_two_pow + rw [show k + 1 + 1 + 1 = k + 3 by omega, Nat.pow_add] + omega + +theorem abstract_column_step (c c' : BinaryColumn) (right_odd : Bool) + (hsafe : column_safe c) (hstep : column_step right_odd c c') : + abstract_of_column c' = abstract_step right_odd (abstract_of_column c) := by + rcases hstep with ⟨he, hv⟩ + unfold abstract_of_column abstract_step + ext + · dsimp; unfold column_width; omega + · dsimp + rw [hv] + unfold arbitrary_column_step column_next_value + have hhalf : column_value c / 2 ≤ 2 ^ c.column_e := by + rcases hsafe with ⟨_, h2⟩ + unfold column_width at h2 + rw [Nat.pow_succ] at h2 + omega + rcases right_odd with _ | _ + · dsimp + rw [pow2_nat, column_width, Nat.pow_succ] + omega + · dsimp + rw [pow2_nat, column_width, Nat.pow_succ] + omega + +-- ============================================================================ +-- 4. `W61Exit` Translated Cycler, Raw Tail Pass & Nested Exit (`PR_SOBCv10.v` lines 64–399) +-- ============================================================================ + +def y_after : ℕ → List (Fin 2) + | 0 => A8 + | 1 => B8 + | 2 => E8 ++ [1, 1] + | 3 => D8 ++ [1, 1] + | 4 => A8 ++ [1, 1] + | _ => B8 ++ [1, 1] + +def tail_word (k : ℕ) : List (Fin 2) := + U ^ (2 * k + 1) ++ B8 ++ [1, 1] + +theorem raw_tail_base (k : ℕ) (l : ListBlank (Fin 2)) (hk : k ≤ 5) : + (l {{B}}> ((B8 ++ U ^ (2 * k + 1) ++ B8 ++ [1, 1]) +> default)) [source_tm]⊢⁺ + (([1, 0, 1] +> l) <{{F}} ((U ^ (2 * k + 3) ++ y_after k) +> default)) := by + rcases k with _ | _ | _ | _ | _ | _ | k + · have h := check_r0inf_spec (M := source_tm) (n := 97) + (l₁ := []) (r₁ := B8 ++ U ^ 1 ++ B8 ++ [1, 1]) (l₂ := U ^ 3 ++ y_after 0) (r₂ := [1, 0, 1]) + (q₁ := B) (q₂ := F) (d₁ := .right) (d₂ := .left) (by decide) l + simpa only [BoundedConfig.toCfg, append_nil] using h + · have h := check_r0inf_spec (M := source_tm) (n := 199) + (l₁ := []) (r₁ := B8 ++ U ^ 3 ++ B8 ++ [1, 1]) (l₂ := U ^ 5 ++ y_after 1) (r₂ := [1, 0, 1]) + (q₁ := B) (q₂ := F) (d₁ := .right) (d₂ := .left) (by decide) l + simpa only [BoundedConfig.toCfg, append_nil] using h + · have h := check_r0inf_spec (M := source_tm) (n := 343) + (l₁ := []) (r₁ := B8 ++ U ^ 5 ++ B8 ++ [1, 1]) (l₂ := U ^ 7 ++ y_after 2) (r₂ := [1, 0, 1]) + (q₁ := B) (q₂ := F) (d₁ := .right) (d₂ := .left) (by decide) l + simpa only [BoundedConfig.toCfg, append_nil] using h + · have h := check_r0inf_spec (M := source_tm) (n := 501) + (l₁ := []) (r₁ := B8 ++ U ^ 7 ++ B8 ++ [1, 1]) (l₂ := U ^ 9 ++ y_after 3) (r₂ := [1, 0, 1]) + (q₁ := B) (q₂ := F) (d₁ := .right) (d₂ := .left) (by decide) l + simpa only [BoundedConfig.toCfg, append_nil] using h + · have h := check_r0inf_spec (M := source_tm) (n := 695) + (l₁ := []) (r₁ := B8 ++ U ^ 9 ++ B8 ++ [1, 1]) (l₂ := U ^ 11 ++ y_after 4) (r₂ := [1, 0, 1]) + (q₁ := B) (q₂ := F) (d₁ := .right) (d₂ := .left) (by decide) l + simpa only [BoundedConfig.toCfg, append_nil] using h + · have h := check_r0inf_spec (M := source_tm) (n := 909) + (l₁ := []) (r₁ := B8 ++ U ^ 11 ++ B8 ++ [1, 1]) (l₂ := U ^ 13 ++ y_after 5) (r₂ := [1, 0, 1]) + (q₁ := B) (q₂ := F) (d₁ := .right) (d₂ := .left) (by decide) l + simpa only [BoundedConfig.toCfg, append_nil] using h + · omega + +theorem raw_tail_column (k e : ℕ) (l : ListBlank (Fin 2)) (hk : k ≤ 5) : + (l {{B}}> ((B8 ^ (e + 1) ++ tail_word k) +> default)) [source_tm]⊢⁺ + (([1, 0, 1] +> l) <{{F}} ((E8 ^ e ++ U ^ (2 * k + 3) ++ y_after k) +> default)) := by + induction e generalizing l with + | zero => + unfold tail_word + rw [Nat.zero_add, pow_one_list, pow_zero_list, List.nil_append] + simpa only [List.append_assoc] using raw_tail_base k l hk + | succ e ih => + rw [pow_succ_list B8 (e + 1), List.append_assoc, append_assoc] + refine stepStar_stepPlus_trans (raw_B_forward l ((B8 ^ (e + 1) ++ tail_word k) +> default)) ?_ + refine stepPlus_trans (ih (Q8 +> l)) ?_ + have hret := raw_B_return l ((E8 ^ e ++ U ^ (2 * k + 3) ++ y_after k) +> default) + rw [pow_succ_list E8 e] + simpa only [List.append_assoc, append_assoc] using hret + +def full_tail (es : List ℕ) (e k : ℕ) : List (Fin 2) := + spaced_words (es.map (fun e => B8 ^ (e + 1)) ++ [B8 ^ (e + 1)]) ++ tail_word k + +def mixed_tail (es : List ℕ) (e k : ℕ) : List (Fin 2) := + spaced_words (es.map (fun e => E8 ^ e ++ A8) ++ [E8 ^ e]) ++ U ^ (2 * k + 3) ++ y_after k + +theorem spaced_snoc_cons (w : List (Fin 2)) (ws : List (List (Fin 2))) (x : List (Fin 2)) : + spaced_words ((w :: ws) ++ [x]) = w ++ U ^ 2 ++ spaced_words (ws ++ [x]) := by + rcases ws with _ | ⟨w₂, ws⟩ <;> rfl + +theorem full_tail_cons (e₀ : ℕ) (es : List ℕ) (e k : ℕ) : + full_tail (e₀ :: es) e k = B8 ^ (e₀ + 1) ++ U ^ 2 ++ full_tail es e k := by + unfold full_tail + rw [List.map_cons, spaced_snoc_cons] + simp only [List.append_assoc] + +theorem mixed_tail_cons (e₀ : ℕ) (es : List ℕ) (e k : ℕ) : + mixed_tail (e₀ :: es) e k = E8 ^ e₀ ++ A8 ++ U ^ 2 ++ mixed_tail es e k := by + unfold mixed_tail + rw [List.map_cons, spaced_snoc_cons] + simp only [List.append_assoc] + +theorem raw_tail_columns (es : List ℕ) (e k : ℕ) (l : ListBlank (Fin 2)) (hk : k ≤ 5) : + (l {{B}}> (full_tail es e k +> default)) [source_tm]⊢⁺ + (([1, 0, 1] +> l) <{{F}} (mixed_tail es e k +> default)) := by + induction es generalizing l with + | nil => + exact raw_tail_column k e l hk + | cons e₀ es ih => + rw [full_tail_cons, mixed_tail_cons, List.append_assoc, append_assoc] + refine stepStar_stepPlus_trans + (raw_Bs_to_Qs (e₀ + 1) l ((U ^ 2 ++ full_tail es e k) +> default)) ?_ + rw [append_assoc (U ^ 2)] + refine stepStar_stepPlus_trans + (raw_Us_to_Xs 2 (Q8 ^ (e₀ + 1) +> l) (full_tail es e k +> default)) ?_ + refine stepPlus_trans (ih (X4 ^ 2 +> (Q8 ^ (e₀ + 1) +> l))) ?_ + rw [pow_succ_list Q8 e₀, append_assoc Q8 (Q8 ^ e₀)] + refine stepPlus_stepStar_trans + (raw_separator_return (Q8 ^ e₀ +> l) (mixed_tail es e k +> default)) ?_ + have hret := raw_B_returns e₀ l ((A8 ++ U ^ 2 ++ mixed_tail es e k) +> default) + simpa only [List.append_assoc, append_assoc] using hret + +def Yw : List (Fin 2) := + [1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0, + 1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,1,0,0,1,0,0] + +theorem cycler_step (L : ListBlank (Fin 2)) : + ((Yw.reverse +> L) {{B}}> default) [source_tm]⊢⁺ + ((Yw.reverse +> ([0, 0, 1] +> L)) {{B}}> default) := by + have h := check_r0inf_spec (M := source_tm) (n := 918) + (l₁ := Yw.reverse) (r₁ := []) (l₂ := Yw.reverse ++ [0, 0, 1]) (r₂ := []) + (q₁ := B) (q₂ := B) (d₁ := .right) (d₂ := .right) (by decide) L + simpa only [BoundedConfig.toCfg, List.append_assoc, append_assoc, append_nil] using h + +theorem cycler_nonhalt (L : ListBlank (Fin 2)) : + NeverHaltsFrom source_tm ((Yw.reverse +> L) {{B}}> default) := by + refine NeverHaltsFrom.of_reachesPlus_invariant + (P := fun c => ∃ L', c = ((Yw.reverse +> L') {{B}}> default)) ?_ ⟨L, rfl⟩ + rintro _ ⟨L', rfl⟩ + exact ⟨(Yw.reverse +> ([0, 0, 1] +> L')) {{B}}> default, cycler_step L', [0, 0, 1] +> L', rfl⟩ + +theorem overflow_base (l : ListBlank (Fin 2)) : + (l {{B}}> ((B8 ++ tail_word 6) +> default)) [source_tm]⊢⁺ + ((Yw.reverse +> ([0, 1, 0, 1] +> l)) {{B}}> default) := by + have h := check_r0inf_spec (M := source_tm) (n := 1207) + (l₁ := []) (r₁ := B8 ++ tail_word 6) (l₂ := Yw.reverse ++ [0, 1, 0, 1]) (r₂ := []) + (q₁ := B) (q₂ := B) (d₁ := .right) (d₂ := .right) (by decide) l + simpa only [BoundedConfig.toCfg, List.append_assoc, append_assoc, append_nil] using h + +theorem overflow_column (e : ℕ) (l : ListBlank (Fin 2)) : + ∃ l', (l {{B}}> ((B8 ^ (e + 1) ++ tail_word 6) +> default)) [source_tm]⊢⁺ + ((Yw.reverse +> l') {{B}}> default) := by + induction e generalizing l with + | zero => + refine ⟨[0, 1, 0, 1] +> l, ?_⟩ + rw [Nat.zero_add, pow_one_list] + exact overflow_base l + | succ e ih => + obtain ⟨l', h⟩ := ih (Q8 +> l) + refine ⟨l', ?_⟩ + rw [pow_succ_list B8 (e + 1), List.append_assoc, append_assoc] + exact stepStar_stepPlus_trans (raw_B_forward l ((B8 ^ (e + 1) ++ tail_word 6) +> default)) h + +theorem overflow_columns (es : List ℕ) (e : ℕ) (l : ListBlank (Fin 2)) : + ∃ l', (l {{B}}> (full_tail es e 6 +> default)) [source_tm]⊢⁺ + ((Yw.reverse +> l') {{B}}> default) := by + induction es generalizing l with + | nil => + exact overflow_column e l + | cons e₀ es ih => + obtain ⟨l', h⟩ := ih (X4 ^ 2 +> (Q8 ^ (e₀ + 1) +> l)) + refine ⟨l', ?_⟩ + rw [full_tail_cons, List.append_assoc, append_assoc] + refine stepStar_stepPlus_trans + (raw_Bs_to_Qs (e₀ + 1) l ((U ^ 2 ++ full_tail es e 6) +> default)) ?_ + rw [append_assoc (U ^ 2)] + exact stepStar_stepPlus_trans + (raw_Us_to_Xs 2 (Q8 ^ (e₀ + 1) +> l) (full_tail es e 6 +> default)) h + +def pre_left_far (n : ℕ) (far : ListBlank (Fin 2)) : ListBlank (Fin 2) := + ([1, 0, 1, 0] ++ V4 ^ (2 * n + 2)) +> far + +def call_left_far (remaining finished : ℕ) (far : ListBlank (Fin 2)) : ListBlank (Fin 2) := + (X4 ^ (2 * finished + 5) ++ V4 ^ (2 * remaining)) +> far + +theorem pre_rotate_list (m : ℕ) : + [1, 0, 1] ++ X4 ^ (m + 1) = [1, 0, 1, 0] ++ V4 ^ m ++ [0, 1, 0] := by + induction m with + | zero => rfl + | succ m ih => + rw [pow_succ_list' X4 (m + 1), ← List.append_assoc, ih, pow_succ_list' V4 m] + simp only [List.append_assoc] + rfl + +theorem nested_pre_left (c f : ℕ) : + ([1, 0, 1] +> exception_call_left c f) = + pre_left_far (f + 1) ([0, 1, 0] +> (V4 ^ (2 * c) +> ([1, 0, 1] +> default))) := by + unfold exception_call_left pre_left_far + rw [← append_assoc, ← append_assoc, ← append_assoc, ← append_assoc] + congr 1 + rw [show 2 * f + 5 = (2 * f + 4) + 1 by omega, + show 2 * (f + 1) + 2 = 2 * f + 4 by omega, + ← List.append_assoc [1, 0, 1], ← List.append_assoc [1, 0, 1], + pre_rotate_list (2 * f + 4)] + +theorem launch_far (k : ℕ) (far : ListBlank (Fin 2)) : + SideRLs (flipTM source_tm) [left_hash] + (pre_left_far (k + 1) far) (call_left_far k 0 far) := by + unfold pre_left_far call_left_far + rw [show 2 * (k + 1) + 2 = 4 + 2 * k by omega, pow_add_list V4 4 (2 * k)] + have h := left_launch_segment.sideRLs_concat + (SideRLs.nil (M := flipTM source_tm) (V4 ^ (2 * k) +> far)) + simpa only [Nat.mul_zero, Nat.zero_add, List.append_assoc, append_assoc] using h + +theorem relaunch_far (remaining finished : ℕ) (far : ListBlank (Fin 2)) : + SideRLs (flipTM source_tm) [left_hash] + (call_left_far (remaining + 1) finished far) + (call_left_far remaining (finished + 1) far) := by + have hseg := (left_hash_X_pairs finished).concat left_relaunch_base + have hside := hseg.sideRLs_concat + (SideRLs.nil (M := flipTM source_tm) (V4 ^ (2 * remaining) +> far)) + unfold call_left_far + rw [show 2 * (remaining + 1) = 2 + 2 * remaining by omega, + show 2 * (finished + 1) + 5 = 2 * finished + 7 by omega, + pow_add_list V4 2 (2 * remaining), + pow_add_list X4 (2 * finished) 5, + pow_add_list X4 (2 * finished) 7] + simpa only [List.append_assoc, append_assoc] using hside + +theorem relaunches_far (k r finished : ℕ) (far : ListBlank (Fin 2)) : + SideRLs (flipTM source_tm) ([left_hash] ^ k) + (call_left_far (k + r) finished far) + (call_left_far r (finished + k) far) := by + induction k generalizing finished with + | zero => + simp only [pow_zero_list, Nat.zero_add, Nat.add_zero] + exact .nil _ + | succ k ih => + rw [pow_succ_list, show k + 1 + r = (k + r) + 1 by omega] + have h := (relaunch_far (k + r) finished far).trans (ih (finished + 1)) + simpa only [Nat.add_right_comm finished 1 k, Nat.add_assoc] using h + +theorem nested_launch (h r : ℕ) (far : ListBlank (Fin 2)) (inp out : List (Fin 2)) + (hseg : SegRLs source_tm (hashes ^ h) [] inp out) : + ((pre_left_far (h + r + 1) far) <{{F}} (inp +> default)) [source_tm]⊢⁺ + ((call_left_far r h far) {{B}}> (out +> default)) := by + refine stepPlus_stepStar_trans ((launch_far (h + r) far).elim_single_left (inp +> default)) ?_ + rcases h with _ | h + · cases hseg + simp only [Nat.zero_add] + exact stepStar_refl source_tm _ + · refine stepPlus_to_stepStar ?_ + have hright : SideRLs source_tm (lrcons (B, []) ([left_hash] ^ h) (F, [])) + (inp +> default) (out +> default) := by + rw [lrcons_same] + exact segRLs_0inf hseg + have hleft : SideRLs (flipTM source_tm) ([left_hash] ^ h) + (call_left_far (h + 1 + r) 0 far) (call_left_far (1 + r) h far) := by + simpa only [Nat.add_assoc, Nat.zero_add] using relaunches_far h (1 + r) 0 far + refine stepPlus_trans (SideRLs.concat hleft hright) ?_ + rw [show 1 + r = r + 1 by omega] + exact (relaunch_far r h far).elim_single_left (out +> default) + +theorem E_to_B (m : ℕ) : SegRLs source_tm (hashes ^ (3 * (2 ^ m - 1))) [] (E8 ^ m) (B8 ^ m) := by + induction m with + | zero => + exact .nil _ + | succ m ih => + rw [pow_succ_list E8 m, pow_succ_list B8 m] + have h := (hash_E_odd (3 * (2 ^ m - 1))).concat ih + have heq : 2 * (3 * (2 ^ m - 1)) + 3 = 3 * (2 ^ (m + 1) - 1) := by + have : 1 ≤ 2 ^ m := Nat.one_le_two_pow + rw [Nat.pow_succ] + omega + rwa [heq] at h + +theorem digits_word_repeat_BB (n : ℕ) : (digits_word A8 B8) (List.replicate n BB) = B8 ^ n := by + induction n with + | zero => rfl + | succ n ih => simp [List.replicate_succ, digits_word, digit_word, ih] + +theorem digits_value_repeat_BB (n : ℕ) : digits_value (List.replicate n BB) = 2 ^ n - 1 := by + induction n with + | zero => rfl + | succ n ih => + simp only [List.replicate_succ, digits_value, ih, Nat.pow_succ] + have : 1 ≤ 2 ^ n := Nat.one_le_two_pow + omega + +def nested_required : List ℕ → ℕ → ℕ + | [], e => 3 * (2 ^ (e + 1) - 1) + | e₀ :: es', e => + (nested_required es' e + 1) * 2 ^ (e₀ + 1) - 2 + (2 ^ (e₀ + 1) - 1) + +theorem nested_counter (es : List ℕ) (e : ℕ) : + SegRLs source_tm (hashes ^ nested_required es e) [] + (spaced_words (es.map (fun e => E8 ^ e ++ A8) ++ [E8 ^ (e + 1)])) + (spaced_words (es.map (fun e => B8 ^ (e + 1)) ++ [B8 ^ (e + 1)])) := by + induction es with + | nil => + exact E_to_B (e + 1) + | cons e₀ es ih => + dsimp only [nested_required] + rw [List.map_cons, List.map_cons, spaced_snoc_cons, spaced_snoc_cons] + have h0 := standard_mixed_to_binary_out_spec e₀ (List.replicate (e₀ + 1) BB) + (nested_required es e) (List.length_replicate) + rw [digits_word_repeat_BB, digits_value_repeat_BB] at h0 + simpa only [List.append_assoc] using h0.concat ((hashes_U_run (nested_required es e) 2).concat + ih) + +theorem mixed_tail_5_eq (es : List ℕ) (e : ℕ) : + mixed_tail es (e + 1) 5 = + spaced_words (es.map (fun e => E8 ^ e ++ A8) ++ [E8 ^ (e + 1)]) ++ tail_word 6 := by + unfold mixed_tail tail_word y_after + simp only [List.append_assoc] + +theorem nested_exit_to_cycler (c f : ℕ) (es : List ℕ) (e : ℕ) + (hle : nested_required es e ≤ f) : + ∃ l', + ((exception_call_left c f) {{B}}> (full_tail es (e + 1) 5 +> default)) [source_tm]⊢⁺ + ((Yw.reverse +> l') {{B}}> default) := by + set h := nested_required es e + set far := [0, 1, 0] +> (V4 ^ (2 * c) +> ([1, 0, 1] +> default)) + have hraw := raw_tail_columns es (e + 1) 5 (exception_call_left c f) (by decide) + rw [nested_pre_left c f, mixed_tail_5_eq es e] at hraw + have hseg := (nested_counter es e).concat (SegRLs.nil (M := source_tm) (tail_word 6)) + have hlaunch := nested_launch h (f - h) far _ _ hseg + rw [show h + (f - h) + 1 = f + 1 by omega] at hlaunch + obtain ⟨l', hover⟩ := overflow_columns es e (call_left_far (f - h) h far) + exact ⟨l', stepPlus_trans hraw (stepPlus_trans hlaunch hover)⟩ + +-- ============================================================================ +-- 5. `TailState`, `FiniteColumns`, `FiniteRound` & `OpeningEarly` (`PR_SOBCv10.v` lines 401–798) +-- ============================================================================ + +inductive SDigit where + | SE | SD | SA | SB + deriving DecidableEq, Repr + +open SDigit + +def sdigit_word : SDigit → List (Fin 2) + | SE => E8 + | SD => D8 + | SA => A8 + | SB => B8 + +def sdigit_value : SDigit → ℤ + | SE => -2 + | SD => -1 + | SA => 0 + | SB => 1 + +def sdigits_word : List SDigit → List (Fin 2) + | [] => [] + | d :: ds' => sdigit_word d ++ sdigits_word ds' + +def sdigits_value : List SDigit → ℤ + | [] => 0 + | d :: ds' => sdigit_value d + 2 * sdigits_value ds' + +def tail_layout (primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) (k lv : ℕ) : List (Fin + 2) := + A8 ^ primary ++ U ^ 2 ++ + spaced_words (zs.map binary_column_word ++ [sdigits_word last]) ++ + U ^ (2 * k + 1) ++ y_after lv + +def post_ca_tail (unary primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) (k lv : ℕ) : + Cfg (Fin 2) (Fin 6) := + (ordinary_left unary) {{B}}> (tail_layout primary zs last k lv +> default) + +def zs_value (o : ℕ) : List BinaryColumn → ℤ + | [] => 0 + | c :: zs' => (2 : ℤ) ^ o * (column_value c : ℤ) + zs_value (o + column_width c) zs' + +def tail_W (primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) : ℕ := + primary + columns_width_sum zs + last.length + +def tail_V (primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) (lv : ℕ) : ℤ := + zs_value primary zs + + (2 : ℤ) ^ (primary + columns_width_sum zs) * sdigits_value last + + (2 : ℤ) ^ (tail_W primary zs last) * ((lv : ℤ) - 1) + +def trigger_hash (primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) (lv : ℕ) : ℤ := + 5 * (2 : ℤ) ^ (tail_W primary zs last) - tail_V primary zs last lv + +def tail_next_half (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) (lv : ℕ) : + ℤ := + ((round_post_unary current previous : ℤ) + + trigger_hash (round_primary_width current previous) zs last lv - 1) / 2 + +def tail_next_index (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) (lv : ℕ) : + ℕ := + ((tail_next_half current previous zs last lv - 6) / 2).toNat + +def column_budget (n : ℕ) (c : BinaryColumn) : Prop := + ∃ phase, + n ≤ lineage_fuel phase ∧ + low_slice (pow2 (column_width c)) (lineage_width phase) + (lineage_residue phase) (column_value c : ℤ) + +theorem column_budget_safe (n : ℕ) (c : BinaryColumn) (h : column_budget n c) : column_safe c := by + rcases h with ⟨phase, _, hslice⟩ + rw [column_safe_abstract] + exact low_slice_safe _ _ _ _ hslice (lineage_residue_bounds phase) + +theorem lineage_next_fuel (phase : LineagePhase) (h : 1 ≤ lineage_fuel phase) : + ∃ phase', lineage_next phase phase' ∧ lineage_fuel phase' + 1 = lineage_fuel phase := by + match phase with + | LBirth n => + exact ⟨LEven (n + 1), .lineage_birth n, by dsimp [lineage_fuel]; omega⟩ + | LEven 0 => + dsimp [lineage_fuel] at h; omega + | LEven (n + 1) => + exact ⟨LOdd n, .lineage_even n, by dsimp [lineage_fuel]; omega⟩ + | LOdd n => + exact ⟨LEven n, .lineage_odd n, rfl⟩ + +theorem column_budget_step (n : ℕ) (c c' : BinaryColumn) (b : Bool) + (hbudget : column_budget (n + 1) c) (hstep : column_step b c c') : + column_budget n c' := by + have hsafe := column_budget_safe (n + 1) c hbudget + rcases hbudget with ⟨phase, hfuel, hslice⟩ + obtain ⟨phase', hnext, hleft⟩ := lineage_next_fuel phase (by omega) + refine ⟨phase', by omega, ?_⟩ + have hab := abstract_column_step c c' b hsafe hstep + have hw : column_width c' = column_width c := congrArg AbstractColumn.abstract_width hab + have hv : (column_value c' : ℤ) = + arbitrary_column_step (pow2 (column_width c)) b (column_value c : ℤ) := + congrArg AbstractColumn.abstract_value hab + rw [hw, hv] + exact lineage_step_preserves_slice _ _ _ _ b hnext hslice + +theorem z_column_budget (previous : ℕ) : column_budget 3 (z_column previous) := by + refine ⟨LBirth previous, by dsimp [lineage_fuel]; omega, ?_⟩ + dsimp [lineage_width, lineage_residue] + rw [z_column_width, z_column_value] + exact z_birth_low_slice previous + +def next_column_odd (right_odd : Bool) : List BinaryColumn → Bool + | [] => right_odd + | d :: _ => decide (column_value d % 2 = 1) + +def tail_columns_step (right_odd : Bool) : List BinaryColumn → List BinaryColumn → Prop + | [], [] => True + | c :: rest, c' :: rest' => + column_step (next_column_odd right_odd rest) c c' ∧ + tail_columns_step right_odd rest rest' + | _, _ => False + +theorem tail_columns_budget_step (n : ℕ) (cs : List BinaryColumn) (b : Bool) + (h : ∀ c ∈ cs, column_budget (n + 1) c) : + ∃ cs', tail_columns_step b cs cs' ∧ (∀ c' ∈ cs', column_budget n c') := by + induction cs with + | nil => + exact ⟨[], trivial, by intro _ hmem; cases hmem⟩ + | cons c rest ih => + obtain ⟨cs', hstep, hbudget⟩ := ih (fun x hx => h x (List.mem_cons_of_mem c hx)) + have hc : column_budget (n + 1) c := h c (List.Mem.head _) + obtain ⟨c', hcstep⟩ := column_step_exists (next_column_odd b rest) c + (column_safe_lower c (column_budget_safe (n + 1) c hc)) + refine ⟨c' :: cs', ⟨hcstep, hstep⟩, ?_⟩ + intro x hx + rcases List.mem_cons.mp hx with rfl | hmem + · exact column_budget_step n c x (next_column_odd b rest) hc hcstep + · exact hbudget x hmem + +theorem column_budget_weaken (n m : ℕ) (c : BinaryColumn) (hnm : n ≤ m) (hb : column_budget m c) : + column_budget n c := by + rcases hb with ⟨phase, hfuel, hslice⟩ + exact ⟨phase, by omega, hslice⟩ + +theorem tail_columns_round_budget (k previous : ℕ) (cs : List BinaryColumn) (b : Bool) + (hk1 : 1 ≤ k) (hk3 : k ≤ 3) (hcs : ∀ c ∈ cs, column_budget (4 - k) c) : + ∃ cs', tail_columns_step b cs cs' ∧ + (∀ c' ∈ z_column previous :: cs', column_budget (4 - (k + 1)) c') := by + have hcs' : ∀ c ∈ cs, column_budget ((4 - (k + 1)) + 1) c := by + intro c hc + rw [show (4 - (k + 1)) + 1 = 4 - k by omega] + exact hcs c hc + obtain ⟨cs', hstep, hbudget⟩ := tail_columns_budget_step (4 - (k + 1)) cs b hcs' + refine ⟨cs', hstep, ?_⟩ + intro x hx + rcases List.mem_cons.mp hx with rfl | hmem + · exact column_budget_weaken (4 - (k + 1)) 3 (z_column previous) (by omega) (z_column_budget + previous) + · exact hbudget x hmem + +def phase_width (k : ℕ) : ℕ := 30 - k + +def phase_value : ℕ → ℤ + | 1 => 391468375 + | 2 => -195734187 + | 3 => 97867094 + | _ => -116042411 + +def phase_lv : ℕ → ℕ + | 1 => 4 + | 2 => 1 + | 3 => 5 + | _ => 3 + +structure finite_round_pre (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) + (k lv : ℕ) : Prop where + fr_stage : 1 ≤ k ∧ k ≤ 4 + fr_columns : ∀ c ∈ zs, column_budget (4 - k) c + fr_head_odd : match zs with + | c :: _ => column_value c % 2 = 1 + | [] => sdigits_value last % 2 = 1 + fr_width : + 2 * (columns_width_sum zs + last.length) + 4 ≤ half_parameter previous + 1 ∧ + 2 * (half_parameter previous + 1 + columns_width_sum zs + last.length) + 4 ≤ + half_parameter current + 1 + fr_last_len : last.length = phase_width k + fr_last_value : sdigits_value last = phase_value k + fr_lv : lv = phase_lv k + +theorem finite_pre_safe (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) (k lv : + ℕ) + (h : finite_round_pre current previous zs last k lv) : + ∀ c ∈ zs, column_safe c := by + intro c hc + exact column_budget_safe (4 - k) c (h.fr_columns c hc) + +def early_tail : List (Fin 2) := U ^ 3 ++ A8 ++ B8 ^ 2 ++ [1, 1] +def fourth_tail : List (Fin 2) := C8 ++ [1, 1] ++ C8 ++ A8 ^ 2 ++ [1, 1, 1, 1] + +theorem opening_D_step1 : + (default {{D}}> default) [source_tm]⊢* + ((ordinary_left 1) {{B}}> ((B8 ++ U ++ D8 ++ C8 ++ U ^ 2) +> default)) := by + have hl0 : (([0] : List (Fin 2)) ^ 40 +> (default : ListBlank (Fin 2))) = default := + BoundedConfig.all0_spec (a := ([0] : List (Fin 2)) ^ 40) (by decide) + have hr0 : (([0] : List (Fin 2)) ^ 8 +> (default : ListBlank (Fin 2))) = default := + BoundedConfig.all0_spec (a := ([0] : List (Fin 2)) ^ 8) (by decide) + have h := runSteps_spec source_tm 556 + ⟨([0] : List (Fin 2)) ^ 40, ([0] : List (Fin 2)) ^ 8, D, .right⟩ + ⟨X4 ++ Q8, B8 ++ U ++ D8 ++ C8 ++ U ^ 2, B, .right⟩ + (by decide) default default + simpa only [BoundedConfig.toCfg, ordinary_left, common_left_wall, pow_one_list, + List.append_assoc, append_assoc, hl0, hr0] using h + +theorem opening_D_step2_side : + SideRLs source_tm (hashes ^ 56) + ((B8 ++ U ++ D8 ++ C8 ++ U ^ 2) +> default) + ((B8 ++ U ++ B8 ^ 3 ++ [1, 1]) +> default) := + BoundedConfig.sideRLs_c_spec source_tm (T := 20000) (by decide) + +theorem opening_D_step2 : + ((ordinary_left 1) {{B}}> ((B8 ++ U ++ D8 ++ C8 ++ U ^ 2) +> default)) [source_tm]⊢* + ((ordinary_left 57) {{B}}> ((B8 ++ U ++ B8 ^ 3 ++ [1, 1]) +> default)) := by + have h := ordinary_side_run 56 1 + ((B8 ++ U ++ D8 ++ C8 ++ U ^ 2) +> default) + ((B8 ++ U ++ B8 ^ 3 ++ [1, 1]) +> default) + opening_D_step2_side + simpa only [show 1 + 56 = 57 by omega] using h + +theorem opening_D_step3 : + ((ordinary_left 57) {{B}}> ((B8 ++ U ++ B8 ^ 3 ++ [1, 1]) +> default)) [source_tm]⊢⁺ + ((exception_pre_left 28) <{{F}} ((U ^ 3 ++ E8 ++ E8 ++ A8) +> default)) := by + have h := check_r0inf_spec (M := source_tm) (n := 157) + (l₁ := []) (r₁ := B8 ++ U ++ B8 ^ 3 ++ [1, 1]) + (l₂ := U ^ 3 ++ E8 ++ E8 ++ A8) (r₂ := [1, 0, 1]) + (q₁ := B) (q₂ := F) (d₁ := .right) (d₂ := .left) (by decide) (ordinary_left 57) + have hpre : ([1, 0, 1] +> ordinary_left 57) = exception_pre_left 28 := by + simpa only [ordinary_left, common_left_wall, show 2 * 28 + 1 = 57 by omega, + List.append_assoc, append_assoc] using exception_pre_left_direct 28 + simpa only [BoundedConfig.toCfg, append_nil, hpre] using h + +theorem opening_D_step4_side : + SideRLs source_tm (hashes ^ 28) + ((U ^ 3 ++ E8 ++ E8 ++ A8) +> default) + (early_tail +> default) := + BoundedConfig.sideRLs_c_spec source_tm (T := 20000) (by decide) + +theorem opening_D_to_third_done : + (default {{D}}> default) [source_tm]⊢* exception_done 28 early_tail := by + refine stepStar_trans opening_D_step1 ?_ + refine stepStar_trans opening_D_step2 ?_ + refine stepPlus_to_stepStar (stepPlus_trans opening_D_step3 ?_) + have hright : SideRLs source_tm (lrcons (B, []) ([left_hash] ^ 27) (F, [])) + ((U ^ 3 ++ E8 ++ E8 ++ A8) +> default) (early_tail +> default) := by + rw [lrcons_same] + exact opening_D_step4_side + have hleft : SideRLs (flipTM source_tm) ([left_hash] ^ 27) + (exception_call_left 27 0) (exception_call_left 0 27) := by + simpa only [Nat.zero_add] using exception_relaunches 27 0 + exact stepPlus_trans (exception_launch_progress 27 ((U ^ 3 ++ E8 ++ E8 ++ A8) +> default)) + (stepPlus_trans (SideRLs.concat hleft hright) (exception_exit 27 early_tail)) + +theorem opening_local_hash : + SegRLs source_tm hashes [] + (C8 ++ A8 ++ U ++ A8 ++ B8 ^ 2 ++ [1, 1]) + (D8 ++ fourth_tail) := + BoundedConfig.segRLs_c_spec source_tm (T := 300) (by decide) + +def opening_after_cd_calls (p : ℕ) : ℕ := + initial_u_pair_calls p 1 + (2 ^ (p + 1) + (2 ^ (p + 1) + (2 ^ (p + 2) - 1))) + +theorem opening_after_cd_side (p : ℕ) : + SideRLs source_tm (hashes ^ opening_after_cd_calls p) + ((A8 ^ p ++ C8 ++ A8 ++ early_tail) +> default) + ((B8 ^ (p + 2) ++ fourth_tail) +> default) := by + have hfirst := segRLs_0inf (initial_u_pairs p 1 (U ++ A8 ++ B8 ^ 2 ++ [1, 1])) + have hbridge := segRLs_0inf (primary_one_rule (p + 1) _ _ opening_local_hash) + have hd := segRLs_0inf (primary_D_absorb (p + 1) fourth_tail) + have hfinish := segRLs_0inf (zero_primary_finish_seg (p + 2) fourth_tail) + have hfirst' : SideRLs source_tm (hashes ^ initial_u_pair_calls p 1) + ((A8 ^ p ++ (C8 ++ (A8 ++ early_tail))) +> default) + ((A8 ^ (p + 1) ++ (C8 ++ (A8 ++ (U ++ (A8 ++ (B8 ^ 2 ++ [1, 1])))))) +> default) := by + unfold early_tail + have hu3 : U ^ 3 = U ^ (2 * 1) ++ U := rfl + rw [hu3] + simpa only [List.append_assoc, append_assoc] using hfirst + have hbridge' : SideRLs source_tm (hashes ^ (2 ^ (p + 1))) + ((A8 ^ (p + 1) ++ (C8 ++ (A8 ++ (U ++ (A8 ++ (B8 ^ 2 ++ [1, 1])))))) +> default) + ((A8 ^ (p + 1) ++ (D8 ++ fourth_tail)) +> default) := by + simpa only [List.append_assoc, append_assoc] using hbridge + have hd' : SideRLs source_tm (hashes ^ (2 ^ (p + 1))) + ((A8 ^ (p + 1) ++ (D8 ++ fourth_tail)) +> default) + ((A8 ^ (p + 2) ++ fourth_tail) +> default) := by + simpa only [List.append_assoc, append_assoc] using hd + have hcomb := hfirst'.trans (hbridge'.trans (hd'.trans hfinish)) + unfold opening_after_cd_calls + rw [pow_add_list, pow_add_list, pow_add_list] + simpa only [List.append_assoc, append_assoc] using hcomb + +def opening_n4 : ℕ := 3 * 2 ^ 29 - 2 + +theorem opening_total_count_general (p : ℕ) : + cd_calls p + opening_after_cd_calls p = 2 * (3 * 2 ^ (p + 1) - 2) + 1 := by + unfold cd_calls opening_after_cd_calls + dsimp [initial_u_pair_calls] + have : 1 ≤ 2 ^ p := Nat.one_le_two_pow + rw [show p + 2 = (p + 1) + 1 by omega, Nat.pow_succ 2 (p + 1), Nat.pow_succ 2 p] + omega + +theorem opening_total_count : + cd_calls 28 + opening_after_cd_calls 28 = 2 * opening_n4 + 1 := + opening_total_count_general 28 + +theorem opening_D_to_fourth_frontier : + (default {{D}}> default) [source_tm]⊢* + ((ordinary_left (2 * opening_n4 + 1)) {{B}}> ((B8 ^ 30 ++ fourth_tail) +> default)) := by + refine stepStar_trans opening_D_to_third_done ?_ + refine stepStar_trans (stepPlus_to_stepStar (exception_done_cd 28 early_tail (by decide))) ?_ + unfold after_cd cd_output + have h := ordinary_side_run (opening_after_cd_calls 28) (cd_calls 28) + ((A8 ^ 28 ++ C8 ++ A8 ++ early_tail) +> default) + ((B8 ^ 30 ++ fourth_tail) +> default) + (opening_after_cd_side 28) + rw [opening_total_count] at h + simpa only [List.append_assoc, append_assoc] using h + +-- ============================================================================ +-- 6. `SignedFrontier` (`PR_SOBCv10.v` lines 799–1014) +-- ============================================================================ + +def sfinish_count : List SDigit → ℕ → ℕ + | [], out => out + | d :: rest, out => + 2 * sfinish_count rest out + + match d with | SE => 3 | SD => 2 | SA => 1 | SB => 0 + +theorem hash_D_finish (n : ℕ) : + SegRLs source_tm (hashes ^ (2 * n + 2)) (hashes ^ n) D8 B8 := by + rw [show 2 * n + 2 = 1 + (2 * n + 1) by omega, pow_add_list, pow_one_list] + simpa only [List.nil_append] using hash_D.trans (hash_A_finish n) + +theorem sfinish_spec (ds : List SDigit) (out : ℕ) : + SegRLs source_tm (hashes ^ sfinish_count ds out) (hashes ^ out) + (sdigits_word ds) (B8 ^ ds.length) := by + induction ds with + | nil => + exact SegRLs.empty source_tm (hashes ^ out) + | cons d ds ih => + rw [List.length_cons, pow_succ_list B8 ds.length] + dsimp only [sdigits_word, sdigit_word, sfinish_count] + rcases d with _ | _ | _ | _ + · exact (hash_E_odd (sfinish_count ds out)).concat ih + · exact (hash_D_finish (sfinish_count ds out)).concat ih + · exact (hash_A_finish (sfinish_count ds out)).concat ih + · rw [Nat.add_zero] + exact (hash_B_finish (sfinish_count ds out)).concat ih + +theorem sfinish_value (ds : List SDigit) (out : ℕ) : + (sfinish_count ds out : ℤ) + sdigits_value ds + 1 = + ((out : ℤ) + 1) * pow2 ds.length := by + induction ds with + | nil => + simp [sfinish_count, sdigits_value, pow2] + | cons d ds ih => + rw [List.length_cons, pow2_succ] + rcases d with _ | _ | _ | _ <;> + { dsimp [sfinish_count, sdigits_value, sdigit_value] + linarith } + +theorem tail_level_finish (lv : ℕ) (hlv : lv ≤ 5) : + SideRLs source_tm (hashes ^ (5 - lv)) + (y_after lv +> default) ((B8 ++ [1, 1]) +> default) := by + rcases lv with _ | _ | _ | _ | _ | _ | lv + · exact BoundedConfig.sideRLs_c_spec source_tm (T := 1000) (by decide) + · exact BoundedConfig.sideRLs_c_spec source_tm (T := 1000) (by decide) + · exact BoundedConfig.sideRLs_c_spec source_tm (T := 1000) (by decide) + · exact BoundedConfig.sideRLs_c_spec source_tm (T := 1000) (by decide) + · exact BoundedConfig.sideRLs_c_spec source_tm (T := 1000) (by decide) + · exact .nil _ + · omega + +def last_finish_count (last : List SDigit) (lv : ℕ) : ℕ := + sfinish_count last (5 - lv) + +theorem last_to_frontier (last : List SDigit) (k lv : ℕ) (hlv : lv ≤ 5) : + SideRLs source_tm (hashes ^ last_finish_count last lv) + ((sdigits_word last ++ U ^ (2 * k + 1) ++ y_after lv) +> default) + ((B8 ^ last.length ++ U ^ (2 * k + 1) ++ B8 ++ [1, 1]) +> default) := by + have hp := (sfinish_spec last (5 - lv)).concat (hashes_U_run (5 - lv) (2 * k + 1)) + have h := hp.sideRLs_concat (tail_level_finish lv hlv) + unfold last_finish_count + simpa only [List.append_assoc, append_assoc] using h + +def columns_with_tail : List BinaryColumn → List (Fin 2) → List (Fin 2) + | [], tail => tail + | c :: rest, tail => binary_column_word c ++ U ^ 2 ++ columns_with_tail rest tail + +def all_B_with_tail : List BinaryColumn → List (Fin 2) → List (Fin 2) + | [], tail => tail + | c :: rest, tail => B8 ^ column_width c ++ U ^ 2 ++ all_B_with_tail rest tail + +def columns_finish_count : List BinaryColumn → ℕ → ℕ + | [], out => out + | c :: rest, out => bfinish_count c.column_digits (columns_finish_count rest out) + +theorem columns_finish_tail (zs : List BinaryColumn) (out : ℕ) (input output : List (Fin 2)) + (htail : SideRLs source_tm (hashes ^ out) (input +> default) (output +> default)) : + SideRLs source_tm (hashes ^ columns_finish_count zs out) + (columns_with_tail zs input +> default) + (all_B_with_tail zs output +> default) := by + induction zs with + | nil => exact htail + | cons c zs ih => + dsimp only [columns_finish_count, columns_with_tail, all_B_with_tail] + have hc := + (bfinish_spec hash_A_finish hash_B_finish) c.column_digits (columns_finish_count zs out) + rw [c.column_length] at hc + have hp := hc.concat (hashes_U_run (columns_finish_count zs out) 2) + have h := hp.sideRLs_concat ih + unfold binary_column_word column_width + simpa only [List.append_assoc, append_assoc] using h + +def tail_finish_count (primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) (lv : ℕ) : ℕ := + bfinish_count (List.replicate primary BA) (columns_finish_count zs (last_finish_count last lv)) + +def tail_frontier (primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) (k : ℕ) : List (Fin + 2) := + B8 ^ primary ++ U ^ 2 ++ + all_B_with_tail zs (B8 ^ last.length ++ U ^ (2 * k + 1) ++ B8 ++ [1, 1]) + +theorem tail_layout_chain (primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) (k lv : ℕ) : + tail_layout primary zs last k lv = + A8 ^ primary ++ U ^ 2 ++ + columns_with_tail zs (sdigits_word last ++ U ^ (2 * k + 1) ++ y_after lv) := by + unfold tail_layout + rw [List.append_assoc (A8 ^ primary ++ U ^ 2), List.append_assoc (A8 ^ primary ++ U ^ 2)] + congr 1 + induction zs with + | nil => + simp [columns_with_tail, spaced_words, List.append_assoc] + | cons c zs ih => + rw [List.map_cons, spaced_snoc_cons] + dsimp only [columns_with_tail] + rw [← ih] + simp only [List.append_assoc] + +theorem tail_to_frontier (primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) (k lv : ℕ) + (hlv : lv ≤ 5) : + SideRLs source_tm (hashes ^ tail_finish_count primary zs last lv) + (tail_layout primary zs last k lv +> default) + (tail_frontier primary zs last k +> default) := by + have htail := columns_finish_tail zs _ _ _ (last_to_frontier last k lv hlv) + have hprimary := (bfinish_spec hash_A_finish hash_B_finish) (List.replicate primary BA) + (columns_finish_count zs (last_finish_count last lv)) + rw [digits_word_repeat_BA, List.length_replicate] at hprimary + have hp := hprimary.concat + (hashes_U_run (columns_finish_count zs (last_finish_count last lv)) 2) + have h := hp.sideRLs_concat htail + unfold tail_finish_count tail_frontier + rw [tail_layout_chain] + simpa only [List.append_assoc, append_assoc] using h + +theorem pow2_add_local (a b : ℕ) : pow2 (a + b) = pow2 a * pow2 b := by + unfold pow2 + rw [pow_add] + +theorem bfinish_value_Z (ds : List BDigit) (out : ℕ) : + (bfinish_count ds out : ℤ) + (digits_value ds : ℤ) + 1 = + ((out : ℤ) + 1) * pow2 ds.length := by + have h := congrArg (fun n : ℕ => (n : ℤ)) (bfinish_count_value ds out) + push_cast at h + rw [pow2_Zpow] + linarith + +def columns_value_Z : List BinaryColumn → ℤ + | [] => 0 + | c :: rest => (column_value c : ℤ) + pow2 (column_width c) * columns_value_Z rest + +theorem zs_value_shift (o : ℕ) (zs : List BinaryColumn) : + zs_value o zs = pow2 o * columns_value_Z zs := by + induction zs generalizing o with + | nil => simp [zs_value, columns_value_Z] + | cons c zs ih => + dsimp [zs_value, columns_value_Z] + rw [ih, pow2_add_local, ← pow2_Zpow] + ring + +theorem columns_finish_value (zs : List BinaryColumn) (out : ℕ) : + (columns_finish_count zs out : ℤ) + columns_value_Z zs + 1 = + ((out : ℤ) + 1) * pow2 (columns_width_sum zs) := by + induction zs with + | nil => + simp [columns_finish_count, columns_value_Z, columns_width_sum, columns_widths, + pow2] + | cons c zs ih => + dsimp only [columns_finish_count, columns_value_Z] + rw [columns_width_sum_cons, pow2_add_local] + have h := bfinish_value_Z c.column_digits (columns_finish_count zs out) + rw [c.column_length] at h + change (bfinish_count c.column_digits (columns_finish_count zs out) : ℤ) + + (column_value c : ℤ) + 1 = + ((columns_finish_count zs out : ℤ) + 1) * pow2 (c.column_e + 1) at h + unfold column_width + nlinarith + +theorem trigger_hash_count (primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) (lv : ℕ) + (hlv : lv ≤ 5) : + ((tail_finish_count primary zs last lv + 1 : ℕ) : ℤ) = + trigger_hash primary zs last lv := by + have hp := bfinish_value_Z (List.replicate primary BA) + (columns_finish_count zs (last_finish_count last lv)) + rw [List.length_replicate, digits_value_repeat_BA] at hp + change (tail_finish_count primary zs last lv : ℤ) + 0 + 1 = + ((columns_finish_count zs (last_finish_count last lv) : ℤ) + 1) * pow2 primary at hp + have hc := columns_finish_value zs (last_finish_count last lv) + have hl := sfinish_value last (5 - lv) + change (last_finish_count last lv : ℤ) + sdigits_value last + 1 = + (((5 - lv : ℕ) : ℤ) + 1) * pow2 last.length at hl + have hsub : ((5 - lv : ℕ) : ℤ) = 5 - (lv : ℤ) := by omega + rw [hsub] at hl + unfold trigger_hash tail_V tail_W + rw [zs_value_shift, ← pow2_Zpow, ← pow2_Zpow, + pow2_add_local (primary + columns_width_sum zs) last.length, + pow2_add_local primary (columns_width_sum zs)] + have hp' : (tail_finish_count primary zs last lv : ℤ) + 1 = + ((columns_finish_count zs (last_finish_count last lv) : ℤ) + 1) * pow2 primary := by linarith + have hc' : (columns_finish_count zs (last_finish_count last lv) : ℤ) + 1 = + ((last_finish_count last lv : ℤ) + 1) * pow2 (columns_width_sum zs) - columns_value_Z zs := by + linarith + have hl' : (last_finish_count last lv : ℤ) + 1 = + (5 - (lv : ℤ) + 1) * pow2 last.length - sdigits_value last := by linarith + push_cast + rw [hp', hc', hl'] + ring + +-- ============================================================================ +-- 7. `SignedDecode` & `OpeningDecode` (`PR_SOBCv10.v` lines 1016–1185) +-- ============================================================================ + +def E_digit (n : ℕ) : SDigit := + if n == 0 then SE + else if n == 1 then SD + else if n % 2 == 0 then SA + else SB + +def E_carry (n : ℕ) : ℕ := + (n - 2) / 2 + +def E_decode : ℕ → ℕ → List SDigit × ℕ + | 0, n => ([], n) + | w + 1, n => + let (ds, out) := E_decode w (E_carry n) + (E_digit n :: ds, out) + +theorem E_digit_spec (n : ℕ) : + SegRLs source_tm (hashes ^ n) (hashes ^ E_carry n) E8 (sdigit_word (E_digit n)) := by + rcases Nat.eq_zero_or_pos n with rfl | hpos + · exact .nil E8 + · rcases Nat.eq_or_lt_of_le hpos with h1 | hgt1 + · subst h1 + exact hash_E + · rcases Nat.mod_two_eq_zero_or_one n with hmod | hmod + · have hdig : E_digit n = SA := by + unfold E_digit + have h0 : (n == 0) = false := beq_false_of_ne (by omega) + have h1 : (n == 1) = false := beq_false_of_ne (by omega) + have hm : (n % 2 == 0) = true := beq_iff_eq.mpr hmod + rw [h0, h1, hm] + rfl + rw [hdig, sdigit_word] + set c := E_carry n + have hc : E_carry n = c := rfl + have hn : n = 2 * c + 2 := by unfold E_carry at hc; omega + rw [hn] + exact hash_E_even c + · have hdig : E_digit n = SB := by + unfold E_digit + have h0 : (n == 0) = false := beq_false_of_ne (by omega) + have h1 : (n == 1) = false := beq_false_of_ne (by omega) + have hm : (n % 2 == 0) = false := beq_false_of_ne (by omega) + rw [h0, h1, hm] + rfl + rw [hdig, sdigit_word] + set c := E_carry n + have hc : E_carry n = c := rfl + have hn : n = 2 * c + 3 := by unfold E_carry at hc; omega + rw [hn] + exact hash_E_odd c + +theorem E_decode_spec (width n : ℕ) : + SegRLs source_tm (hashes ^ n) (hashes ^ (E_decode width n).2) + (E8 ^ width) (sdigits_word (E_decode width n).1) := by + induction width generalizing n with + | zero => + exact SegRLs.empty source_tm (hashes ^ n) + | succ w ih => + dsimp only [E_decode, sdigits_word] + rw [pow_succ_list E8 w] + exact (E_digit_spec n).concat (ih (E_carry n)) + +def opening_call_base : ℕ := 462424812206 + +def opening_digits : List SDigit := + [SA,SA,SA,SA,SB,SB,SA,SB,SA,SB,SA,SB,SA,SB,SA,SB,SA,SB, + SA,SB,SA,SB,SA,SB,SA,SB,SA,SB,SA,SB,SA,SB,SB,SB,SA,SB] + +theorem opening_decode_exact : + E_decode 36 opening_call_base = (opening_digits, 4) := by + decide + +theorem opening_tail_four : + SideRLs source_tm (hashes ^ 4) (A8 +> default) ((A8 ++ [1, 1]) +> default) := + BoundedConfig.sideRLs_c_spec source_tm (T := 500) (by decide) + +theorem opening_decode_base : + SideRLs source_tm (hashes ^ opening_call_base) + ((E8 ^ 36 ++ U ^ 3 ++ A8) +> default) + ((sdigits_word opening_digits ++ U ^ 3 ++ A8 ++ [1, 1]) +> default) := by + have h := E_decode_spec 36 opening_call_base + rw [opening_decode_exact] at h + have hp := h.concat (hashes_U_run 4 3) + have hfull := hp.sideRLs_concat opening_tail_four + simpa only [List.append_assoc, append_assoc] using hfull + +def opening_decode_calls (k : ℕ) : ℕ := + 2 ^ k * opening_call_base + 2 * (2 ^ k - 1) + +theorem opening_decode (k : ℕ) : + SideRLs source_tm (hashes ^ opening_decode_calls k) + ((E8 ^ (k + 36) ++ U ^ 3 ++ A8) +> default) + ((A8 ^ k ++ sdigits_word opening_digits ++ U ^ 3 ++ A8 ++ [1, 1]) +> default) := by + have hprefix := prefix_E_even k opening_call_base [] [] opening_call_base + (SegRLs.empty source_tm (hashes ^ opening_call_base)) + rw [List.append_nil, List.append_nil] at hprefix + have h := hprefix.sideRLs_concat opening_decode_base + unfold opening_decode_calls + rw [pow_add_list E8 k 36] + simpa only [List.append_assoc, append_assoc] using h + +theorem opening_call_base_formula : + opening_call_base = (1292 * 2 ^ 30 + 4) / 3 + 2 := by + decide + +theorem opening_decode_calls_formula (k : ℕ) : + opening_decode_calls k = 2 ^ (k + 2) - 2 + 2 ^ k * ((1292 * 2 ^ 30 + 4) / 3) := by + unfold opening_decode_calls + rw [opening_call_base_formula, Nat.pow_add] + have : 1 ≤ 2 ^ k := Nat.one_le_two_pow + change 2 ^ k * ((1292 * 2 ^ 30 + 4) / 3 + 2) + 2 * (2 ^ k - 1) = + 2 ^ k * 4 - 2 + 2 ^ k * ((1292 * 2 ^ 30 + 4) / 3) + omega + +-- ============================================================================ +-- 8. `OpeningEntry`, `Fossil`, `RoundCaller` & `OpeningLate` (`PR_SOBCv10.v` lines 1187–1762) +-- ============================================================================ + +def entry_rest : List SDigit := opening_digits.drop 9 +def entry_last : List SDigit := SB :: SB :: entry_rest +def entry_state_of (cur prev : ℕ) : Cfg (Fin 2) (Fin 6) := + post_ca_tail + (round_post_unary cur prev) + (round_primary_width cur prev) [] entry_last 1 4 + +theorem opening_n4_even_large : + (∃ q, opening_n4 = 2 * q) ∧ 64 ≤ opening_n4 := by + refine ⟨⟨3 * 2 ^ 28 - 1, by decide⟩, by decide⟩ + +theorem n4_binary : opening_n4 = 1610612734 := by decide +theorem n4_large : 10 ≤ opening_n4 := by decide + +theorem even_index_half (n : ℕ) (h : ∃ q, n = 2 * q ∧ 6 ≤ 2 * q) : + half_parameter ((n - 6) / 2) = n := by + rcases h with ⟨q, rfl, hge⟩ + unfold half_parameter + omega + +theorem opening_decode_even_ge6 (k : ℕ) (hk : 2 ≤ k) : + ∃ q, opening_decode_calls k = 2 * q ∧ 6 ≤ 2 * q := by + unfold opening_decode_calls + have hbase : opening_call_base = 2 * 231212406103 := by decide + rw [hbase] + have hpow : 4 ≤ 2 ^ k := by + have : 2 ^ 2 ≤ 2 ^ k := Nat.pow_le_pow_right (by decide) hk + simpa using this + refine ⟨2 ^ k * 231212406103 + (2 ^ k - 1), by omega, by omega⟩ + +theorem opening_entry_growth (n : ℕ) (hn : 64 ≤ n) : + 2 * (n + 30) + 4 ≤ opening_decode_calls (n - 2) + 1 := by + have hpow := pow2_linear_margin (n - 8) + rw [show n - 8 + 5 = n - 3 by omega] at hpow + have heq : 2 ^ (n - 2) = 2 * 2 ^ (n - 3) := by + rw [show n - 2 = (n - 3) + 1 by omega, Nat.pow_succ] + ring + unfold opening_decode_calls opening_call_base + rw [heq] + omega + +theorem entry_last_facts : + entry_last.length = 29 ∧ sdigits_value entry_last = 391468375 ∧ + sdigits_value entry_last % 2 = 1 := by + decide + +theorem entry_opening_word_generic (n4 : ℕ) (hn4 : ∃ q, n4 = 2 * q ∧ 6 ≤ 2 * q) : + A8 ^ (n4 - 2) ++ sdigits_word opening_digits ++ U ^ 3 ++ A8 ++ [1, 1] = + A8 ^ (2 * ((n4 - 6) / 2 + 4)) ++ B8 ++ B8 ++ A8 ++ B8 ++ A8 ++ + (sdigits_word entry_rest ++ U ^ 3 ++ A8 ++ [1, 1]) := by + have hsplit : sdigits_word opening_digits = + A8 ^ 4 ++ B8 ++ B8 ++ A8 ++ B8 ++ A8 ++ sdigits_word entry_rest := rfl + have hhalf := even_index_half n4 hn4 + unfold half_parameter at hhalf + have hexp : n4 - 2 + 4 = 2 * ((n4 - 6) / 2 + 4) := by omega + rw [hsplit] + simp only [← List.append_assoc] + rw [← pow_add_list A8 (n4 - 2) 4, hexp] + +theorem opening_exception_to_entry_generic (n4 n5 : ℕ) + (hn4 : ∃ q, n4 = 2 * q ∧ 6 ≤ 2 * q) + (hn5 : ∃ q, n5 = 2 * q ∧ 6 ≤ 2 * q) : + (exception_done n5 + (A8 ^ (n4 - 2) ++ sdigits_word opening_digits ++ U ^ 3 ++ A8 ++ [1, 1])) + [source_tm]⊢⁺ entry_state_of ((n5 - 6) / 2) ((n4 - 6) / 2) := by + rw [entry_opening_word_generic n4 hn4] + unfold entry_state_of post_ca_tail tail_layout round_post_unary round_primary_width + rw [even_index_half n5 hn5, even_index_half n4 hn4] + have hhalf := even_index_half n4 hn4 + unfold half_parameter at hhalf + have hwidth : n5 + n4 + 6 = n5 + 2 * ((n4 - 6) / 2 + 4) + 4 := by omega + rw [hwidth] + rcases hn5 with ⟨q, hq, hge6⟩ + have hpos : 1 ≤ n5 := by omega + have hca := exception_done_ca n5 ((n4 - 6) / 2 + 4) + (sdigits_word entry_rest ++ U ^ 3 ++ A8 ++ [1, 1]) hpos + have hsw : spaced_words (List.map binary_column_word [] ++ [sdigits_word entry_last]) = + B8 ++ B8 ++ sdigits_word entry_rest := rfl + rw [hsw] + dsimp only [y_after] at hca ⊢ + simpa only [pow_succ_list, pow_zero_list, List.nil_append, List.append_nil, + List.append_assoc, append_assoc] using hca + +theorem entry_pre_generic (n4 n5 : ℕ) + (hn4 : ∃ q, n4 = 2 * q ∧ 6 ≤ 2 * q) + (hn5 : ∃ q, n5 = 2 * q ∧ 6 ≤ 2 * q) + (hge64 : 64 ≤ n4) + (hgrow : 2 * (n4 + 30) + 4 ≤ n5 + 1) : + finite_round_pre ((n5 - 6) / 2) ((n4 - 6) / 2) [] entry_last 1 4 := by + obtain ⟨hlen, hval, hodd⟩ := entry_last_facts + refine ⟨⟨by omega, by omega⟩, ?_, hodd, ?_, hlen, hval, rfl⟩ + · intro _ hmem; cases hmem + · rw [even_index_half n4 hn4, even_index_half n5 hn5, hlen] + change 2 * (0 + 29) + 4 ≤ n4 + 1 ∧ + 2 * (n4 + 1 + 0 + 29) + 4 ≤ n5 + 1 + exact ⟨by omega, by omega⟩ + +def fossil_tail : List (Fin 2) := C8 ++ [1, 1] ++ C8 ++ U ++ [1, 1] ++ U +def fossil_start (m : ℕ) : List (Fin 2) := C8 ++ A8 ^ m ++ D8 ++ D8 ++ A8 ++ U ++ E8 ++ A8 + +theorem fossil_scan (m : ℕ) : + SegRLs source_tm hashes [] (fossil_start m) + (D8 ++ C8 ^ m ++ D8 ++ D8 ++ fossil_tail) := by + refine .cons (fun l r => ?_) (.nil _) + unfold fossil_start + simp only [toDHCfg, List.append_assoc, append_assoc, append_nil] + refine stepPlus_stepStar_trans (scan_C8_fwd l _) ?_ + have hd : (D8 +> (D8 +> (A8 +> (U +> (E8 +> (A8 +> r)))))) = + ([1] +> (([1, 1, 0, 1, 1, 1, 0] ++ D8 ++ A8 ++ U ++ E8 ++ A8) +> r)) := rfl + rw [hd] + refine stepStar_trans (scan_A8_fwd_pow m (W_C +> l) + (([1, 1, 0, 1, 1, 1, 0] ++ D8 ++ A8 ++ U ++ E8 ++ A8) +> r)) ?_ + rw [← hd] + have hturn : (([1] +> ((W_A ^ m) +> (W_C +> l))) {{A}}> + (D8 +> (D8 +> (A8 +> (U +> (E8 +> (A8 +> r))))))) [source_tm]⊢* + (([1] +> ((W_A ^ m) +> (W_C +> l))) <{{F}} ((D8 ++ D8 ++ fossil_tail) +> r)) := by + have h := runSteps_spec source_tm 91 + ⟨[1], D8 ++ D8 ++ A8 ++ U ++ E8 ++ A8, A, .right⟩ + ⟨D8 ++ D8 ++ fossil_tail, [1], F, .left⟩ + (by decide) ((W_A ^ m) +> (W_C +> l)) r + simpa only [BoundedConfig.toCfg, List.append_assoc, append_assoc, append_nil] using h + refine stepStar_trans hturn ?_ + refine stepStar_trans (scan_A8_ret_pow m (W_C +> l) ((D8 ++ D8 ++ fossil_tail) +> r)) ?_ + simpa only [List.append_assoc, append_assoc] using + scan_C8_ret l ((C8 ^ m) +> ((D8 ++ D8 ++ fossil_tail) +> r)) + +theorem fossil_tail_finish : + SideRLs source_tm (hashes ^ 25) + (fossil_tail +> default) ((B8 ^ 2 ++ U ++ B8 ++ [1, 1]) +> default) := + BoundedConfig.sideRLs_c_spec source_tm (T := 2000) (by decide) + +theorem c_sweep_even (width pairs : ℕ) (rest : List (Fin 2)) : + SegRLs source_tm (hashes ^ c_sweep_calls width pairs) [] + (A8 ^ width ++ C8 ^ (2 * pairs) ++ rest) + (A8 ^ (width + 2 * pairs) ++ rest) := by + induction pairs generalizing width with + | zero => + simp only [c_sweep_calls, Nat.mul_zero, Nat.add_zero, pow_zero_list, List.append_nil] + exact .nil _ + | succ pairs ih => + rw [show width + 2 * (pairs + 1) = (width + 2) + 2 * pairs by omega, + show 2 * (pairs + 1) = 2 + 2 * pairs by omega, + pow_add_list C8 2 (2 * pairs)] + dsimp [c_sweep_calls] + have hpair := ca_pair width (C8 ^ (2 * pairs) ++ rest) + have htail := ih (width + 2) + rw [List.append_assoc] at htail + have hcomb := hpair.trans htail + rw [← pow_add_list] at hcomb + convert hcomb using 1 <;> + simp only [C8, A8, + List.cons_append, List.nil_append, List.append_nil, List.append_assoc] + +theorem fossil_tail_lift (width : ℕ) : + SideRLs source_tm (hashes ^ (25 * 2 ^ width + (2 ^ width - 1))) + ((A8 ^ width ++ fossil_tail) +> default) + ((B8 ^ (width + 2) ++ U ++ B8 ++ [1, 1]) +> default) := by + have htail := (all_A_cycles width 25).sideRLs_concat fossil_tail_finish + have htail' : SideRLs source_tm (hashes ^ (25 * 2 ^ width)) + ((A8 ^ width ++ fossil_tail) +> default) + ((A8 ^ width ++ (B8 ^ 2 ++ U ++ B8 ++ [1, 1])) +> default) := by + simpa only [List.append_assoc, append_assoc] using htail + have hlow := segRLs_0inf (zero_primary_finish_seg width (B8 ^ 2 ++ U ++ B8 ++ [1, 1])) + have hcomb := htail'.trans hlow + simp only [← List.append_assoc] at hcomb + rw [← pow_add_list, ← pow_add_list B8 width 2] at hcomb + simpa only [List.append_assoc, append_assoc] using hcomb + +def fossil_calls (p k : ℕ) : ℕ := + 2 ^ p + 2 ^ p + c_sweep_calls (p + 1) k + + 2 ^ (p + 1 + 2 * k) + 2 ^ (p + 2 + 2 * k) + + (25 * 2 ^ (p + 3 + 2 * k) + (2 ^ (p + 3 + 2 * k) - 1)) + +theorem fossil_run (p k : ℕ) : + SideRLs source_tm (hashes ^ fossil_calls p k) + ((A8 ^ p ++ fossil_start (2 * k)) +> default) + ((B8 ^ (p + 2 * k + 5) ++ U ++ B8 ++ [1, 1]) +> default) := by + have hscan : SideRLs source_tm (hashes ^ (2 ^ p)) + ((A8 ^ p ++ fossil_start (2 * k)) +> default) + ((A8 ^ p ++ (D8 ++ (C8 ^ (2 * k) ++ (D8 ++ (D8 ++ fossil_tail))))) +> default) := by + simpa only [List.append_assoc, append_assoc] using + segRLs_0inf (primary_one_rule p _ _ (fossil_scan (2 * k))) + have hd : SideRLs source_tm (hashes ^ (2 ^ p)) + ((A8 ^ p ++ (D8 ++ (C8 ^ (2 * k) ++ (D8 ++ (D8 ++ fossil_tail))))) +> default) + ((A8 ^ (p + 1) ++ (C8 ^ (2 * k) ++ (D8 ++ (D8 ++ fossil_tail)))) +> default) := by + simpa only [List.append_assoc, append_assoc] using + segRLs_0inf (primary_D_absorb p (C8 ^ (2 * k) ++ D8 ++ D8 ++ fossil_tail)) + have hsweep : SideRLs source_tm (hashes ^ c_sweep_calls (p + 1) k) + ((A8 ^ (p + 1) ++ (C8 ^ (2 * k) ++ (D8 ++ (D8 ++ fossil_tail)))) +> default) + ((A8 ^ (p + 1 + 2 * k) ++ (D8 ++ (D8 ++ fossil_tail))) +> default) := by + simpa only [List.append_assoc, append_assoc] using + segRLs_0inf (c_sweep_even (p + 1) k (D8 ++ D8 ++ fossil_tail)) + have hd1 : SideRLs source_tm (hashes ^ (2 ^ (p + 1 + 2 * k))) + ((A8 ^ (p + 1 + 2 * k) ++ (D8 ++ (D8 ++ fossil_tail))) +> default) + ((A8 ^ (p + 2 + 2 * k) ++ (D8 ++ fossil_tail)) +> default) := by + rw [show p + 2 + 2 * k = (p + 1 + 2 * k) + 1 by omega] + simpa only [List.append_assoc, append_assoc] using + segRLs_0inf (primary_D_absorb (p + 1 + 2 * k) (D8 ++ fossil_tail)) + have hd2 : SideRLs source_tm (hashes ^ (2 ^ (p + 2 + 2 * k))) + ((A8 ^ (p + 2 + 2 * k) ++ (D8 ++ fossil_tail)) +> default) + ((A8 ^ (p + 3 + 2 * k) ++ fossil_tail) +> default) := by + rw [show p + 3 + 2 * k = (p + 2 + 2 * k) + 1 by omega] + simpa only [List.append_assoc, append_assoc] using + segRLs_0inf (primary_D_absorb (p + 2 + 2 * k) fossil_tail) + have htail : SideRLs source_tm (hashes ^ (25 * 2 ^ (p + 3 + 2 * k) + (2 ^ (p + 3 + 2 * k) - 1))) + ((A8 ^ (p + 3 + 2 * k) ++ fossil_tail) +> default) + ((B8 ^ (p + 2 * k + 5) ++ (U ++ (B8 ++ [1, 1]))) +> default) := by + rw [show p + 2 * k + 5 = (p + 3 + 2 * k) + 2 by omega] + simpa only [List.append_assoc, append_assoc] using fossil_tail_lift (p + 3 + 2 * k) + have hcomb := hscan.trans (hd.trans (hsweep.trans (hd1.trans (hd2.trans htail)))) + unfold fossil_calls + rw [pow_add_list, pow_add_list, pow_add_list, pow_add_list, pow_add_list] + simpa only [List.append_assoc, append_assoc] using hcomb + +theorem geom4n_power (k : ℕ) : 3 * geom4n k + 1 = 2 ^ (2 * k) := by + induction k with + | zero => rfl + | succ k ih => + rw [geom4n_succ, show 2 * (k + 1) = 2 * k + 2 by omega, Nat.pow_add] + have h4 : (2 : ℕ) ^ 2 = 4 := rfl + rw [h4] + omega + +theorem fossil_count_formula (n k : ℕ) : + fossil_calls (n + 1) k = 2 ^ n * ((1292 * 2 ^ (2 * k) + 4) / 3) - 1 := by + have hg := geom4n_power k + have hdiv : (1292 * 2 ^ (2 * k) + 4) / 3 = 1292 * geom4n k + 432 := by + have hmul : 1292 * 2 ^ (2 * k) + 4 = (1292 * geom4n k + 432) * 3 := by omega + rw [hmul, Nat.mul_div_cancel _ (by decide)] + rw [hdiv] + unfold fossil_calls + rw [c_sweep_calls_formula] + have hp1 : 2 ^ (n + 1) = 2 * 2 ^ n := by rw [Nat.pow_succ]; ring + have hp2 : 2 ^ (n + 1 + 1) = 4 * 2 ^ n := by rw [Nat.pow_succ, hp1]; ring + have hp25 : 2 ^ (n + 1 + 1 + 1) = 8 * 2 ^ n := by rw [Nat.pow_succ, hp2]; ring + have hp3 : 2 ^ (n + 1 + 1 + 2 * k) = 4 * 2 ^ n * (3 * geom4n k + 1) := by + rw [Nat.pow_add, hp2, ← hg] + have hp4 : 2 ^ (n + 1 + 2 + 2 * k) = 8 * 2 ^ n * (3 * geom4n k + 1) := by + rw [Nat.pow_add, show n + 1 + 2 = (n + 1 + 1) + 1 by omega, Nat.pow_succ, hp2, ← hg]; ring + have hp5 : 2 ^ (n + 1 + 3 + 2 * k) = 16 * 2 ^ n * (3 * geom4n k + 1) := by + rw [Nat.pow_add, show n + 1 + 3 = (n + 1 + 1) + 2 by omega, Nat.pow_add, hp2, ← hg]; ring + rw [hp1, hp25, hp3, hp4, hp5] + set P := 2 ^ n + set G := geom4n k + have hP : 1 ≤ P := Nat.one_le_two_pow + have hring : 2 * P + 2 * P + 8 * P * G + 4 * P * (3 * G + 1) + 8 * P * (3 * G + 1) + + (25 * (16 * P * (3 * G + 1)) + 16 * P * (3 * G + 1)) = P * (1292 * G + 432) := by ring + have hpos : 1 ≤ 16 * P * (3 * G + 1) := by nlinarith + omega + +-- `RoundCaller` +def exception_done_side (n : ℕ) (output : ListBlank (Fin 2)) : Cfg (Fin 2) (Fin 6) := + common_left_wall {{B}}> ((C8 ++ A8 ++ U ^ (2 * n)) +> output) + +theorem exception_exit_side (k : ℕ) (output : ListBlank (Fin 2)) : + ((exception_call_left 0 k) <{{F}} output) [source_tm]⊢⁺ + exception_done_side (k + 1) output := by + unfold exception_call_left exception_done_side + rw [Nat.mul_zero, pow_zero_list, List.append_nil, pow_add_list X4 (2 * k) 5, + List.append_assoc, append_assoc] + refine stepStar_stepPlus_trans (raw_XX_returns k ((X4 ^ 5 ++ [1, 0, 1]) +> default) output) ?_ + have hbase := exception_exit_base (U ^ (2 * k) +> output) + rw [show 2 * (k + 1) = 2 + 2 * k by omega, pow_add_list U 2 (2 * k)] + simpa only [List.append_assoc, append_assoc] using hbase + +theorem exception_exit_zero_side (output : ListBlank (Fin 2)) : + ((exception_pre_left 0) <{{F}} output) [source_tm]⊢⁺ + exception_done_side 0 output := by + unfold exception_pre_left exception_done_side + have h0 : (([0] : List (Fin 2)) ^ 9 +> (default : ListBlank (Fin 2))) = default := + BoundedConfig.all0_spec (a := ([0] : List (Fin 2)) ^ 9) (by decide) + have h := run1Steps_spec source_tm 114 + ⟨[], [1, 0, 1, 0] ++ V4 ^ 2 ++ [1, 0, 1] ++ ([0] : List (Fin 2)) ^ 9, F, .left⟩ + ⟨Q8, C8 ++ A8, B, .right⟩ + (by decide) (by decide) default output + simpa only [BoundedConfig.toCfg, common_left_wall, Nat.mul_zero, Nat.zero_add, pow_zero_list, + List.append_nil, List.append_assoc, append_assoc, append_nil, h0] using h + +theorem exception_calls_side (k : ℕ) (input output : ListBlank (Fin 2)) + (hright : SideRLs source_tm (hashes ^ (k + 1)) input output) : + ((exception_call_left k 0) {{B}}> input) [source_tm]⊢⁺ + ((exception_call_left 0 k) <{{F}} output) := by + have hright' : SideRLs source_tm (lrcons (B, []) ([left_hash] ^ k) (F, [])) input output := by + rw [lrcons_same] + exact hright + have hleft : SideRLs (flipTM source_tm) ([left_hash] ^ k) + (exception_call_left k 0) (exception_call_left 0 k) := by + simpa only [Nat.zero_add] using exception_relaunches k 0 + exact SideRLs.concat hleft hright' + +theorem exception_pre_from_side (n : ℕ) (input output : ListBlank (Fin 2)) + (hright : SideRLs source_tm (hashes ^ n) input output) : + ((exception_pre_left n) <{{F}} input) [source_tm]⊢⁺ + exception_done_side n output := by + rcases n with _ | k + · cases hright + exact exception_exit_zero_side _ + · exact stepPlus_trans (exception_launch_progress k input) + (stepPlus_trans (exception_calls_side k input output hright) (exception_exit_side k output)) + +theorem exception_pre_from_side_word (n : ℕ) (input output : List (Fin 2)) + (hright : SideRLs source_tm (hashes ^ n) (input +> default) (output +> default)) : + ((exception_pre_left n) <{{F}} (input +> default)) [source_tm]⊢⁺ + exception_done n output := by + have h := exception_pre_from_side n (input +> default) (output +> default) hright + unfold exception_done_side at h + unfold exception_done + simpa only [List.append_assoc, append_assoc] using h + +theorem ordinary_raw_pre_left (n : ℕ) : + ([1, 0, 1] +> ordinary_left (2 * n + 1)) = exception_pre_left n := by + simpa only [ordinary_left, common_left_wall, List.append_assoc, append_assoc] using + exception_pre_left_direct n + +theorem ordinary_raw_pre_left_count (tally n : ℕ) (ht : tally = 2 * n + 1) : + ([1, 0, 1] +> ordinary_left tally) = exception_pre_left n := by + rw [ht, ordinary_raw_pre_left] + +theorem exception_relaunches_partial (h r finished : ℕ) : + SideRLs (flipTM source_tm) ([left_hash] ^ h) + (exception_call_left (h + r) finished) + (exception_call_left r (finished + h)) := by + induction h generalizing finished with + | zero => + simp only [pow_zero_list, Nat.zero_add, Nat.add_zero] + exact .nil _ + | succ h ih => + rw [pow_succ_list, show h + 1 + r = (h + r) + 1 by omega] + have hstep := (exception_relaunch_side (h + r) finished).trans (ih (finished + 1)) + simpa only [Nat.add_right_comm finished 1 h, Nat.add_assoc] using hstep + +theorem exception_partial_side (h r finished : ℕ) (input output : ListBlank (Fin 2)) + (hright : SideRLs source_tm (hashes ^ h) input output) : + ((exception_call_left (h + r) finished) {{B}}> input) [source_tm]⊢* + ((exception_call_left r (finished + h)) {{B}}> output) := by + rcases h with _ | h + · cases hright + simp only [Nat.zero_add, Nat.add_zero] + exact stepStar_refl source_tm _ + · refine stepPlus_to_stepStar ?_ + have hright' : SideRLs source_tm (lrcons (B, []) ([left_hash] ^ h) (F, [])) input output := by + rw [lrcons_same] + exact hright + have hleft : SideRLs (flipTM source_tm) ([left_hash] ^ h) + (exception_call_left (h + 1 + r) finished) + (exception_call_left (1 + r) (finished + h)) := by + simpa only [Nat.add_assoc] using exception_relaunches_partial h (1 + r) finished + refine stepPlus_trans (SideRLs.concat hleft hright') ?_ + rw [show 1 + r = r + 1 by omega, show finished + (h + 1) = (finished + h) + 1 by omega] + exact (exception_relaunch_side r (finished + h)).elim_single_left output + +theorem exception_launch_partial_side (h r : ℕ) (input output : ListBlank (Fin 2)) + (hright : SideRLs source_tm (hashes ^ h) input output) : + ((exception_pre_left (h + r + 1)) <{{F}} input) [source_tm]⊢⁺ + ((exception_call_left r h) {{B}}> output) := by + refine stepPlus_stepStar_trans (exception_launch_progress (h + r) input) ?_ + simpa only [Nat.zero_add] using exception_partial_side h r 0 input output hright + +-- `OpeningLate` +def fourth_output : List (Fin 2) := A8 ^ 29 ++ D8 ++ D8 ++ A8 ++ U ++ E8 ++ A8 +def fourth_raw_output : List (Fin 2) := E8 ^ 30 ++ D8 ++ A8 ++ U ++ E8 ++ A8 + +theorem fourth_raw (l : ListBlank (Fin 2)) : + (l {{B}}> ((B8 ^ 30 ++ fourth_tail) +> default)) [source_tm]⊢⁺ + (([1, 0, 1] +> l) <{{F}} (fourth_raw_output +> default)) := by + have h := check_r0inf_spec (M := source_tm) (n := 1079) + (l₁ := []) (r₁ := B8 ^ 30 ++ fourth_tail) + (l₂ := fourth_raw_output) (r₂ := [1, 0, 1]) + (q₁ := B) (q₂ := F) (d₁ := .right) (d₂ := .left) (by decide) l + simpa only [BoundedConfig.toCfg, append_nil] using h + +theorem fourth_decode : + SegRLs source_tm (hashes ^ opening_n4) [] fourth_raw_output fourth_output := by + have h := E_decode_spec 30 1610612734 + have he : E_decode 30 1610612734 = (List.replicate 29 SA ++ [SD], 0) := by decide + rw [he, ← n4_binary] at h + have hwords : sdigits_word (List.replicate 29 SA ++ [SD]) = A8 ^ 29 ++ D8 := rfl + rw [hwords] at h + have hfull := h.concat (SegRLs.nil (M := source_tm) (D8 ++ A8 ++ U ++ E8 ++ A8)) + unfold fourth_raw_output fourth_output + simpa only [List.append_assoc] using hfull + +theorem fourth_frontier_to_done : + ((ordinary_left (2 * opening_n4 + 1)) {{B}}> ((B8 ^ 30 ++ fourth_tail) +> default)) + [source_tm]⊢⁺ exception_done opening_n4 fourth_output := by + refine stepPlus_trans (fourth_raw (ordinary_left (2 * opening_n4 + 1))) ?_ + rw [ordinary_raw_pre_left] + exact exception_pre_from_seg opening_n4 fourth_raw_output fourth_output fourth_decode + +theorem fourth_cd_to_fossil : + (exception_done opening_n4 fourth_output) [source_tm]⊢⁺ + ((ordinary_left (cd_calls opening_n4)) {{B}}> + ((A8 ^ opening_n4 ++ fossil_start 30) +> default)) := by + have hw : cd_output opening_n4 ++ fourth_output = A8 ^ opening_n4 ++ fossil_start 30 := by + unfold cd_output fourth_output fossil_start + have ha30 : A8 ^ 30 = A8 ++ A8 ^ 29 := rfl + rw [ha30] + simp only [List.append_assoc] + have h := exception_done_cd opening_n4 fourth_output (by + have hge := n4_large + generalize opening_n4 = n4 at hge + omega) + unfold after_cd at h + rwa [hw] at h + +theorem fossil_calls_positive_formula (p k : ℕ) (hp : 1 ≤ p) : + fossil_calls p k = 2 ^ (p - 1) * ((1292 * 2 ^ (2 * k) + 4) / 3) - 1 := by + rcases p with _ | p + · omega + · simpa using fossil_count_formula p k + +theorem fifth_total_tally_generic (n : ℕ) (hn : 2 ≤ n) : + cd_calls n + fossil_calls n 15 = 2 * opening_decode_calls (n - 2) + 1 := by + unfold cd_calls + rw [fossil_calls_positive_formula n 15 (by omega), + opening_decode_calls_formula (n - 2), + show n - 2 + 2 = n by omega, + show 2 * 15 = 30 by omega] + have h1 : 2 ^ n = 4 * 2 ^ (n - 2) := by + have hn2 : n = (n - 2) + 2 := by omega + conv_lhs => rw [hn2] + rw [Nat.pow_add] + ring + have h2 : 2 ^ (n - 1) = 2 * 2 ^ (n - 2) := by + have hn1 : n - 1 = (n - 2) + 1 := by omega + conv_lhs => rw [hn1] + rw [Nat.pow_succ] + ring + rw [h1, h2] + set P := 2 ^ (n - 2) + set Q := (1292 * 2 ^ 30 + 4) / 3 + have hpow : 1 ≤ P := Nat.one_le_two_pow + have hq : 1 ≤ Q := by decide + have hPQ : 2 * P * Q = 2 * (P * Q) := by ring + have hpos : 1 ≤ P * Q := Nat.mul_pos hpow hq + omega + +theorem fifth_total_tally : + cd_calls opening_n4 + fossil_calls opening_n4 15 = + 2 * opening_decode_calls (opening_n4 - 2) + 1 := + fifth_total_tally_generic opening_n4 (by + have hge := n4_large + generalize opening_n4 = n4 at hge + omega) + +def fifth_output : List (Fin 2) := + A8 ^ (opening_n4 - 2) ++ sdigits_word opening_digits ++ U ^ 3 ++ A8 ++ [1, 1] + +theorem fossil_to_fifth_frontier : + ((ordinary_left (cd_calls opening_n4)) {{B}}> + ((A8 ^ opening_n4 ++ fossil_start 30) +> default)) [source_tm]⊢* + ((ordinary_left (2 * opening_decode_calls (opening_n4 - 2) + 1)) {{B}}> + ((B8 ^ (opening_n4 + 35) ++ U ++ B8 ++ [1, 1]) +> default)) := by + have h := ordinary_side_run (fossil_calls opening_n4 15) (cd_calls opening_n4) + ((A8 ^ opening_n4 ++ fossil_start 30) +> default) + ((B8 ^ (opening_n4 + 2 * 15 + 5) ++ U ++ B8 ++ [1, 1]) +> default) + (fossil_run opening_n4 15) + have hexp : opening_n4 + 2 * 15 + 5 = opening_n4 + 35 := by + generalize opening_n4 = n4 + omega + rw [fifth_total_tally, hexp] at h + exact h + +theorem fifth_frontier_to_done_generic (n : ℕ) (hn : 2 ≤ n) : + ((ordinary_left (2 * opening_decode_calls (n - 2) + 1)) {{B}}> + ((B8 ^ (n + 35) ++ U ++ B8 ++ [1, 1]) +> default)) [source_tm]⊢⁺ + exception_done (opening_decode_calls (n - 2)) + (A8 ^ (n - 2) ++ sdigits_word opening_digits ++ U ^ 3 ++ A8 ++ [1, 1]) := by + have hraw := raw_tail_column 0 (n + 34) + (ordinary_left (2 * opening_decode_calls (n - 2) + 1)) (by decide) + unfold tail_word y_after at hraw + rw [show n + 34 + 1 = n + 35 by omega, pow_one_list] at hraw + have hraw' : ((ordinary_left (2 * opening_decode_calls (n - 2) + 1)) {{B}}> + ((B8 ^ (n + 35) ++ U ++ B8 ++ [1, 1]) +> default)) [source_tm]⊢⁺ + ((exception_pre_left (opening_decode_calls (n - 2))) <{{F}} + ((E8 ^ (n + 34) ++ U ^ 3 ++ A8) +> default)) := by + rw [← ordinary_raw_pre_left] + simpa only [List.append_assoc, append_assoc] using hraw + refine stepPlus_trans hraw' ?_ + have hdec := opening_decode (n - 2) + rw [show n - 2 + 36 = n + 34 by omega] at hdec + exact exception_pre_from_side_word (opening_decode_calls (n - 2)) _ _ hdec + +theorem fifth_frontier_to_done : + ((ordinary_left (2 * opening_decode_calls (opening_n4 - 2) + 1)) {{B}}> + ((B8 ^ (opening_n4 + 35) ++ U ++ B8 ++ [1, 1]) +> default)) [source_tm]⊢⁺ + exception_done (opening_decode_calls (opening_n4 - 2)) fifth_output := + fifth_frontier_to_done_generic opening_n4 (by + have hge := n4_large + generalize opening_n4 = n4 at hge + omega) + +theorem opening_D_to_fifth_done : + (default {{D}}> default) [source_tm]⊢* + exception_done (opening_decode_calls (opening_n4 - 2)) fifth_output := by + refine stepStar_trans opening_D_to_fourth_frontier ?_ + refine stepPlus_to_stepStar ?_ + refine stepPlus_trans fourth_frontier_to_done ?_ + refine stepPlus_trans fourth_cd_to_fossil ?_ + exact stepStar_stepPlus_trans fossil_to_fifth_frontier fifth_frontier_to_done + +-- ============================================================================ +-- 9. `RoundDecode`, `TailCases` & `FiniteDecode` (`PR_SOBCv10.v` lines 1764–2119) +-- ============================================================================ + +def decode_budget (r : ℕ) : ℕ := ceil_half r - 2 + +theorem column_decode_budget (c c' : BinaryColumn) (r : ℕ) + (hr : 4 ≤ r) (hstep : column_step (decide (r % 2 = 1)) c c') : + column_required (decode_budget r) c' = + decode_budget (r * 2 ^ column_width c - column_value c) := by + rcases hstep with ⟨he, hv⟩ + have hbound := binary_column_value_bound c + unfold column_required column_next_value column_width column_value at * + rw [he, hv] + unfold decode_budget + rw [ceil_half_scaled_sub r (c.column_e + 1) (digits_value c.column_digits) + (by omega) (by omega) hbound] + rw [show c.column_e + 1 - 1 = c.column_e by omega] + rw [Nat.pow_succ] at hbound ⊢ + set b := 2 ^ c.column_e + have hb : 1 ≤ b := Nat.one_le_two_pow + rcases Nat.mod_two_eq_zero_or_one r with hmod | hmod + · have hdec : decide (r % 2 = 1) = false := decide_eq_false (by omega) + rw [hdec] + simp only [Bool.false_eq_true, ↓reduceIte] + have hceil : ceil_half r = r / 2 := by unfold ceil_half; omega + rw [hceil] + have hr2 : 2 * (r / 2) = r := by omega + have hsub : (r / 2 - 2 + 1) * (b * 2) = r * b - 2 * b := by + rw [show r / 2 - 2 + 1 = r / 2 - 1 by omega, Nat.sub_mul, Nat.one_mul, + show (r / 2) * (b * 2) = (2 * (r / 2)) * b by ring, hr2, Nat.mul_comm b 2] + have hrb : 4 * b ≤ r * b := by nlinarith + have hdiv : digits_value c.column_digits / 2 < b := by omega + rw [hsub] + omega + · have hdec : decide (r % 2 = 1) = true := decide_eq_true hmod + rw [hdec] + simp only [↓reduceIte] + have hceil : ceil_half r = r / 2 + 1 := by unfold ceil_half; omega + rw [hceil] + have hr2 : 2 * (r / 2) + 1 = r := by omega + have hr2' : 2 * (r / 2) = r - 1 := by omega + have hsub : (r / 2 + 1 - 2 + 1) * (b * 2) = r * b - b := by + rw [show r / 2 + 1 - 2 + 1 = r / 2 by omega, + show (r / 2) * (b * 2) = (2 * (r / 2)) * b by ring, + hr2', Nat.sub_mul, Nat.one_mul] + have hrb : 4 * b ≤ r * b := by nlinarith + have hdiv : digits_value c.column_digits / 2 < b := by omega + rw [hsub] + omega + +def right_remaining : List BinaryColumn → ℕ → ℕ + | [], r => r + | c :: rest, r => right_remaining rest r * 2 ^ column_width c - column_value c + +def columns_input_count : List BinaryColumn → ℕ → ℕ + | [], out => out + | c :: rest, out => column_required (columns_input_count rest out) c + +theorem right_remaining_lower (cs : List BinaryColumn) (r : ℕ) (hr : 1 ≤ r) : + r ≤ right_remaining cs r := by + induction cs with + | nil => exact le_rfl + | cons c cs ih => + dsimp only [right_remaining] + have hv := binary_column_value_bound c + change column_value c < 2 ^ column_width c at hv + have hpow : 2 ≤ 2 ^ column_width c := by + unfold column_width + have : 1 ≤ 2 ^ c.column_e := Nat.one_le_two_pow + rw [Nat.pow_succ] + omega + have hge : r + column_value c ≤ right_remaining cs r * 2 ^ column_width c := by nlinarith + omega + +theorem right_remaining_head_parity (c : BinaryColumn) (cs : List BinaryColumn) (r : ℕ) + (hr : 1 ≤ r) : + decide (right_remaining (c :: cs) r % 2 = 1) = decide (column_value c % 2 = 1) := by + have hlower := right_remaining_lower cs r hr + have hv := binary_column_value_bound c + change column_value c < 2 ^ column_width c at hv + have heq : right_remaining (c :: cs) r + column_value c = + 2 * (right_remaining cs r * 2 ^ c.column_e) := by + dsimp only [right_remaining] + unfold column_width at hv ⊢ + rw [Nat.pow_succ] at hv ⊢ + have hge : column_value c ≤ right_remaining cs r * (2 ^ c.column_e * 2) := by nlinarith + have hm : right_remaining cs r * (2 ^ c.column_e * 2) = + 2 * (right_remaining cs r * 2 ^ c.column_e) := by ring + omega + have hmod : (right_remaining (c :: cs) r % 2 = 1) ↔ (column_value c % 2 = 1) := by omega + exact decide_eq_decide.mpr hmod + +theorem columns_decode_budget (cs cs' : List BinaryColumn) (r : ℕ) + (hr : 4 ≤ r) (hstep : tail_columns_step (decide (r % 2 = 1)) cs cs') : + columns_input_count cs' (decode_budget r) = decode_budget (right_remaining cs r) := by + induction cs generalizing cs' with + | nil => + rcases cs' with _ | ⟨c', cs'⟩ + · rfl + · cases hstep + | cons c cs ih => + rcases cs' with _ | ⟨c', cs'⟩ + · cases hstep + · rcases hstep with ⟨hc, hrest⟩ + dsimp [columns_input_count, right_remaining] + rw [ih cs' hrest] + apply column_decode_budget + · have := right_remaining_lower cs r (by omega) + omega + · rcases cs with _ | ⟨d, rest⟩ + · exact hc + · rw [right_remaining_head_parity d rest r (by omega)] + exact hc + +theorem right_remaining_finish (cs : List BinaryColumn) (last : List SDigit) (lv : ℕ) : + right_remaining cs (last_finish_count last lv + 1) = + columns_finish_count cs (last_finish_count last lv) + 1 := by + induction cs with + | nil => rfl + | cons c cs ih => + dsimp [right_remaining, columns_finish_count] + rw [ih] + have h := bfinish_count_value c.column_digits + (columns_finish_count cs (last_finish_count last lv)) + rw [c.column_length] at h + change bfinish_count c.column_digits (columns_finish_count cs (last_finish_count last lv)) + + column_value c + 1 = + (columns_finish_count cs (last_finish_count last lv) + 1) * 2 ^ column_width c at h + omega + +def mixed_with_tail : List BinaryColumn → List (Fin 2) → List (Fin 2) + | [], tail => tail + | c :: rest, tail => mixed_column_word c ++ U ^ 2 ++ mixed_with_tail rest tail + +theorem mixed_with_tail_spec (cs : List BinaryColumn) (out : ℕ) (input output : List (Fin 2)) + (h : SideRLs source_tm (hashes ^ out) (input +> default) (output +> default)) : + SideRLs source_tm (hashes ^ columns_input_count cs out) + (mixed_with_tail cs input +> default) + (columns_with_tail cs output +> default) := by + induction cs with + | nil => exact h + | cons c cs ih => + dsimp only [columns_input_count, mixed_with_tail, columns_with_tail] + have hp := (mixed_column_spec c (columns_input_count cs out)).concat + (hashes_U_run (columns_input_count cs out) 2) + have hfull := hp.sideRLs_concat ih + simpa only [List.append_assoc, append_assoc] using hfull + +theorem mixed_with_tail_same_width (b : Bool) (cs cs' : List BinaryColumn) (input : List (Fin 2)) + (hstep : tail_columns_step b cs cs') : + mixed_with_tail cs input = mixed_with_tail cs' input := by + induction cs generalizing cs' with + | nil => + rcases cs' with _ | _ + · rfl + · cases hstep + | cons c cs ih => + rcases cs' with _ | ⟨c', cs'⟩ + · cases hstep + · rcases hstep with ⟨⟨he, _⟩, hrest⟩ + dsimp only [mixed_with_tail] + have hw : mixed_column_word c = mixed_column_word c' := by + unfold mixed_column_word + rw [he] + rw [hw, ih cs' hrest] + +theorem tail_columns_decode (cs cs' : List BinaryColumn) (r : ℕ) (input output : List (Fin 2)) + (hr : 4 ≤ r) (hstep : tail_columns_step (decide (r % 2 = 1)) cs cs') + (htail : SideRLs source_tm (hashes ^ decode_budget r) (input +> default) (output +> default)) : + SideRLs source_tm (hashes ^ decode_budget (right_remaining cs r)) + (mixed_with_tail cs input +> default) + (columns_with_tail cs' output +> default) := by + rw [← columns_decode_budget cs cs' r hr hstep, + mixed_with_tail_same_width _ cs cs' input hstep] + exact mixed_with_tail_spec cs' (decode_budget r) input output htail + +theorem post_unary_even (current previous : ℕ) : + round_post_unary current previous = 2 * (round_post_unary current previous / 2) := by + rw [round_post_unary_half_formula, round_post_unary_formula] + set h := half_parameter current + set body := 1 + geom4n (previous + 4) + 2 ^ (2 * (previous + 4) + 1) + have hp : 2 ^ (h + 2) = 2 * 2 ^ (h + 1) := by + rw [show h + 2 = (h + 1) + 1 by omega, Nat.pow_succ]; ring + rw [hp] + have hpos : 1 ≤ 2 ^ (h + 1) * body := by + have : 1 ≤ 2 ^ (h + 1) := Nat.one_le_two_pow + have : 1 ≤ body := by + dsimp only [body] + have := Nat.zero_le (geom4n (previous + 4)) + have := Nat.zero_le (2 ^ (2 * (previous + 4) + 1)) + omega + nlinarith + have hm : 2 * 2 ^ (h + 1) * body = 2 * (2 ^ (h + 1) * body) := by ring + omega + +theorem primary_decode_tally (current previous r : ℕ) (hr : 4 ≤ r) (hodd : r % 2 = 1) : + round_post_unary current previous + (r * 2 ^ round_primary_width current previous - 1) = + 2 * column_required (decode_budget r) (round_outer_column current previous) + 1 := by + have hv := round_unary_decodes_outer current previous + have hu := post_unary_even current previous + have hp := round_primary_width_positive current previous + unfold column_required round_outer_column + dsimp only + rw [show round_primary_width current previous - 1 + 1 = + round_primary_width current previous by omega] + set P := round_primary_width current previous + have hpow : 2 ^ P = 2 * 2 ^ (P - 1) := by + have hp1 : P = (P - 1) + 1 := by omega + conv_lhs => rw [hp1] + rw [Nat.pow_succ]; ring + have hb : 1 ≤ 2 ^ (P - 1) := Nat.one_le_two_pow + unfold decode_budget ceil_half + rw [hpow] + have h1 : ((r + 1) / 2 - 2 + 1) * (2 * 2 ^ (P - 1)) = r * 2 ^ (P - 1) - 2 ^ (P - 1) := by + have hr2 : 2 * ((r + 1) / 2 - 2 + 1) = r - 1 := by omega + rw [show ((r + 1) / 2 - 2 + 1) * (2 * 2 ^ (P - 1)) = + (2 * ((r + 1) / 2 - 2 + 1)) * 2 ^ (P - 1) by ring, + hr2, Nat.sub_mul, Nat.one_mul] + rw [h1] + have hrb : 4 * 2 ^ (P - 1) ≤ r * 2 ^ (P - 1) := Nat.mul_le_mul_right _ hr + have hm : r * (2 * 2 ^ (P - 1)) = 2 * (r * 2 ^ (P - 1)) := by ring + omega + +-- `TailCases` +def decoded_last7 : List SDigit := (E_decode 28 341136723).1 +def decoded_last8 : List SDigit := (E_decode 27 768955732).1 +def decoded_last9 : List SDigit := (E_decode 26 18175315).1 + +theorem decode_last7 : E_decode 28 341136723 = (decoded_last7, 0) := by decide +theorem decode_last8 : E_decode 27 768955732 = (decoded_last8, 3) := by decide +theorem decode_last9 : E_decode 26 18175315 = (decoded_last9, 0) := by decide +theorem decode_trigger_frontier : E_decode 25 134217725 = (List.replicate 25 SB, 1) := by decide + +theorem decoded_last_checkpoints : + decoded_last7.length = 28 ∧ sdigits_value decoded_last7 = -195734187 ∧ + decoded_last8.length = 27 ∧ sdigits_value decoded_last8 = 97867094 ∧ + decoded_last9.length = 26 ∧ sdigits_value decoded_last9 = -116042411 := by + decide + +theorem E_decode_tail_run (width calls : ℕ) (ds : List SDigit) (out k lv : ℕ) + (hdecode : E_decode width calls = (ds, out)) + (htail : SideRLs source_tm (hashes ^ out) (y_after k +> default) (y_after lv +> default)) : + SideRLs source_tm (hashes ^ calls) + ((E8 ^ width ++ U ^ (2 * k + 3) ++ y_after k) +> default) + ((sdigits_word ds ++ U ^ (2 * k + 3) ++ y_after lv) +> default) := by + have hdigits := E_decode_spec width calls + rw [hdecode] at hdigits + have hprefix := hdigits.concat (hashes_U_run out (2 * k + 3)) + have hfull := hprefix.sideRLs_concat htail + simpa only [List.append_assoc, append_assoc] using hfull + +theorem last_case6_return : + SideRLs source_tm (hashes ^ 341136723) + ((E8 ^ 28 ++ U ^ 5 ++ y_after 1) +> default) + ((sdigits_word decoded_last7 ++ U ^ 5 ++ y_after 1) +> default) := + E_decode_tail_run 28 341136723 decoded_last7 0 1 1 decode_last7 (.nil _) + +theorem last_case7_return : + SideRLs source_tm (hashes ^ 768955732) + ((E8 ^ 27 ++ U ^ 7 ++ y_after 2) +> default) + ((sdigits_word decoded_last8 ++ U ^ 7 ++ y_after 5) +> default) := + E_decode_tail_run 27 768955732 decoded_last8 3 2 5 decode_last8 (tail_level_finish 2 (by decide)) + +theorem last_case8_return : + SideRLs source_tm (hashes ^ 18175315) + ((E8 ^ 26 ++ U ^ 9 ++ y_after 3) +> default) + ((sdigits_word decoded_last9 ++ U ^ 9 ++ y_after 3) +> default) := + E_decode_tail_run 26 18175315 decoded_last9 0 3 3 decode_last9 (.nil _) + +theorem sdigits_word_replicate_SB (n : ℕ) : sdigits_word (List.replicate n SB) = B8 ^ n := by + induction n with + | zero => rfl + | succ n ih => simp [List.replicate_succ, sdigits_word, sdigit_word, ih] + +theorem last_case9_frontier : + SideRLs source_tm (hashes ^ 134217725) + ((E8 ^ 25 ++ U ^ 11 ++ y_after 4) +> default) + ((B8 ^ 25 ++ U ^ 11 ++ y_after 5) +> default) := by + have h := E_decode_tail_run 25 134217725 (List.replicate 25 SB) 1 4 5 + decode_trigger_frontier (tail_level_finish 4 (by decide)) + rwa [sdigits_word_replicate_SB 25] at h + +-- `FiniteDecode` +def phase_R : ℕ → ℕ + | 1 => 682273449 + | 2 => 1537911467 + | 3 => 36350634 + | _ => 317369003 + +theorem phase_R_value (k : ℕ) (hk1 : 1 ≤ k) (hk4 : k ≤ 4) : + (6 - (phase_lv k : ℤ)) * pow2 (phase_width k) - phase_value k = (phase_R k : ℤ) := by + rcases k with _ | _ | _ | _ | _ | k <;> try omega + all_goals decide + +theorem finite_last_R (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) (k lv : + ℕ) + (hpre : finite_round_pre current previous zs last k lv) : + last_finish_count last lv + 1 = phase_R k := by + rcases hpre with ⟨⟨hk1, hk4⟩, _, _, _, hlen, hval, hlv⟩ + have hlvbound : lv ≤ 5 := by + rw [hlv] + rcases k with _ | _ | _ | _ | _ | k <;> try omega + all_goals decide + have h := sfinish_value last (5 - lv) + change (last_finish_count last lv : ℤ) + sdigits_value last + 1 = + (((5 - lv : ℕ) : ℤ) + 1) * pow2 last.length at h + have hsub : ((5 - lv : ℕ) : ℤ) = 5 - (lv : ℤ) := by omega + rw [hsub, hlen, hval, hlv, show (5 - (phase_lv k : ℤ) + 1) = 6 - (phase_lv k : ℤ) by ring] at h + have hr := phase_R_value k hk1 hk4 + have hZ : ((last_finish_count last lv + 1 : ℕ) : ℤ) = (phase_R k : ℤ) := by + rw [hlv] + push_cast + linarith + exact Int.ofNat.inj hZ + +theorem phase_R_large (k : ℕ) : 4 ≤ phase_R k := by + unfold phase_R + split <;> decide + +def next_last : ℕ → List SDigit + | 1 => decoded_last7 + | 2 => decoded_last8 + | _ => decoded_last9 + +def phase_budget_val : ℕ → ℕ + | 1 => 341136723 + | 2 => 768955732 + | _ => 18175315 + +theorem phase_decode_budget (k : ℕ) (hk1 : 1 ≤ k) (hk3 : k ≤ 3) : + decode_budget (phase_R k) = phase_budget_val k := by + rcases k with _ | _ | _ | _ | k <;> try omega + all_goals decide + +theorem finite_last_decode (k : ℕ) (hk1 : 1 ≤ k) (hk3 : k ≤ 3) : + SideRLs source_tm (hashes ^ decode_budget (phase_R k)) + ((E8 ^ (phase_width k - 1) ++ U ^ (2 * k + 3) ++ y_after k) +> default) + ((sdigits_word (next_last k) ++ U ^ (2 * k + 3) ++ y_after (phase_lv (k + 1))) +> default) := + by + rw [phase_decode_budget k hk1 hk3] + rcases k with _ | _ | _ | _ | k <;> try omega + · exact last_case6_return + · exact last_case7_return + · exact last_case8_return + +theorem next_last_checkpoints (k : ℕ) (hk1 : 1 ≤ k) (hk3 : k ≤ 3) : + (next_last k).length = phase_width (k + 1) ∧ + sdigits_value (next_last k) = phase_value (k + 1) := by + obtain ⟨h1, h2, h3, h4, h5, h6⟩ := decoded_last_checkpoints + rcases k with _ | _ | _ | _ | k <;> try omega + · exact ⟨h1, h2⟩ + · exact ⟨h3, h4⟩ + · exact ⟨h5, h6⟩ + +theorem phase_R_parity (k : ℕ) : + (phase_R k % 2 = 1) ↔ (phase_value k % 2 = 1) := by + rcases k with _ | _ | _ | _ | k + · decide + · decide + · decide + · decide + · have h1 : phase_R (k + 4) = 317369003 := rfl + have h2 : phase_value (k + 4) = -116042411 := rfl + rw [h1, h2] + decide + +theorem finite_suffix_odd (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) (k + lv : ℕ) + (hpre : finite_round_pre current previous zs last k lv) : + right_remaining zs (phase_R k) % 2 = 1 := by + rcases hpre with ⟨_, _, hodd, _, _, hval, _⟩ + rcases zs with _ | ⟨c, zs⟩ + · dsimp [right_remaining] + rw [phase_R_parity, ← hval] + exact hodd + · have hp := right_remaining_head_parity c zs (phase_R k) (by have := phase_R_large k; omega) + exact of_decide_eq_true (hp.trans (decide_eq_true hodd)) + +theorem finite_columns_decode (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) + (k lv : ℕ) + (hpre : finite_round_pre current previous zs last k lv) (hk3 : k ≤ 3) : + ∃ zs', + tail_columns_step (decide (phase_R k % 2 = 1)) zs zs' ∧ + (∀ c' ∈ z_column previous :: zs', column_budget (4 - (k + 1)) c') ∧ + SideRLs source_tm (hashes ^ decode_budget (right_remaining zs (phase_R k))) + (mixed_with_tail zs (E8 ^ (phase_width k - 1) ++ U ^ (2 * k + 3) ++ y_after k) +> default) + (columns_with_tail zs' + (sdigits_word (next_last k) ++ U ^ (2 * k + 3) ++ y_after (phase_lv (k + 1))) +> + default) := by + obtain ⟨zs', hstep, hbudget⟩ := tail_columns_round_budget k previous zs + (decide (phase_R k % 2 = 1)) hpre.fr_stage.1 hk3 hpre.fr_columns + refine ⟨zs', hstep, hbudget, ?_⟩ + exact tail_columns_decode zs zs' (phase_R k) _ _ (phase_R_large k) hstep + (finite_last_decode k hpre.fr_stage.1 hk3) + +-- ============================================================================ +-- 10. `FrontierBridge`, `RoundAssembly`, `WidthBounds`, `FiniteComplete`, `FinalTrigger` & +-- `FiniteOrbit` +-- ============================================================================ + +def tail_frontier_state (unary primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) (k : ℕ) : + Cfg (Fin 2) (Fin 6) := + (ordinary_left unary) {{B}}> (tail_frontier primary zs last k +> default) + +theorem post_tail_to_frontier (unary primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) + (k lv : ℕ) (hlv : lv ≤ 5) : + (post_ca_tail unary primary zs last k lv) [source_tm]⊢* + tail_frontier_state (unary + tail_finish_count primary zs last lv) primary zs last k := + ordinary_side_run (tail_finish_count primary zs last lv) unary + (tail_layout primary zs last k lv +> default) + (tail_frontier primary zs last k +> default) + (tail_to_frontier primary zs last k lv hlv) + +theorem all_B_tail_full (zs : List BinaryColumn) (last k : ℕ) : + all_B_with_tail zs (B8 ^ (last + 1) ++ tail_word k) = + full_tail (zs.map BinaryColumn.column_e) last k := by + induction zs with + | nil => rfl + | cons c zs ih => + dsimp only [all_B_with_tail] + rw [List.map_cons, ih, full_tail_cons] + rfl + +theorem tail_frontier_full (primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) (k e : ℕ) + (hlen : last.length = e + 1) : + tail_frontier (primary + 1) zs last k = + full_tail (primary :: zs.map BinaryColumn.column_e) e k := by + unfold tail_frontier + rw [hlen, full_tail_cons, ← all_B_tail_full] + unfold tail_word + simp only [List.append_assoc] + +theorem post_tail_raw (unary primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) + (k lv e : ℕ) (hlv : lv ≤ 5) (hk : k ≤ 5) (hlen : last.length = e + 1) : + (post_ca_tail unary (primary + 1) zs last k lv) [source_tm]⊢⁺ + (([1, 0, 1] +> ordinary_left (unary + tail_finish_count (primary + 1) zs last lv)) <{{F}} + (mixed_tail (primary :: zs.map BinaryColumn.column_e) e k +> default)) := by + refine stepStar_stepPlus_trans (post_tail_to_frontier unary (primary + 1) zs last k lv hlv) ?_ + unfold tail_frontier_state + rw [tail_frontier_full primary zs last k e hlen] + exact raw_tail_columns (primary :: zs.map BinaryColumn.column_e) e k _ hk + +theorem mixed_tail_chain (cs : List BinaryColumn) (e k : ℕ) : + mixed_tail (cs.map BinaryColumn.column_e) e k = + mixed_with_tail cs (E8 ^ e ++ U ^ (2 * k + 3) ++ y_after k) := by + induction cs with + | nil => + unfold mixed_tail mixed_with_tail + simp [spaced_words, List.append_assoc] + | cons c cs ih => + rw [List.map_cons, mixed_tail_cons, ih] + dsimp only [mixed_with_tail, mixed_column_word] + +theorem tail_finish_equation (primary : ℕ) (zs : List BinaryColumn) (last : List SDigit) (lv : ℕ) : + tail_finish_count primary zs last lv + 1 = + (columns_finish_count zs (last_finish_count last lv) + 1) * 2 ^ primary := by + have h := bfinish_count_value (List.replicate primary BA) + (columns_finish_count zs (last_finish_count last lv)) + rw [List.length_replicate, digits_value_repeat_BA] at h + change tail_finish_count primary zs last lv + 0 + 1 = + (columns_finish_count zs (last_finish_count last lv) + 1) * 2 ^ primary at h + omega + +def finite_decode_count (current previous : ℕ) (zs : List BinaryColumn) (k : ℕ) : ℕ := + column_required (decode_budget (right_remaining zs (phase_R k))) + (round_outer_column current previous) + +def finite_decode_input (current previous : ℕ) (zs : List BinaryColumn) (k : ℕ) : List (Fin 2) := + mixed_with_tail (round_outer_column current previous :: zs) + (E8 ^ (phase_width k - 1) ++ U ^ (2 * k + 3) ++ y_after k) + +def finite_decode_output (current previous : ℕ) (zs' : List BinaryColumn) (k : ℕ) : List (Fin 2) := + columns_with_tail (round_outer_column current previous :: zs') + (sdigits_word (next_last k) ++ U ^ (2 * k + 3) ++ y_after (phase_lv (k + 1))) + +theorem finite_raw_to_pre (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) (k + lv : ℕ) + (hpre : finite_round_pre current previous zs last k lv) : + (post_ca_tail (round_post_unary current previous) + (round_primary_width current previous) zs last k lv) [source_tm]⊢⁺ + ((exception_pre_left (finite_decode_count current previous zs k)) <{{F}} + (finite_decode_input current previous zs k +> default)) := by + have hr := finite_last_R current previous zs last k lv hpre + have hodd := finite_suffix_odd current previous zs last k lv hpre + rcases hpre with ⟨⟨hk1, hk4⟩, _, _, _, hlen, _, hlv⟩ + have hlvbound : lv ≤ 5 := by + rw [hlv] + rcases k with _ | _ | _ | _ | _ | k <;> try omega + all_goals decide + have hp := round_primary_width_positive current previous + have hlen' : last.length = (phase_width k - 1) + 1 := by + rw [hlen]; unfold phase_width; omega + have hraw := post_tail_raw (round_post_unary current previous) + (round_primary_width current previous - 1) zs last k lv (phase_width k - 1) + hlvbound (by omega) hlen' + rw [show round_primary_width current previous - 1 + 1 = + round_primary_width current previous by omega] at hraw + have htally : round_post_unary current previous + + tail_finish_count (round_primary_width current previous) zs last lv = + 2 * finite_decode_count current previous zs k + 1 := by + have hcount := tail_finish_equation (round_primary_width current previous) zs last lv + rw [← right_remaining_finish, hr] at hcount + have hbase := phase_R_large k + have hlower := right_remaining_lower zs (phase_R k) (by omega) + have ht := primary_decode_tally current previous (right_remaining zs (phase_R k)) + (by omega) hodd + unfold finite_decode_count + omega + rw [ordinary_raw_pre_left_count _ _ htally] at hraw + unfold finite_decode_input + have hmap : ((round_primary_width current previous - 1) :: zs.map BinaryColumn.column_e) = + (round_outer_column current previous :: zs).map BinaryColumn.column_e := rfl + rw [hmap, mixed_tail_chain] at hraw + exact hraw + +theorem finite_decode_side (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) + (k lv : ℕ) (zs' : List BinaryColumn) + (hpre : finite_round_pre current previous zs last k lv) (hk3 : k ≤ 3) + (hstep : tail_columns_step (decide (phase_R k % 2 = 1)) zs zs') : + SideRLs source_tm (hashes ^ finite_decode_count current previous zs k) + (finite_decode_input current previous zs k +> default) + (finite_decode_output current previous zs' k +> default) := by + have htail := tail_columns_decode zs zs' (phase_R k) _ _ (phase_R_large k) hstep + (finite_last_decode k hpre.fr_stage.1 hk3) + have hp := (mixed_column_spec (round_outer_column current previous) + (decode_budget (right_remaining zs (phase_R k)))).concat + (hashes_U_run (decode_budget (right_remaining zs (phase_R k))) 2) + have hfull := hp.sideRLs_concat htail + unfold finite_decode_count finite_decode_input finite_decode_output + dsimp only [mixed_with_tail, columns_with_tail] + simpa only [List.append_assoc, append_assoc] using hfull + +theorem finite_exception_done (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) + (k lv : ℕ) (hpre : finite_round_pre current previous zs last k lv) (hk3 : k ≤ 3) : + ∃ zs', + tail_columns_step (decide (phase_R k % 2 = 1)) zs zs' ∧ + (∀ c' ∈ z_column previous :: zs', column_budget (4 - (k + 1)) c') ∧ + ((post_ca_tail (round_post_unary current previous) + (round_primary_width current previous) zs last k lv) [source_tm]⊢⁺ + exception_done (finite_decode_count current previous zs k) + (finite_decode_output current previous zs' k)) := by + obtain ⟨zs', hstep, hbudget, _⟩ := finite_columns_decode current previous zs last k lv hpre hk3 + refine ⟨zs', hstep, hbudget, ?_⟩ + refine stepPlus_trans (finite_raw_to_pre current previous zs last k lv hpre) ?_ + exact exception_pre_from_side_word _ _ _ + (finite_decode_side current previous zs last k lv zs' hpre hk3 hstep) + +theorem finite_done_to_next_post (current previous : ℕ) (zs' : List BinaryColumn) (k next : ℕ) : + (exception_done (half_parameter next) + (finite_decode_output current previous zs' k)) [source_tm]⊢⁺ + post_ca_tail (round_post_unary next current) (round_primary_width next current) + (z_column previous :: zs') (next_last k) (k + 1) (phase_lv (k + 1)) := by + set tail := sdigits_word (next_last k) ++ U ^ (2 * k + 3) ++ y_after (phase_lv (k + 1)) + set rest := + B8 ++ (digits_word A8 B8) (z_tail_digits previous) ++ U ^ 2 ++ columns_with_tail zs' tail + have hca := exception_done_ca (half_parameter next) (current + 4) rest + (by unfold half_parameter; omega) + have hlhs : exception_done (half_parameter next) (finite_decode_output current previous zs' k) = + exception_done (half_parameter next) + (A8 ^ (2 * (current + 4)) ++ B8 ++ B8 ++ A8 ++ B8 ++ A8 ++ rest) := by + unfold finite_decode_output exception_done + dsimp only [columns_with_tail] + rw [round_outer_column_word] + dsimp only [rest, tail] + have hexp1 : half_parameter current + 2 = 2 * (current + 4) := by unfold half_parameter; omega + rw [hexp1] + simp only [List.append_assoc] + have hrhs : ((ordinary_left (cd_calls (half_parameter next) + ca_calls (half_parameter next) + (current + 4))) {{B}}> + ((A8 ^ (half_parameter next + 2 * (current + 4) + 4) ++ U ^ 2 ++ B8 ++ B8 ++ rest) +> + default)) = + post_ca_tail (round_post_unary next current) (round_primary_width next current) + (z_column previous :: zs') (next_last k) (k + 1) (phase_lv (k + 1)) := by + unfold post_ca_tail round_post_unary round_primary_width + rw [tail_layout_chain] + dsimp only [columns_with_tail] + rw [z_column_word, z_digits_word_split, show 2 * (k + 1) + 1 = 2 * k + 3 by omega] + unfold rest tail + have hexp2 : half_parameter next + 2 * (current + 4) + 4 = + half_parameter next + half_parameter current + 6 := by unfold half_parameter; omega + rw [hexp2] + simp only [List.append_assoc, append_assoc] + rw [hlhs, ← hrhs] + exact hca + +-- `WidthBounds` +theorem outer_decode_even_ge6 (current previous out : ℕ) : + ∃ q, column_required out (round_outer_column current previous) = 2 * q ∧ 6 ≤ 2 * q := by + have hp := round_primary_width_positive current previous + unfold column_required round_outer_column + dsimp only + rw [show round_primary_width current previous - 1 + 1 = + round_primary_width current previous by omega, + round_outer_digits_value] + set P := round_primary_width current previous + have hp3 : 3 ≤ P := by dsimp [P]; unfold round_primary_width half_parameter; omega + have hsplit : 2 ^ P = 2 * 2 ^ (P - 1) := by + have hp1 : P = (P - 1) + 1 := by omega + conv_lhs => rw [hp1] + rw [Nat.pow_succ]; ring + have ha : 4 ≤ 2 ^ (P - 1) := by + rw [show P - 1 = (P - 3) + 2 by omega, Nat.pow_add] + have : 1 ≤ 2 ^ (P - 3) := Nat.one_le_two_pow + have h4 : (2 : ℕ) ^ 2 = 4 := rfl + rw [h4] + omega + have hh : 2 ^ (half_parameter current + 1) = 2 * 2 ^ (half_parameter current) := by + rw [Nat.pow_succ]; ring + rw [hh, hsplit] + set a := 2 ^ (P - 1) + set body := + 1 + geom4n (previous + 4) + 2 ^ (2 * (previous + 4) + 1) + 2 ^ (2 * (previous + 4) + 2) + set b := 2 ^ (half_parameter current) * body + have hoa : 4 ≤ (out + 1) * a := Nat.le_mul_of_pos_left a (by omega) |>.trans' ha + have hm1 : (out + 1) * (2 * a) = 2 * ((out + 1) * a) := by ring + have hm2 : 2 * 2 ^ (half_parameter current) * body = 2 * b := by dsimp only [b]; ring + refine ⟨(out + 1) * a - 1 + b, by omega, by omega⟩ + +theorem outer_decode_parameter (current previous out : ℕ) : + half_parameter ((column_required out (round_outer_column current previous) - 6) / 2) = + column_required out (round_outer_column current previous) := by + obtain ⟨q, hq, hge⟩ := outer_decode_even_ge6 current previous out + unfold half_parameter + omega + +theorem outer_decode_lower (current previous out : ℕ) : + 2 ^ round_primary_width current previous - 2 ≤ + column_required out (round_outer_column current previous) := by + have hp := round_primary_width_positive current previous + unfold column_required round_outer_column + dsimp only + rw [show round_primary_width current previous - 1 + 1 = + round_primary_width current previous by omega] + set P := round_primary_width current previous + have h1 : 2 ^ P ≤ (out + 1) * 2 ^ P := Nat.le_mul_of_pos_left (2 ^ P) (by omega) + omega + +theorem outer_decode_growth (current previous out suffix_width : ℕ) + (hwidth : 2 * suffix_width + 4 ≤ half_parameter previous + 1) : + 2 * (half_parameter current + 1 + half_parameter previous + suffix_width) + 4 ≤ + column_required out (round_outer_column current previous) + 1 := by + have hlower := outer_decode_lower current previous out + have hpow := pow2_linear_margin (half_parameter current + half_parameter previous) + unfold round_primary_width at hlower + rw [show half_parameter current + half_parameter previous + 6 = + (half_parameter current + half_parameter previous + 5) + 1 by omega, + Nat.pow_succ] at hlower + omega + +theorem tail_columns_step_width_sum (b : Bool) (cs cs' : List BinaryColumn) + (hstep : tail_columns_step b cs cs') : + columns_width_sum cs' = columns_width_sum cs := by + induction cs generalizing cs' with + | nil => + rcases cs' with _ | _ + · rfl + · cases hstep + | cons c cs ih => + rcases cs' with _ | ⟨c', cs'⟩ + · cases hstep + · rcases hstep with ⟨⟨he, _⟩, hrest⟩ + rw [columns_width_sum_cons, columns_width_sum_cons, ih cs' hrest, he] + +theorem tail_width_dominance_step (current previous next out : ℕ) (cs cs' : List BinaryColumn) + (last last' : List SDigit) (b : Bool) + (hstep : tail_columns_step b cs cs') + (hlast : last.length = last'.length + 1) + (hnext : half_parameter next = column_required out (round_outer_column current previous)) + (hw : 2 * (columns_width_sum cs + last.length) + 4 ≤ half_parameter previous + 1 ∧ + 2 * (half_parameter previous + 1 + columns_width_sum cs + last.length) + 4 ≤ + half_parameter current + 1) : + 2 * (columns_width_sum (z_column previous :: cs') + last'.length) + 4 ≤ + half_parameter current + 1 ∧ + 2 * (half_parameter current + 1 + columns_width_sum (z_column previous :: cs') + last'.length) + + 4 ≤ + half_parameter next + 1 := by + rcases hw with ⟨hprev, hcur⟩ + rw [columns_width_sum_cons, tail_columns_step_width_sum b cs cs' hstep, z_column_e, hnext] + have hgrowth := outer_decode_growth current previous out + (columns_width_sum cs + last.length) hprev + omega + +theorem tail_next_half_tally (current previous : ℕ) (cs : List BinaryColumn) (last : List SDigit) + (lv n : ℕ) (hlv : lv ≤ 5) + (htally : round_post_unary current previous + + tail_finish_count (round_primary_width current previous) cs last lv = 2 * n + 1) : + tail_next_half current previous cs last lv = (n : ℤ) := by + unfold tail_next_half + rw [← trigger_hash_count (round_primary_width current previous) cs last lv hlv] + have hcast : (round_post_unary current previous : ℤ) + + ((tail_finish_count (round_primary_width current previous) cs last lv + 1 : ℕ) : ℤ) - 1 = + 2 * (n : ℤ) + 1 := by omega + rw [hcast] + omega + +theorem tail_next_parameter (current previous : ℕ) (cs : List BinaryColumn) (last : List SDigit) + (lv out : ℕ) (hlv : lv ≤ 5) + (htally : round_post_unary current previous + + tail_finish_count (round_primary_width current previous) cs last lv = + 2 * column_required out (round_outer_column current previous) + 1) : + half_parameter (tail_next_index current previous cs last lv) = + column_required out (round_outer_column current previous) := by + unfold tail_next_index + rw [tail_next_half_tally current previous cs last lv _ hlv htally] + obtain ⟨q, hq, hge⟩ := outer_decode_even_ge6 current previous out + set n := column_required out (round_outer_column current previous) + have hto : (((n : ℤ) - 6) / 2).toNat = (n - 6) / 2 := by omega + rw [hto] + exact outer_decode_parameter current previous out + +-- `FiniteComplete` +theorem finite_tally (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) (k lv : ℕ) + (hpre : finite_round_pre current previous zs last k lv) : + round_post_unary current previous + + tail_finish_count (round_primary_width current previous) zs last lv = + 2 * finite_decode_count current previous zs k + 1 := by + have hr := finite_last_R current previous zs last k lv hpre + have hodd := finite_suffix_odd current previous zs last k lv hpre + have hcount := tail_finish_equation (round_primary_width current previous) zs last lv + rw [← right_remaining_finish, hr] at hcount + have hbase := phase_R_large k + have hlower := right_remaining_lower zs (phase_R k) (by omega) + have ht := primary_decode_tally current previous (right_remaining zs (phase_R k)) + (by omega) hodd + unfold finite_decode_count + omega + +theorem finite_next_parameter (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) + (k lv : ℕ) + (hpre : finite_round_pre current previous zs last k lv) : + half_parameter (tail_next_index current previous zs last lv) = + finite_decode_count current previous zs k := by + have htally := finite_tally current previous zs last k lv hpre + have hlv : lv ≤ 5 := by + rcases hpre.fr_stage with ⟨hk1, hk4⟩ + rw [hpre.fr_lv] + rcases k with _ | _ | _ | _ | _ | k <;> try omega + all_goals decide + exact tail_next_parameter current previous zs last lv _ hlv htally + +theorem finite_round_proved (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) + (k lv : ℕ) (hpre : finite_round_pre current previous zs last k lv) (hk3 : k ≤ 3) : + ∃ zs' last' lv', + ((post_ca_tail (round_post_unary current previous) + (round_primary_width current previous) zs last k lv) [source_tm]⊢⁺ + post_ca_tail + (round_post_unary (tail_next_index current previous zs last lv) current) + (round_primary_width (tail_next_index current previous zs last lv) current) + (z_column previous :: zs') last' (k + 1) lv') ∧ + finite_round_pre (tail_next_index current previous zs last lv) current + (z_column previous :: zs') last' (k + 1) lv' := by + obtain ⟨zs', hstep, hbudget, hdone⟩ := + finite_exception_done current previous zs last k lv hpre hk3 + have hnext := finite_next_parameter current previous zs last k lv hpre + obtain ⟨hlen', hval'⟩ := next_last_checkpoints k hpre.fr_stage.1 hk3 + refine ⟨zs', next_last k, phase_lv (k + 1), ?_, ?_⟩ + · refine stepPlus_trans hdone ?_ + rw [← hnext] + exact finite_done_to_next_post current previous zs' k + (tail_next_index current previous zs last lv) + · refine ⟨⟨by omega, by omega⟩, hbudget, z_column_odd previous, ?_, hlen', hval', rfl⟩ + refine tail_width_dominance_step current previous + (tail_next_index current previous zs last lv) + (decode_budget (right_remaining zs (phase_R k))) + zs zs' last (next_last k) _ hstep ?_ hnext hpre.fr_width + rw [hpre.fr_last_len, hlen'] + unfold phase_width + omega + +-- `FinalTrigger` & `FiniteOrbit` +def full_finish_count : List ℕ → ℕ → ℕ + | [], out => out + | e :: rest, out => (full_finish_count rest out + 2) * 2 ^ (e + 1) - 3 + +theorem full_finish_prefix (es : List ℕ) (out : ℕ) (input output : List (Fin 2)) + (htail : SideRLs source_tm (hashes ^ out) (input +> default) (output +> default)) : + SideRLs source_tm (hashes ^ full_finish_count es out) + (spaced_words (es.map (fun e => E8 ^ e ++ A8) ++ [input]) +> default) + (spaced_words (es.map (fun e => B8 ^ (e + 1)) ++ [output]) +> default) := by + induction es with + | nil => exact htail + | cons e es ih => + dsimp only [full_finish_count] + rw [List.map_cons, List.map_cons, spaced_snoc_cons, spaced_snoc_cons] + have hc := standard_mixed_to_binary_out_spec e (List.replicate (e + 1) BB) + (full_finish_count es out) (List.length_replicate) + rw [digits_word_repeat_BB, digits_value_repeat_BB] at hc + have hpow : 2 ≤ 2 ^ (e + 1) := by + have : 1 ≤ 2 ^ e := Nat.one_le_two_pow + rw [Nat.pow_succ]; omega + have heq : (full_finish_count es out + 1) * 2 ^ (e + 1) - 2 + (2 ^ (e + 1) - 1) = + (full_finish_count es out + 2) * 2 ^ (e + 1) - 3 := by + set X := 2 ^ (e + 1) + have hX : 2 ≤ X := hpow + have h1 : (full_finish_count es out + 1) * X + X = (full_finish_count es out + 2) * X := by + ring + have h2 : 2 ≤ (full_finish_count es out + 1) * X := + Nat.le_mul_of_pos_left X (by omega) |>.trans' hX + omega + rw [heq] at hc + have hp := hc.concat (hashes_U_run (full_finish_count es out) 2) + have hfull := hp.sideRLs_concat ih + simpa only [List.append_assoc, append_assoc] using hfull + +theorem spaced_tail_append (ws : List (List (Fin 2))) (x suffix : List (Fin 2)) : + spaced_words (ws ++ [x ++ suffix]) = spaced_words (ws ++ [x]) ++ suffix := by + induction ws with + | nil => rfl + | cons w ws ih => + rw [spaced_snoc_cons, spaced_snoc_cons, ih] + simp only [List.append_assoc] + +def trigger_finish (es : List ℕ) : ℕ := full_finish_count es 134217725 + +theorem raw_four_to_frontier (es : List ℕ) : + SideRLs source_tm (hashes ^ trigger_finish es) + (mixed_tail es 25 4 +> default) + (full_tail es 24 5 +> default) := by + have h := full_finish_prefix es 134217725 + (E8 ^ 25 ++ U ^ 11 ++ y_after 4) + (B8 ^ 25 ++ U ^ 11 ++ y_after 5) + last_case9_frontier + rw [spaced_tail_append, spaced_tail_append, spaced_tail_append, spaced_tail_append] at h + unfold y_after at h + unfold trigger_finish mixed_tail full_tail tail_word y_after + simpa only [List.append_assoc, append_assoc] using h + +theorem full_finish_monotone (es : List ℕ) (a b : ℕ) (hab : a ≤ b) : + full_finish_count es a ≤ full_finish_count es b := by + induction es with + | nil => exact hab + | cons e es ih => + dsimp only [full_finish_count] + have hle : (full_finish_count es a + 2) * 2 ^ (e + 1) ≤ (full_finish_count es b + 2) * 2 ^ (e + + 1) := + Nat.mul_le_mul_right _ (by omega) + omega + +theorem nested_required_finish (es : List ℕ) (e : ℕ) : + nested_required es e = full_finish_count es (3 * (2 ^ (e + 1) - 1)) := by + induction es with + | nil => rfl + | cons a es ih => + dsimp only [nested_required, full_finish_count] + rw [ih] + have hpow : 2 ≤ 2 ^ (a + 1) := by + have : 1 ≤ 2 ^ a := Nat.one_le_two_pow + rw [Nat.pow_succ]; omega + set X := 2 ^ (a + 1) + have hX : 2 ≤ X := hpow + set F := full_finish_count es (3 * (2 ^ (e + 1) - 1)) + have h1 : (F + 1) * X + X = (F + 2) * X := by ring + have h2 : 2 ≤ (F + 1) * X := Nat.le_mul_of_pos_left X (by omega) |>.trans' hX + omega + +theorem trigger_finish_sufficient (es : List ℕ) : + nested_required es 23 ≤ trigger_finish es := by + rw [nested_required_finish] + exact full_finish_monotone es _ _ (by decide) + +theorem full_finish_less_than_decode (cs : List BinaryColumn) (out small : ℕ) (h : small < out) : + full_finish_count (cs.map BinaryColumn.column_e) small < columns_input_count cs out := by + induction cs with + | nil => exact h + | cons c cs ih => + rw [List.map_cons] + dsimp only [full_finish_count, columns_input_count] + unfold column_required + have hpow : 2 ≤ 2 ^ (c.column_e + 1) := by + have : 1 ≤ 2 ^ c.column_e := Nat.one_le_two_pow + rw [Nat.pow_succ]; omega + set X := 2 ^ (c.column_e + 1) + have hX : 2 ≤ X := hpow + set F := full_finish_count (cs.map BinaryColumn.column_e) small + set C := columns_input_count cs out + have hle : (F + 2) * X ≤ (C + 1) * X := Nat.mul_le_mul_right X (by omega) + have hge : 4 ≤ (F + 2) * X := by nlinarith + omega + +theorem safe_tail_steps (b : Bool) (cs : List BinaryColumn) (hsafe : ∀ c ∈ cs, column_safe c) : + ∃ cs', tail_columns_step b cs cs' := by + induction cs with + | nil => exact ⟨[], trivial⟩ + | cons c cs ih => + obtain ⟨cs', hrest⟩ := ih (fun x hx => hsafe x (List.mem_cons_of_mem c hx)) + obtain ⟨c', hc'⟩ := column_step_exists (next_column_odd b cs) c + (column_safe_lower c (hsafe c (List.Mem.head _))) + exact ⟨c' :: cs', ⟨hc', hrest⟩⟩ + +theorem tail_steps_es (b : Bool) (cs cs' : List BinaryColumn) (hstep : tail_columns_step b cs cs') : + cs'.map BinaryColumn.column_e = cs.map BinaryColumn.column_e := by + induction cs generalizing cs' with + | nil => + rcases cs' with _ | _ + · rfl + · cases hstep + | cons c cs ih => + rcases cs' with _ | ⟨c', cs'⟩ + · cases hstep + · rcases hstep with ⟨⟨he, _⟩, hrest⟩ + simp only [List.map_cons, he, ih cs' hrest] + +theorem final_last_budget_gap : 134217725 < decode_budget (phase_R 4) := by + decide + +theorem final_decode_budget_gap (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) + (lv : ℕ) + (hpre : finite_round_pre current previous zs last 4 lv) : + trigger_finish (frontier_es current previous zs) < finite_decode_count current previous zs 4 := + by + obtain ⟨zs', hstep⟩ := safe_tail_steps (decide (phase_R 4 % 2 = 1)) zs + (finite_pre_safe current previous zs last 4 lv hpre) + have hgap := full_finish_less_than_decode (round_outer_column current previous :: zs') + (decode_budget (phase_R 4)) 134217725 final_last_budget_gap + dsimp only [columns_input_count] at hgap + rw [columns_decode_budget zs zs' (phase_R 4) (phase_R_large 4) hstep, + List.map_cons, tail_steps_es _ zs zs' hstep] at hgap + exact hgap + +theorem final_decode_input_raw (current previous : ℕ) (zs : List BinaryColumn) : + finite_decode_input current previous zs 4 = + mixed_tail (frontier_es current previous zs) 25 4 := by + unfold finite_decode_input frontier_es + exact (mixed_tail_chain (round_outer_column current previous :: zs) 25 4).symm + +theorem finite_trigger_proved (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) + (lv : ℕ) + (hpre : finite_round_pre current previous zs last 4 lv) : + ∃ c f es e, + ((post_ca_tail (round_post_unary current previous) + (round_primary_width current previous) zs last 4 lv) [source_tm]⊢⁺ + ((exception_call_left c f) {{B}}> (full_tail es (e + 1) 5 +> default))) ∧ + nested_required es e ≤ f := by + have hgap := final_decode_budget_gap current previous zs last lv hpre + set es := frontier_es current previous zs + set f := trigger_finish es + set n := finite_decode_count current previous zs 4 + refine ⟨n - (f + 1), f, es, 23, ?_, trigger_finish_sufficient es⟩ + refine stepPlus_trans (finite_raw_to_pre current previous zs last 4 lv hpre) ?_ + rw [final_decode_input_raw] + have hrun := exception_launch_partial_side f (n - (f + 1)) _ _ (raw_four_to_frontier es) + rw [show f + (n - (f + 1)) + 1 = n by omega] at hrun + exact hrun + +theorem finite_entry_to_cycler (current previous : ℕ) (zs : List BinaryColumn) (last : List SDigit) + (lv : ℕ) + (hpre : finite_round_pre current previous zs last 1 lv) : + ∃ L₀ : ListBlank (Fin 2), + ((post_ca_tail (round_post_unary current previous) + (round_primary_width current previous) zs last 1 lv) [source_tm]⊢⁺ + ((Yw.reverse +> L₀) {{B}}> default)) := by + obtain ⟨zs1, last1, lv1, h1, p1⟩ := + finite_round_proved current previous zs last 1 lv hpre (by decide) + obtain ⟨zs2, last2, lv2, h2, p2⟩ := finite_round_proved _ _ _ last1 2 lv1 p1 (by decide) + obtain ⟨zs3, last3, lv3, h3, p3⟩ := finite_round_proved _ _ _ last2 3 lv2 p2 (by decide) + obtain ⟨c, f, es, e, h4, hbound⟩ := finite_trigger_proved _ _ _ last3 lv3 p3 + obtain ⟨L₀, h5⟩ := nested_exit_to_cycler c f es e hbound + exact ⟨L₀, stepPlus_trans h1 (stepPlus_trans h2 (stepPlus_trans h3 (stepPlus_trans h4 h5)))⟩ + +theorem fifth_done_to_cycler_generic (n4 n5 : ℕ) + (hn4 : ∃ q, n4 = 2 * q ∧ 6 ≤ 2 * q) + (hn5 : ∃ q, n5 = 2 * q ∧ 6 ≤ 2 * q) + (hge64 : 64 ≤ n4) + (hgrow : 2 * (n4 + 30) + 4 ≤ n5 + 1) : + ∃ L₀ : ListBlank (Fin 2), + ((exception_done n5 + (A8 ^ (n4 - 2) ++ sdigits_word opening_digits ++ U ^ 3 ++ A8 ++ [1, 1])) + [source_tm]⊢⁺ ((Yw.reverse +> L₀) {{B}}> default)) := by + have hentry := opening_exception_to_entry_generic n4 n5 hn4 hn5 + have hpre := entry_pre_generic n4 n5 hn4 hn5 hge64 hgrow + obtain ⟨L₀, hcycler⟩ := finite_entry_to_cycler ((n5 - 6) / 2) ((n4 - 6) / 2) [] entry_last 4 hpre + exact ⟨L₀, stepPlus_trans hentry hcycler⟩ + +theorem blank_D_to_cycler : + ∃ L₀ : ListBlank (Fin 2), + ((default {{D}}> default) [source_tm]⊢* ((Yw.reverse +> L₀) {{B}}> default)) := by + obtain ⟨⟨q4, hq4⟩, hge64⟩ := opening_n4_even_large + have hn4 : ∃ q, opening_n4 = 2 * q ∧ 6 ≤ 2 * q := ⟨q4, hq4, by omega⟩ + have hn5 : ∃ q, opening_decode_calls (opening_n4 - 2) = 2 * q ∧ 6 ≤ 2 * q := + opening_decode_even_ge6 (opening_n4 - 2) (by omega) + have hgrow : 2 * (opening_n4 + 30) + 4 ≤ opening_decode_calls (opening_n4 - 2) + 1 := + opening_entry_growth opening_n4 hge64 + obtain ⟨L₀, hcycler⟩ := fifth_done_to_cycler_generic + opening_n4 (opening_decode_calls (opening_n4 - 2)) hn4 hn5 hge64 hgrow + exact ⟨L₀, stepStar_trans opening_D_to_fifth_done (stepPlus_to_stepStar hcycler)⟩ + +theorem sobc_D_nonhalt : NeverHaltsFrom source_tm (default {{D}}> default) := by + obtain ⟨L₀, hreach⟩ := blank_D_to_cycler + exact neverHaltsFrom_of_reachesStar hreach (cycler_nonhalt L₀) + +end + +public section + +theorem is_not_halt : IsNotHalt target := + neverHaltsFrom_of_mapFlipCfg_12 sobc_D_nonhalt + +end + +end BusyBeaver.M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF + diff --git a/BusyBeaver/BB6/NonHalt/M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH.lean b/BusyBeaver/BB6/NonHalt/M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH.lean new file mode 100644 index 00000000..95cb507c --- /dev/null +++ b/BusyBeaver/BB6/NonHalt/M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH.lean @@ -0,0 +1,46 @@ +/- +Copyright (c) 2026 Google LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +-/ +module + +import BusyBeaver.Basic +public import BusyBeaver.Bridge +import BusyBeaver.Calculi.Counter +import BusyBeaver.BB6.NonHalt.M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH + +open Mathlib Relation Nat Turing BusyBeaver SixState + +namespace BusyBeaver.M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH + +@[expose] public section + +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH" + +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB + +end + +def stateMap_m0557 : Fin 6 → Fin 6 + | 0 => 4 + | 1 => 0 + | 2 => 1 + | 3 => 2 + | 4 => 3 + | 5 => 5 + +public section + +theorem is_not_halt : IsNotHalt target := by + exact Counter.does_not_halt_of_conj_stem + (M_tgt := target) + (M_src := BusyBeaver.M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH.target) + (σ := stateMap_m0557) (f := false) + (c₁ := (default : ListBlank (Fin 2)) {{1}}> default) + (by decide) (Counter.init_reaches_conjCfg_default rfl) + BusyBeaver.M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH.is_not_halt_from_0557 + +end + +end BusyBeaver.M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH diff --git a/BusyBeaver/BB6/NonHalt/M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE.lean b/BusyBeaver/BB6/NonHalt/M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE.lean new file mode 100644 index 00000000..dc711428 --- /dev/null +++ b/BusyBeaver/BB6/NonHalt/M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE.lean @@ -0,0 +1,2096 @@ +/- +Copyright (c) 2026 Google LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +-/ +module + +import BusyBeaver.Basic +public import BusyBeaver.Bridge +import BusyBeaver.Calculi.Longitudinal +import BusyBeaver.Calculi.SegCount +import Mathlib.Tactic.Ring +import Mathlib.Tactic.Linarith + +open Mathlib Relation Nat Turing BusyBeaver SixState + +namespace BusyBeaver.M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE + +@[expose] public section + +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE" + +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB + +end + +abbrev target_tm : Machine (Fin 2) (Fin 6) := target + +namespace SegCount + +open BusyBeaver.Longitudinal + +variable {Γ Λ : Type*} [Inhabited Γ] [Inhabited Λ] + +export BusyBeaver.SegCount (runSteps runSteps_spec) + +theorem SegRLs.congr {M : Machine Γ Λ} {ls₁ ls₁' ls₂ ls₂' : List (DH0 Γ Λ × DH0 Γ Λ)} + {w₁ w₁' w₂ w₂' : List Γ} + (h : SegRLs M ls₁ ls₂ w₁ w₂) + (hls₁ : ls₁ = ls₁') (hls₂ : ls₂ = ls₂') (hw₁ : w₁ = w₁') (hw₂ : w₂ = w₂') : + SegRLs M ls₁' ls₂' w₁' w₂' := by + subst hls₁ hls₂ hw₁ hw₂; exact h + +theorem runSteps1_spec (M : Machine Γ Λ) (n : ℕ) (x y : BoundedConfig.BCfg Γ Λ) + (h : (BoundedConfig.step M x).map (runSteps M n) = some y) (l₀ r₀ : ListBlank Γ) : + (BoundedConfig.toCfg x l₀ r₀) [M]⊢⁺ (BoundedConfig.toCfg y l₀ r₀) := by + rcases hstep : BoundedConfig.step M x with _ | x' <;> rw [hstep] at h + · cases h + · dsimp only [Option.map] at h + injection h with hy + exact stepPlus_stepStar_trans ⟨1, by decide, BoundedConfig.step_spec M x hstep l₀ r₀⟩ + (runSteps_spec M n x' y hy l₀ r₀) + +theorem SegRLs.trans_eq {M : Machine Γ Λ} + {ls₁ ls₂ ls₃ ls₄ : List (DH0 Γ Λ × DH0 Γ Λ)} + {w₁ w₂ w₂' w₃ : List Γ} + (h₁ : SegRLs M ls₁ ls₂ w₁ w₂) (h₂ : SegRLs M ls₃ ls₄ w₂' w₃) + (hw : w₂ = w₂') : + SegRLs M (ls₁ ++ ls₃) (ls₂ ++ ls₄) w₁ w₃ := by + subst hw; exact h₁.trans h₂ + + +theorem stepStar_congr {M : Machine Γ Λ} {c₁ c₁' c₂ c₂' : Cfg Γ Λ} + (h : c₁ [M]⊢* c₂) (hc₁ : c₁ = c₁') (hc₂ : c₂ = c₂') : c₁' [M]⊢* c₂' := by + subst hc₁ hc₂; exact h + +theorem stepPlus_congr {M : Machine Γ Λ} {c₁ c₁' c₂ c₂' : Cfg Γ Λ} + (h : c₁ [M]⊢⁺ c₂) (hc₁ : c₁ = c₁') (hc₂ : c₂ = c₂') : c₁' [M]⊢⁺ c₂' := by + subst hc₁ hc₂; exact h + +theorem run_trans {M : Machine Γ Λ} {hf ls₁ ls₂ : List (DH0 Γ Λ × DH0 Γ Λ)} {m n : ℕ} + {w₁ w₂ w₂' w₃ : List Γ} + (h₁ : SegRLs M (hf ^ m) ls₁ w₁ w₂) + (h₂ : SegRLs M (hf ^ n) ls₂ w₂' w₃) + (hw : w₂ = w₂') : + SegRLs M (hf ^ (m + n)) (ls₁ ++ ls₂) w₁ w₃ := by + rw [pow_add_list] + exact SegRLs.trans_eq h₁ h₂ hw + +def ucount : ℕ → ℕ + | 0 => 1 + | k + 1 => 4 * ucount k + 1 + +def vcount (k : ℕ) : ℕ := 2 * ucount k - 1 + +def qcount : ℕ → ℕ + | 0 => 0 + | k + 1 => ucount k + +omit [Inhabited Γ] [Inhabited Λ] in +theorem ucount_positive (k : ℕ) : 0 < ucount k := by + induction k with + | zero => decide + | succ k ih => dsimp [ucount]; omega + +omit [Inhabited Γ] [Inhabited Λ] in +theorem ucount_power (k : ℕ) : 3 * ucount k + 1 = 4 ^ (k + 1) := by + induction k with + | zero => rfl + | succ k ih => + dsimp [ucount] + rw [Nat.pow_succ] + omega + +omit [Inhabited Γ] [Inhabited Λ] in +theorem qcount_S (j : ℕ) : qcount (j + 1) = 4 * qcount j + 1 := by + cases j <;> rfl + +theorem H_lift_finite {M : Machine Γ Λ} {hf : List (DH0 Γ Λ × DH0 Γ Λ)} + {hword : ℕ → ℕ → List Γ} + (H_cycle : ∀ a b, SegRLs M (hf ^ (4 ^ (a + 2))) hf (hword a (1 + b)) (hword (1 + a) b)) + (a b j : ℕ) : + SegRLs M (hf ^ (4 ^ (a + 2) * qcount j)) (hf ^ j) + (hword a (j + b)) (hword (a + j) b) := by + induction j generalizing a with + | zero => + rw [qcount, Nat.mul_zero, Nat.zero_add, Nat.add_zero] + exact .nil _ + | succ j ih => + have h1 := H_cycle a (j + b) + have h2 := ih (a + 1) + have h12 := run_trans h1 h2 (by rw [Nat.add_comm 1 a]) + refine SegRLs.congr h12 ?_ (by rw [pow_succ_list]) + (by rw [show j + 1 + b = 1 + (j + b) by omega]) + (by rw [show a + 1 + j = a + (j + 1) by omega]) + congr 1 + rw [qcount_S, show a + 1 + 2 = (a + 2) + 1 by omega, Nat.pow_succ] + ring + +theorem H_lift {M : Machine Γ Λ} {hf : List (DH0 Γ Λ × DH0 Γ Λ)} + {hword : ℕ → ℕ → List Γ} + (H_cycle : ∀ a b, SegRLs M (hf ^ (4 ^ (a + 2))) hf (hword a (1 + b)) (hword (1 + a) b)) + (a b j : ℕ) (r r' : ListBlank Γ) (H : SideRLs M (hf ^ j) r r') : + SideRLs M (hf ^ (4 ^ (a + 2) * qcount j)) + (hword a (j + b) +> r) (hword (a + j) b +> r') := + (H_lift_finite H_cycle a b j).sideRLs_concat H + +theorem N_run {M : Machine Γ Λ} {hf : List (DH0 Γ Λ × DH0 Γ Λ)} + {Ncfg : ℕ → ListBlank Γ → Cfg Γ Λ} + (h_step : ∀ n r r', SideRLs M hf r r' → (Ncfg n r) [M]⊢⁺ (Ncfg (n + 1) r')) : + ∀ m n r r', SideRLs M (hf ^ m) r r' → (Ncfg n r) [M]⊢* (Ncfg (n + m) r') := by + intro m + induction m with + | zero => + intro n r r' h + cases h + simp only [Nat.add_zero] + exact stepStar_refl M _ + | succ m ih => + intro n r r' h + rw [pow_succ_list] at h + rcases h.split with ⟨r_mid, h1, h2⟩ + refine stepStar_trans (stepPlus_to_stepStar (h_step n r r_mid h1)) ?_ + have h_rec := ih (n + 1) r_mid r' h2 + have h_add : n + 1 + m = n + (m + 1) := by omega + rwa [h_add] at h_rec + +theorem N_H_lift {M : Machine Γ Λ} {hf : List (DH0 Γ Λ × DH0 Γ Λ)} + {hword : ℕ → ℕ → List Γ} {Ncfg : ℕ → ListBlank Γ → Cfg Γ Λ} + (h_N : ∀ n r r', SideRLs M hf r r' → (Ncfg n r) [M]⊢⁺ (Ncfg (n + 1) r')) + (H_cycle : ∀ a b, SegRLs M (hf ^ (4 ^ (a + 2))) hf (hword a (1 + b)) (hword (1 + a) b)) + (n a b j : ℕ) (r r' : ListBlank Γ) (H : SideRLs M (hf ^ j) r r') : + (Ncfg n (hword a (j + b) +> r)) [M]⊢* + (Ncfg (n + 4 ^ (a + 2) * qcount j) (hword (a + j) b +> r')) := + N_run h_N (4 ^ (a + 2) * qcount j) n _ _ (H_lift H_cycle a b j r r' H) + +end SegCount + +section + +open BusyBeaver.Longitudinal SegCount + +local notation "Γ" => Fin 2 +local notation "Λ" => Fin 6 + +set_option maxRecDepth 200000 + +abbrev O : Fin 2 := 0 +abbrev I : Fin 2 := 1 + +abbrev A : Fin 6 := 0 +abbrev C : Fin 6 := 2 +abbrev E : Fin 6 := 4 +abbrev F : Fin 6 := 5 + +abbrev tm : Machine (Fin 2) (Fin 6) := target_tm + +-- ============================================================================ +-- 1. Bounded Execution Helpers & Tape Words (`SOBCv14.v:13-50`) +-- ============================================================================ + + +abbrev hf : List (DH0 Γ Λ × DH0 Γ Λ) := [((F, []), (E, []))] +abbrev z4 : List Γ := [O, O, O, O] +abbrev a4 : List Γ := [I, O, O, O] +abbrev b4 : List Γ := [I, O, O, I] +abbrev c4 : List Γ := [O, I, I, O] +abbrev d4 : List Γ := [I, I, I, O] +abbrev e4 : List Γ := [O, O, I, O] + +theorem pow_one_add {α : Type*} (u : List α) (n : ℕ) : u ^ (1 + n) = u ++ u ^ n := by + rw [Nat.add_comm 1 n, pow_succ_list] + +theorem pow_two_add {α : Type*} (u : List α) (n : ℕ) : u ^ (2 + n) = u ++ (u ++ u ^ n) := by + rw [show 2 + n = (n + 1) + 1 by omega, pow_succ_list, pow_succ_list] + +theorem pow_add_two {α : Type*} (u : List α) (n : ℕ) : u ^ (n + 2) = u ++ (u ++ u ^ n) := by + rw [show n + 2 = (n + 1) + 1 by omega, pow_succ_list, pow_succ_list] + +theorem pow_add_three {α : Type*} (u : List α) (n : ℕ) : u ^ (n + 3) = u ++ (u ++ (u ++ u ^ n)) := + by + rw [show n + 3 = (n + 2) + 1 by omega, pow_succ_list, pow_add_two] + +theorem cons4_pow_comm {α : Type*} (a b c d : α) (k : ℕ) (s : List α) : + [a, b, c, d] ^ k ++ (a :: b :: c :: d :: s) = + a :: b :: c :: d :: ([a, b, c, d] ^ k ++ s) := by + induction k with + | zero => rfl + | succ k ih => + rw [pow_succ_list, List.append_assoc, ih] + rfl + +theorem cons4_pow_comm_end {α : Type*} (a b c d : α) (k : ℕ) : + [a, b, c, d] ^ k ++ [a, b, c, d] = + a :: b :: c :: d :: [a, b, c, d] ^ k := by + simpa using cons4_pow_comm a b c d k [] + +theorem z4_cons_O_comm (k : ℕ) (s : List Γ) : + [O, O, O, O] ^ k ++ (O :: s) = O :: ([O, O, O, O] ^ k ++ s) := by + induction k with + | zero => rfl + | succ k ih => + rw [pow_succ_list, List.append_assoc, ih] + rfl + +theorem z4_end_O_comm (k : ℕ) : + [O, O, O, O] ^ k ++ [O] = O :: [O, O, O, O] ^ k := by + simpa using z4_cons_O_comm k [] + +def hword (a b : ℕ) : List Γ := + [O, O, I] ++ d4 ++ e4 ^ a ++ c4 ^ b ++ [O, I, I, I, I] + +abbrev seek_tail : List Γ := [O, O, O, I, O, O, O, I, I, I, I, I] +abbrev seed_tail : List Γ := [O, O, O] ++ z4 ++ a4 ++ z4 ++ [O, I, I, I] ++ [I, I, I, I] ++ a4 +abbrev seed_tail40 : List Γ := [O, O, O] ++ z4 ++ [I, I, I, I] ^ 4 ++ a4 +def post_input (j : ℕ) : List Γ := + hword j 0 ++ [O, O, O] ++ z4 ^ 2 ++ a4 ^ 44 ++ z4 ++ a4 ^ 5 ++ [I, I, I, I] ++ b4 ++ [I, I, I] +abbrev second_tail : List Γ := + [O, O, O, I] ++ [O, O, O, I] ++ [I, I, I, I] ++ [O, O, O, I] ++ + [I, I, I, I] ++ [O, O, O, I] ++ [I, I, I, I] ++ [I, I, I, I] +abbrev second_result_tail : List Γ := + a4 ++ [I, I, I, I] ++ a4 ++ [I, I, I, I] ++ a4 ++ [I, I, I, I] ^ 2 ++ [I] +abbrev entry_tail : List Γ := + a4 ++ [I, I, I, I] ++ a4 ++ [I, I, I, I] ++ a4 ++ [I, I, I, I] ^ 2 ++ d4 ++ [I, I] + +theorem pow2_list {α : Type*} (u : List α) : u ^ 2 = u ++ u := by + rw [pow_succ_list, pow_one_list] +theorem pow3_list {α : Type*} (u : List α) : u ^ 3 = u ++ (u ++ u) := by + rw [pow_succ_list, pow2_list] +theorem pow4_list {α : Type*} (u : List α) : u ^ 4 = u ++ (u ++ (u ++ u)) := by + rw [pow_succ_list, pow3_list] +theorem pow5_list {α : Type*} (u : List α) : u ^ 5 = u ++ (u ++ (u ++ (u ++ u))) := by + rw [pow_succ_list, pow4_list] +theorem pow6_list {α : Type*} (u : List α) : u ^ 6 = u ++ (u ++ (u ++ (u ++ (u ++ u)))) := by + rw [pow_succ_list, pow5_list] + +macro "norm_word" : tactic => + `(tactic| simp only [hword, z4, a4, b4, c4, d4, e4, seek_tail, + seed_tail, seed_tail40, post_input, second_tail, second_result_tail, entry_tail, + pow_zero_list, pow_one_list, pow_succ_list, pow_one_add, pow_two_add, + pow_add_two, pow_add_three, + cons4_pow_comm, cons4_pow_comm_end, z4_cons_O_comm, z4_end_O_comm, + Nat.add_zero, Nat.zero_add, + List.append_assoc, List.nil_append, List.append_nil, List.cons_append]) + +macro "flat_word" : tactic => + `(tactic| simp only [hword, z4, a4, b4, c4, d4, e4, seek_tail, + seed_tail, seed_tail40, post_input, second_tail, second_result_tail, entry_tail, + pow_zero_list, pow_one_list, pow2_list, pow3_list, pow4_list, pow5_list, pow6_list, + pow_one_add, pow_two_add, Nat.add_zero, Nat.zero_add, + List.append_assoc, List.nil_append, List.append_nil, List.cons_append]) + +theorem finite_suffix {n : ℕ} {w₁ w₂ : List Γ} (s : List Γ) + (h : SegRLs tm (hf ^ n) [] w₁ w₂) : + SegRLs tm (hf ^ n) [] (w₁ ++ s) (w₂ ++ s) := + h.concat (.nil s) + +theorem finite_suffix1 {w₁ w₂ : List Γ} (s : List Γ) + (h : SegRLs tm hf [] w₁ w₂) : + SegRLs tm (hf ^ 1) [] (w₁ ++ s) (w₂ ++ s) := + h.concat (.nil s) + +theorem segment_suffix {ls : List (DH0 Γ Λ × DH0 Γ Λ)} {w₁ w₂ : List Γ} (s : List Γ) + (h : SegRLs tm ls [] w₁ w₂) : + SegRLs tm ls [] (w₁ ++ s) (w₂ ++ s) := + h.concat (.nil s) + +theorem finite_trans {m n : ℕ} {w₁ w₂ w₂' w₃ : List Γ} + (h₁ : SegRLs tm (hf ^ m) [] w₁ w₂) + (h₂ : SegRLs tm (hf ^ n) [] w₂' w₃) + (hw : w₂ = w₂' := by norm_word) : + SegRLs tm (hf ^ (m + n)) [] w₁ w₃ := by + rw [pow_add_list] + exact SegRLs.trans_eq h₁ h₂ hw + +theorem run_trans {m n : ℕ} {ls₁ ls₂ : List (DH0 Γ Λ × DH0 Γ Λ)} {w₁ w₂ w₂' w₃ : List Γ} + (h₁ : SegRLs tm (hf ^ m) ls₁ w₁ w₂) + (h₂ : SegRLs tm (hf ^ n) ls₂ w₂' w₃) + (hw : w₂ = w₂' := by norm_word) : + SegRLs tm (hf ^ (m + n)) (ls₁ ++ ls₂) w₁ w₃ := by + rw [pow_add_list] + exact SegRLs.trans_eq h₁ h₂ hw + +theorem segRLs_repeat_wall (h : DH0 Γ Λ × DH0 Γ Λ) {w₁ w₂ : List Γ} + (H : SegRLs tm [h] [h] w₁ w₂) (n : ℕ) : + SegRLs tm [h] [h] (w₁ ^ n) (w₂ ^ n) := by + induction n with + | zero => exact SegRLs.empty tm [h] + | succ n ih => exact H.concat ih + +-- ============================================================================ +-- 2. Base 1-Block Walls & Bridges (`SOBCv14.v:21-118`, `419-443`, `582-635`, `714-757`, `836-844`) +-- ============================================================================ + + +def Ufinite (k : ℕ) : Prop := + SegRLs tm (hf ^ ucount k) [] + ([O, O, O] ++ z4 ^ k ++ [O]) + ([O, O, I] ++ a4 ^ k ++ [I]) + +def Vfinite (k : ℕ) : Prop := + SegRLs tm (hf ^ vcount k) [] + ([O, O, O] ++ c4 ++ z4 ^ k) + ([O, O, I] ++ d4 ++ e4 ^ k) + +theorem Ufinite_0 : Ufinite 0 := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem Vfinite_0 : Vfinite 0 := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem Ufinite_1 : Ufinite 1 := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +-- 1-Block repeating walls (`T := 200`) +private theorem wall_CF_a4 : SegRLs tm [((C, []), (F, []))] [((C, []), (F, []))] a4 z4 := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +private theorem wall_AF_e4 : SegRLs tm [((A, []), (F, []))] [((A, []), (F, []))] e4 z4 := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +private theorem wall_AE_e4 : SegRLs tm [((A, []), (E, []))] [((A, []), (E, []))] e4 z4 := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +private theorem wall_AF0_c4 : SegRLs tm [((A, []), (F, [O]))] [((A, []), (F, [O]))] c4 [O, O, I, + I] := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +private theorem wall_FEz4_0001 : SegRLs tm [((F, []), (E, z4))] [((F, []), (E, z4))] [O, O, O, + I] z4 := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +private theorem wall_FEz4_0011 : SegRLs tm [((F, []), (E, z4))] [((F, []), (E, z4))] [O, O, I, + I] [I, I, O, O] := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +private theorem P_F_0 : SegRLs tm hf [((C, []), (F, []))] ([O, O, I] ++ a4) ([O, O, O] ++ c4) := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem P_F (k : ℕ) : + SegRLs tm hf [((C, []), (F, []))] ([O, O, I] ++ a4 ^ (1 + k)) ([O, O, O] ++ c4 ++ z4 ^ k) := by + have h := P_F_0.concat (segRLs_repeat_wall ((C, []), (F, [])) wall_CF_a4 k) + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +private theorem J_F_0 : SegRLs tm hf [((A, []), (F, []))] ([O, O, I] ++ d4) ([O, O, O] ++ z4) := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem J_F (a : ℕ) : + SegRLs tm hf [((A, []), (F, []))] ([O, O, I] ++ d4 ++ e4 ^ a) ([O, O, O] ++ z4 ^ (1 + a)) := by + have h := J_F_0.concat (segRLs_repeat_wall ((A, []), (F, [])) wall_AF_e4 a) + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +private theorem J_E_0 : SegRLs tm [((F, []), (F, []))] [((A, []), (E, []))] ([O, O, I] ++ d4) ([O, + O, O] ++ z4) := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem J_E (a : ℕ) : + SegRLs tm [((F, []), (F, []))] [((A, []), (E, []))] + ([O, O, I] ++ d4 ++ e4 ^ a) ([O, O, O] ++ z4 ^ (1 + a)) := by + have h := J_E_0.concat (segRLs_repeat_wall ((A, []), (E, [])) wall_AE_e4 a) + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +private theorem CF_a4_0 : SegRLs tm [((C, []), (F, []))] [] (a4 ++ [O]) [O, O, O, I, I] := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem bridge_L2 (m : ℕ) : + SegRLs tm hf [] ([O, O, I] ++ a4 ^ (2 + m) ++ [O]) + ([O, O, O] ++ c4 ++ z4 ^ m ++ [O, O, O, I, I]) := by + have h := (P_F m).concat CF_a4_0 + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +private theorem CF_1110 : SegRLs tm [((C, []), (F, []))] [] [I, I, I, O] [O, O, I, O] := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem bridge_L3_0 (m : ℕ) : + SegRLs tm hf [] ([O, O, I] ++ a4 ^ (1 + m) ++ [I, I, I, O]) + ([O, O, O] ++ c4 ++ z4 ^ m ++ [O, O, I, O]) := by + have h := (P_F m).concat CF_1110 + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +private theorem CF_1111 : SegRLs tm [((C, []), (F, []))] [] [I, I, I, I] [O, O, I, I] := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem bridge_L3_1 (m : ℕ) : + SegRLs tm hf [] ([O, O, I] ++ a4 ^ (1 + m) ++ [I, I, I, I]) + ([O, O, O] ++ c4 ++ z4 ^ m ++ [O, O, I, I]) := by + have h := (P_F m).concat CF_1111 + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +private theorem AF_0000 : SegRLs tm [((A, []), (F, []))] [] [O, O, O, O] [O, I, I, O] := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem bridge_L4_0 (m : ℕ) : + SegRLs tm hf [] ([O, O, I] ++ d4 ++ e4 ^ m ++ [O, O, O, O]) + ([O, O, O] ++ z4 ^ (1 + m) ++ [O, I, I, O]) := by + have h := (J_F m).concat AF_0000 + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +private theorem AF_0001 : SegRLs tm [((A, []), (F, []))] [] [O, O, O, I] [O, I, I, I] := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem bridge_L4_1 (m : ℕ) : + SegRLs tm hf [] ([O, O, I] ++ d4 ++ e4 ^ m ++ [O, O, O, I]) + ([O, O, O] ++ z4 ^ (1 + m) ++ [O, I, I, I]) := by + have h := (J_F m).concat AF_0001 + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +private theorem AF_0011 : SegRLs tm [((A, []), (F, []))] [] [O, O, I, I] [O, O, O, O] := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem bridge_L4_3 (m : ℕ) : + SegRLs tm hf [] ([O, O, I] ++ d4 ++ e4 ^ m ++ [O, O, I, I]) + ([O, O, O] ++ z4 ^ (1 + m) ++ [O, O, O, O]) := by + have h := (J_F m).concat AF_0011 + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +private theorem H_empty_tail : SegRLs tm [((A, []), (F, []))] hf [O, I, I, I, I] (z4 ++ [O]) := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem H_empty_F (a : ℕ) : + SegRLs tm hf hf (hword a 0) ([O, O, O] ++ z4 ^ (2 + a) ++ [O]) := by + have h := (J_F a).concat H_empty_tail + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +private theorem I_0001_pow (a : ℕ) : + [I] ++ [O, O, O, I] ^ a = a4 ^ a ++ [I] := by + induction a with + | zero => rfl + | succ a ih => + rw [pow_succ_list [O, O, O, I] a, ← List.append_assoc [I] [O, O, O, I], + show [I] ++ [O, O, O, I] = a4 ++ [I] from rfl, + List.append_assoc a4 [I], ih, ← List.append_assoc, ← pow_succ_list a4 a] + +private theorem I_0011_pow (b : ℕ) : + [I] ++ [O, O, I, I] ^ b = b4 ^ b ++ [I] := by + induction b with + | zero => rfl + | succ b ih => + rw [pow_succ_list [O, O, I, I] b, ← List.append_assoc [I] [O, O, I, I], + show [I] ++ [O, O, I, I] = b4 ++ [I] from rfl, + List.append_assoc b4 [I], ih, ← List.append_assoc, ← pow_succ_list b4 b] + +private theorem H_OA_c4_first : SegRLs tm [((A, []), (F, []))] [((A, []), (F, [O]))] c4 [O, O, O, I, + I] := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +private theorem H_OA_tail : SegRLs tm [((A, []), (F, [O]))] hf [O, I, I, I, I] z4 := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem H_OA (a b : ℕ) : + SegRLs tm hf hf (hword a (1 + b)) + ([O, O, O] ++ z4 ^ (1 + a) ++ [O, O, O, I] ++ b4 ^ b ++ a4 ++ [O]) := by + have h1 := (J_F a).concat H_OA_c4_first + have h2 := h1.concat (segRLs_repeat_wall ((A, []), (F, [O])) wall_AF0_c4 b) + have h3 := h2.concat H_OA_tail + refine SegRLs.congr h3 rfl rfl (by norm_word) ?_ + have hb := I_0011_pow b + rw [show ([O, O, O] ++ z4 ^ (1 + a) ++ [O, O, O, I, I] ++ [O, O, I, I] ^ b) ++ z4 = + [O, O, O] ++ z4 ^ (1 + a) ++ [O, O, O, I] ++ ([I] ++ [O, O, I, I] ^ b) ++ z4 from by norm_word, + hb] + norm_word + +private theorem H_OB_head : SegRLs tm hf [((F, []), (E, z4))] [O, O, I, I] (z4 ++ [I, I, O, O]) := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +private theorem H_OB_tail : SegRLs tm [((F, []), (E, z4))] [] ([O, O, I, I] ++ z4) [I, I, I, I] := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +private theorem h_ob_out_eq (b : ℕ) : + [O] ++ [I, I, O, O] ^ b ++ [I, I, I, I] = c4 ^ b ++ [O, I, I, I, I] := by + induction b with + | zero => rfl + | succ b ih => + have h1 : [O] ++ [I, I, O, O] ^ (b + 1) ++ [I, I, I, I] = + c4 ++ ([O] ++ [I, I, O, O] ^ b ++ [I, I, I, I]) := by + rw [pow_succ_list]; simp only [c4, List.cons_append, List.nil_append] + rw [h1, ih, pow_succ_list, List.append_assoc] + +theorem H_OB (a b : ℕ) : + SegRLs tm hf [] + ([O, O, I] ++ a4 ^ a ++ b4 ^ (1 + b) ++ a4 ++ [O]) + ([O, O, O] ++ c4 ++ z4 ^ a ++ c4 ^ b ++ [O, I, I, I, I]) := by + have h1 := H_OB_head.concat (segRLs_repeat_wall ((F, []), (E, z4)) wall_FEz4_0001 a) + have h2 := h1.concat (segRLs_repeat_wall ((F, []), (E, z4)) wall_FEz4_0011 b) + have h3 := h2.concat H_OB_tail + refine SegRLs.congr h3 rfl rfl ?_ ?_ + · have ha := I_0001_pow a + have hb := I_0011_pow b + rw [show ([O, O, I, I] ++ [O, O, O, I] ^ a ++ [O, O, I, I] ^ b) ++ ([O, O, I, I] ++ z4) = + [O, O, I] ++ ([I] ++ [O, O, O, I] ^ a) ++ [O, O, I, I] ^ b ++ ([O, O, I, + I] ++ z4) from by norm_word, + ha, + show [O, O, I] ++ (a4 ^ a ++ [I]) ++ [O, O, I, I] ^ b ++ ([O, O, I, I] ++ z4) = + [O, O, I] ++ a4 ^ a ++ ([I] ++ [O, O, I, I] ^ b) ++ ([O, O, I, I] ++ z4) from by norm_word, + hb] + norm_word + · rw [show (z4 ++ [I, I, O, O] ++ z4 ^ a ++ [I, I, O, O] ^ b) ++ [I, I, I, I] = + ([O, O, O] ++ c4 ++ z4 ^ a) ++ ([O] ++ [I, I, O, O] ^ b ++ [I, I, I, I]) from by norm_word, + h_ob_out_eq b] + norm_word + +private theorem CF_AZ : SegRLs tm [((C, []), (F, []))] [] (a4 ++ z4) ([O, O, O, I] ++ a4) := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem C_AZ (k : ℕ) : + SegRLs tm [((C, []), (F, []))] [] + (a4 ^ (1 + k) ++ z4) (z4 ^ k ++ [O, O, O, I] ++ a4) := by + have h := (segRLs_repeat_wall ((C, []), (F, [])) wall_CF_a4 k).concat CF_AZ + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +private theorem F_000_CF : SegRLs tm hf [((C, []), (F, []))] [O, O, O] [O, O, O] := + BoundedConfig.segRLs_c_spec tm (T := 200) (by decide) + +theorem F_AZ_large (k : ℕ) : + SegRLs tm hf [] + ([O, O, O] ++ a4 ^ (1 + k) ++ z4) + ([O, O, O] ++ z4 ^ k ++ [O, O, O, I] ++ a4) := by + have h := F_000_CF.concat (C_AZ k) + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +-- ============================================================================ +-- 3. `Ufinite` & `Vfinite` Joint Induction & Reset Seek (`SOBCv14.v:141-514`) +-- ============================================================================ + + +theorem Vfinite_step (k : ℕ) (HU : Ufinite (k + 1)) (HV : Vfinite k) : Vfinite (k + 1) := by + have h1 := finite_suffix z4 HV + have h2 : SegRLs tm (hf ^ 1) [] _ _ := bridge_L4_0 k + have h3 := finite_suffix [I, I, O] HU + have h4 : SegRLs tm (hf ^ 1) [] _ _ := bridge_L3_0 k + have h5 := finite_suffix e4 HV + have h12 := finite_trans h1 h2 + have h123 := finite_trans h12 h3 + have h1234 := finite_trans h123 h4 + have h12345 := finite_trans h1234 h5 + refine SegRLs.congr h12345 ?_ rfl (by norm_word) (by norm_word) + congr 1 + have := ucount_positive k + dsimp [vcount, ucount] + omega + +theorem Ufinite_step (k : ℕ) (HU : Ufinite (k + 1)) (HV : Vfinite k) : Ufinite (k + 2) := by + have h1 := finite_suffix z4 HU + have h2 : SegRLs tm (hf ^ 1) [] _ _ := bridge_L2 k + have h3 := finite_suffix [O, O, O, I, I] HV + have h4 := finite_suffix1 [I] (bridge_L4_1 k) + have h5 := finite_suffix [I, I, I, I] HU + have h6 := finite_suffix1 [I] (bridge_L3_1 k) + have h7 := finite_suffix [O, O, I, I, I] HV + have h8 := finite_suffix1 [I] (bridge_L4_3 k) + have h9 := finite_suffix [O, O, O, I] HU + have h12 := finite_trans h1 h2 + have h123 := finite_trans h12 h3 + have h1234 := finite_trans h123 h4 + have h12345 := finite_trans h1234 h5 + have h123456 := finite_trans h12345 h6 + have h1234567 := finite_trans h123456 h7 + have h12345678 := finite_trans h1234567 h8 + have h123456789 := finite_trans h12345678 h9 + refine SegRLs.congr h123456789 ?_ rfl (by norm_word) (by norm_word) + congr 1 + have := ucount_positive k + dsimp [vcount, ucount] + omega + +theorem UVfinite (k : ℕ) : Ufinite (k + 1) ∧ Vfinite k := by + induction k with + | zero => exact ⟨Ufinite_1, Vfinite_0⟩ + | succ k ih => exact ⟨Ufinite_step k ih.1 ih.2, Vfinite_step k ih.1 ih.2⟩ + +theorem Ufinite_all (k : ℕ) : Ufinite k := by + cases k with + | zero => exact Ufinite_0 + | succ k => exact (UVfinite k).1 + +theorem Vfinite_all (k : ℕ) : Vfinite k := (UVfinite k).2 + + +theorem pow4_next (k : ℕ) : 4 ^ (k + 1) = 4 * 4 ^ k := by + rw [Nat.pow_succ]; ring + +theorem U_prefix_M (k : ℕ) : + SegRLs tm (hf ^ (2 * 4 ^ (k + 1))) [] + ([O, O, O] ++ z4 ^ (k + 2) ++ [O]) + ([O, O, O] ++ z4 ^ (k + 1) ++ [O, I, I, I, I]) := by + have h1 := finite_suffix z4 (Ufinite_all (k + 1)) + have h2 : SegRLs tm (hf ^ 1) [] _ _ := bridge_L2 k + have h3 := finite_suffix [O, O, O, I, I] (Vfinite_all k) + have h4 := finite_suffix1 [I] (bridge_L4_1 k) + have h12 := finite_trans h1 h2 + have h123 := finite_trans h12 h3 + have h1234 := finite_trans h123 h4 + refine SegRLs.congr h1234 ?_ rfl (by norm_word) (by norm_word) + congr 1 + have := ucount_positive k + have := ucount_power k + dsimp [vcount, ucount] + omega + +theorem U_prefix_L (k : ℕ) : + SegRLs tm (hf ^ (4 ^ (k + 2))) [] + ([O, O, O] ++ z4 ^ (k + 2) ++ [O]) + ([O, O, O] ++ z4 ^ (k + 1) ++ [O, O, O, O, I]) := by + have h1 := U_prefix_M k + have h2 := finite_suffix [I, I, I, I] (Ufinite_all (k + 1)) + have h3 := finite_suffix1 [I] (bridge_L3_1 k) + have h4 := finite_suffix [O, O, I, I, I] (Vfinite_all k) + have h5 := finite_suffix1 [I] (bridge_L4_3 k) + have h12 := finite_trans h1 h2 + have h123 := finite_trans h12 h3 + have h1234 := finite_trans h123 h4 + have h12345 := finite_trans h1234 h5 + refine SegRLs.congr h12345 ?_ rfl (by norm_word) (by norm_word) + congr 1 + have := ucount_positive k + have := ucount_power k + have := pow4_next (k + 1) + rw [show k + 2 = (k + 1) + 1 by omega] + dsimp [vcount, ucount] at * + omega + +theorem U_near_end (k : ℕ) : + SegRLs tm (hf ^ (ucount (k + 2) - 5)) [] + ([O, O, O] ++ z4 ^ (k + 2) ++ [O]) + ([O, O, O] ++ z4 ^ 2 ++ a4 ^ k ++ [I]) := by + induction k with + | zero => + exact SegRLs.congr (U_prefix_L 0) rfl rfl (by norm_word) (by norm_word) + | succ k ih => + have h1 := U_prefix_L (k + 1) + have h2 := finite_suffix [O, O, O, I] ih + have h12 := finite_trans h1 h2 + refine SegRLs.congr h12 ?_ rfl (by norm_word) (by norm_word) + congr 1 + have := ucount_positive k + have := ucount_power (k + 2) + rw [show k + 1 + 2 = (k + 2) + 1 by omega] + dsimp [ucount] at * + omega + +theorem near_end_count (k : ℕ) : ucount (k + 2) - 5 = 16 * ucount k := by + dsimp [ucount]; omega + +theorem seek_top3 (k : ℕ) : + SegRLs tm (hf ^ (13 * 4 ^ (k + 7))) [] + ([O, O, O] ++ z4 ^ (k + 9) ++ [O]) + (([O, O, O] ++ z4 ^ (k + 6) ++ [O]) ++ seek_tail) := by + have h1 := U_prefix_M (k + 7) + have h2 := finite_suffix [I, I, I, I] (U_prefix_L (k + 6)) + have h3 := finite_suffix [O, O, O, I, I, I, I, I] (U_prefix_L (k + 5)) + have h12 := finite_trans h1 h2 (by rw [show k + 7 + 1 = k + 6 + 2 by omega]; norm_word) + have h123 := finite_trans h12 h3 (by rw [show k + 6 + 1 = k + 5 + 2 by omega]; norm_word) + refine SegRLs.congr h123 ?_ rfl + (by rw [show k + 7 + 2 = k + 9 by omega]) + (by rw [show k + 5 + 1 = k + 6 by omega]; norm_word) + congr 1 + have : 4 ^ (k + 7 + 1) = 4 * 4 ^ (k + 7) := pow4_next (k + 7) + have : 4 ^ (k + 6 + 2) = 4 * 4 ^ (k + 7) := by + rw [show k + 6 + 2 = (k + 7) + 1 by omega, pow4_next] + have : 4 ^ (k + 5 + 2) = 4 ^ (k + 7) := by congr 1 + omega + +theorem seek_lower (a : ℕ) : + SegRLs tm (hf ^ (4 ^ (a + 4) + 16 * ucount a)) [] + ([O, O, O] ++ z4 ^ (a + 4) ++ [O]) + ([O, O, O] ++ z4 ^ 2 ++ a4 ^ (a + 1) ++ z4 ++ [I]) := by + have h1 := U_prefix_L (a + 2) + have h2 := finite_suffix [O, O, O, O, O, O, O, I] (U_near_end a) + have h12 := finite_trans h1 h2 + refine SegRLs.congr h12 ?_ rfl + (by rw [show a + 2 + 2 = a + 4 by omega]) (by norm_word) + congr 1 + rw [near_end_count, show a + 2 + 2 = a + 4 by omega] + +theorem z4_recut (p q : ℕ) : z4 ^ (p + q) ++ [O] = (z4 ^ p ++ [O]) ++ z4 ^ q := by + rw [pow_add_list] + norm_word + +theorem reset_seek_finite (a b : ℕ) : + SegRLs tm (hf ^ (16 * ucount a + 4 ^ (a + 4) + 13 * 4 ^ (a + b + 7))) [] + ([O, O, O] ++ z4 ^ (a + b + 9) ++ [O]) + ([O, O, O] ++ z4 ^ 2 ++ a4 ^ (1 + a) ++ z4 ++ a4 ++ + z4 ^ (2 + b) ++ a4 ++ [I, I, I, I, I]) := by + have h1 := seek_top3 (a + b) + have h2 := finite_suffix (z4 ^ (b + 2) ++ seek_tail) (seek_lower a) + have hw : ([O, O, O] ++ z4 ^ (a + b + 6) ++ [O]) ++ seek_tail = + ([O, O, O] ++ z4 ^ (a + 4) ++ [O]) ++ (z4 ^ (b + 2) ++ seek_tail) := by + rw [show a + b + 6 = (a + 4) + (b + 2) by omega, pow_add_list] + norm_word + have h12 := finite_trans h1 h2 hw + refine SegRLs.congr h12 (by congr 1; omega) rfl (by norm_word) ?_ + rw [show b + 2 = 2 + b by omega] + norm_word + +-- ============================================================================ +-- 4. `H_cycle`, `H_lift` & Normal Caller `Ncfg` (`SOBCv14.v:453-605`) +-- ============================================================================ + +theorem H_cycle (a b : ℕ) : + SegRLs tm (hf ^ (4 ^ (a + 2))) hf (hword a (1 + b)) (hword (1 + a) b) := by + have h1 : SegRLs tm (hf ^ 1) hf _ _ := H_OA a b + have h2 := finite_suffix ([O, O, I] ++ b4 ^ b ++ a4 ++ [O]) (Ufinite_all (a + 1)) + have h3 : SegRLs tm (hf ^ 1) [] _ _ := H_OB (1 + a) b + have h4 := finite_suffix (c4 ^ b ++ [O, I, I, I, I]) (Vfinite_all (a + 1)) + have h12 := run_trans h1 h2 + have h123 := run_trans h12 h3 + have h1234 := run_trans h123 h4 + refine SegRLs.congr h1234 ?_ rfl (by norm_word) (by norm_word) + congr 1 + have := ucount_positive (a + 1) + have := ucount_power (a + 1) + rw [show a + 2 = (a + 1) + 1 by omega] + dsimp [vcount] + omega + + +theorem reset_seek (a b : ℕ) (r : ListBlank Γ) : + SideRLs tm (hf ^ (16 * ucount a + 4 ^ (a + 4) + 13 * 4 ^ (a + b + 7))) + (([O, O, O] ++ z4 ^ (a + b + 9) ++ [O]) +> r) + (([O, O, O] ++ z4 ^ 2 ++ a4 ^ (1 + a) ++ z4 ++ a4 ++ + z4 ^ (2 + b) ++ a4 ++ [I, I, I, I, I]) +> r) := + (reset_seek_finite a b).sideRLs_concat (.nil r) + +def Ncfg (n : ℕ) (r : ListBlank Γ) : Cfg Γ Λ := + default <{{F}} ((z4 ++ c4 ^ n ++ [O, I, I, I, I]) +> r) + +def Nleft (n : ℕ) : ListBlank Γ := + ([I, I, I, I, I] ++ [I, I, O, I] ^ (1 + n) ++ [I, I, O, O]) +> default + +private theorem shift_A_c4_step (l r : ListBlank Γ) : + (l {{A}}> (c4 +> r)) [tm]⊢* (([I, I, O, I] +> l) {{A}}> r) := + runSteps_spec tm 4 ⟨[], c4, A, .right⟩ ⟨[I, I, O, I], [], A, .right⟩ (by decide) l r + +private theorem shift_A_c4 (n : ℕ) (l r : ListBlank Γ) : + (l {{A}}> (c4 ^ n +> r)) [tm]⊢* (([I, I, O, I] ^ n +> l) {{A}}> r) := by + induction n generalizing l with + | zero => exact stepStar_refl tm _ + | succ n ih => + rw [pow_succ_list, append_assoc] + refine stepStar_trans (shift_A_c4_step l (c4 ^ n +> r)) ?_ + refine stepStar_congr (ih ([I, I, O, I] +> l)) rfl ?_ + rw [← append_assoc, ← pow_succ_list'] + +theorem N_out (n : ℕ) (r : ListBlank Γ) : + (Ncfg n r) [tm]⊢* (Nleft n {{F}}> r) := by + have h1 : (Ncfg n r) [tm]⊢* + (([I, I, O, I] +> ([I, I, O, O] +> default)) {{A}}> (c4 ^ n +> ([O, I, I, I, I] +> r))) := by + have h := runSteps_spec tm 13 ⟨z4, [O, O], F, .left⟩ + ⟨[I, I, O, I, I, I], [], A, .right⟩ (by decide) + default (c4 ^ n +> ([O, I, I, I, I] +> r)) + have hd : ([O, O] : List Γ) +> (default : ListBlank Γ) = default := + BoundedConfig.all0_spec (by decide) + have hl : ([I, I, O, I, I, I] : List Γ) +> (default : ListBlank Γ) = + [I, I, O, I] +> ([I, I, O, O] +> default) := + calc ([I, I, O, I, I, I] : List Γ) +> default + _ = [I, I, O, I, I, I] +> ([O, O] +> default) := by rw [hd] + _ = ([I, I, O, I] ++ [I, I, O, O]) +> default := by rw [← append_assoc]; rfl + _ = [I, I, O, I] +> ([I, I, O, O] +> default) := by rw [append_assoc] + simpa only [Ncfg, BoundedConfig.toCfg, append_nil, append_assoc, hd, hl] using h + have h2 := shift_A_c4 n ([I, I, O, I] +> ([I, I, O, O] +> default)) ([O, I, I, I, I] +> r) + have h2' : (([I, I, O, I] ^ n +> ([I, I, O, I] +> ([I, I, O, O] +> default))) {{A}}> + ([O, I, I, I, I] +> r)) = + (([I, I, O, I] +> ([I, I, O, I] ^ n +> ([I, I, O, O] +> default))) {{A}}> + ([O, I, I, I, I] +> r)) := by + congr 1 + rw [← append_assoc, ← pow_succ_list', pow_succ_list, append_assoc] + have h3 : (([I, I, O, I] +> ([I, I, O, I] ^ n +> ([I, I, O, O] +> default))) {{A}}> + ([O, I, I, I, I] +> r)) [tm]⊢* (Nleft n {{F}}> r) := by + have h := runSteps_spec tm 9 ⟨[I, I, O, I], [O, I, I, I, I], A, .right⟩ + ⟨[I, I, I, I, I] ++ [I, I, O, I], [], F, .right⟩ (by decide) + ([I, I, O, I] ^ n +> ([I, I, O, O] +> default)) r + have hl : ([I, I, I, I, I] ++ [I, I, O, I]) +> + ([I, I, O, I] ^ n +> ([I, I, O, O] +> (default : ListBlank Γ))) = Nleft n := by + unfold Nleft + rw [show (1 + n : ℕ) = n + 1 by omega, pow_succ_list] + simp only [append_assoc] + simpa only [BoundedConfig.toCfg, append_nil, hl] using h + exact stepStar_trans h1 (stepStar_trans (stepStar_congr h2 rfl h2') h3) + +def Nturn (n : ℕ) : ListBlank Γ := + ([I, I, I, I] ++ [O, I, I, I] ^ (2 + n)) +> default + +private theorem shift_E_1110_step (l r : ListBlank Γ) : + (([I] +> ([I, I, O, I] +> l)) <{{E}} ([O, O, I, I] +> r)) [tm]⊢* + (([I] +> l) <{{E}} ([O, O, I, I] +> ([O, O, I, I] +> r))) := by + have h := runSteps_spec tm 10 ⟨[O, O, I, I], [I, I, I, O], E, .left⟩ + ⟨[O, O, I, I] ++ [O, O, I, I], [], E, .left⟩ (by decide) ([I] +> l) r + have hl : ([I, I, I, O] : List Γ) +> ([I] +> l) = [I] +> ([I, I, O, I] +> l) := by + rw [← append_assoc, ← append_assoc]; rfl + simpa only [BoundedConfig.toCfg, append_nil, append_assoc, hl] using h + +private theorem shift_E_1110 (n : ℕ) (l r : ListBlank Γ) : + (([I] +> ([I, I, O, I] ^ n +> l)) <{{E}} ([O, O, I, I] +> r)) [tm]⊢* + (([I] +> l) <{{E}} ([O, O, I, I] +> ([O, O, I, I] ^ n +> r))) := by + induction n generalizing r with + | zero => exact stepStar_refl tm _ + | succ n ih => + rw [pow_succ_list, append_assoc] + refine stepStar_trans (shift_E_1110_step ([I, I, O, I] ^ n +> l) r) ?_ + refine stepStar_congr (ih ([O, O, I, I] +> r)) rfl ?_ + rw [← append_assoc ([O, O, I, I] ^ n) [O, O, I, I] r, ← pow_succ_list'] + +private theorem shift_F_0011_step (l r : ListBlank Γ) : + (l {{F}}> ([O, O, I, I] +> r)) [tm]⊢* (([I, O, I, I] +> l) {{F}}> r) := + runSteps_spec tm 4 ⟨[], [O, O, I, I], F, .right⟩ ⟨[I, O, I, I], [], F, .right⟩ (by decide) l r + +private theorem shift_F_0011 (k : ℕ) (l r : ListBlank Γ) : + (l {{F}}> ([O, O, I, I] ^ k +> r)) [tm]⊢* (([I, O, I, I] ^ k +> l) {{F}}> r) := by + induction k generalizing l with + | zero => exact stepStar_refl tm _ + | succ k ih => + rw [pow_succ_list, append_assoc] + refine stepStar_trans (shift_F_0011_step l ([O, O, I, I] ^ k +> r)) ?_ + refine stepStar_congr (ih ([I, O, I, I] +> l)) rfl ?_ + rw [← append_assoc, ← pow_succ_list'] + +private theorem IOII_pow_I (k : ℕ) : + [I, O, I, I] ^ k ++ [I] = [I] ++ [O, I, I, I] ^ k := by + induction k with + | zero => rfl + | succ k ih => + rw [pow_succ_list [I, O, I, I] k, List.append_assoc [I, O, I, I], ih, + ← List.append_assoc [I, O, I, I] [I], + show [I, O, I, I] ++ [I] = [I] ++ [O, I, I, I] from rfl, + List.append_assoc [I] [O, I, I, I], ← pow_succ_list [O, I, I, I] k] + +theorem N_return_1 (n : ℕ) (r : ListBlank Γ) : + (Nleft n <{{E}} r) [tm]⊢* (Nturn n {{C}}> ([O] +> r)) := by + have h_nl : Nleft n = ([I, I, I, I, I, I, I, O] +> + ([I] +> ([I, I, O, I] ^ n +> ([I, I, O, O] +> default)))) := by + unfold Nleft + rw [pow_one_add [I, I, O, I] n] + simp only [← append_assoc] + rfl + have h1 : (Nleft n <{{E}} r) [tm]⊢* + (([I] +> ([I, I, O, I] ^ n +> ([I, I, O, O] +> default))) <{{E}} + ([O, O, I, I] +> (z4 +> r))) := by + rw [h_nl] + have h := runSteps_spec tm 14 ⟨[], [I, I, I, I, I, I, I, O], E, .left⟩ + ⟨[O, O, I, I] ++ z4, [], E, .left⟩ (by decide) + ([I] +> ([I, I, O, I] ^ n +> ([I, I, O, O] +> default))) r + simpa only [BoundedConfig.toCfg, append_nil, append_assoc] using h + have h2 := shift_E_1110 n ([I, I, O, O] +> default) (z4 +> r) + have h3 : (([I] +> ([I, I, O, O] +> default)) <{{E}} + ([O, O, I, I] +> ([O, O, I, I] ^ n +> (z4 +> r)))) [tm]⊢* + (([I, O, I, I, I] +> default) {{F}}> ([O, O, I, I] ^ (1 + n) +> (z4 +> r))) := by + have h := runSteps_spec tm 15 ⟨[O, O, I, I], [I, I, I, O, O], E, .left⟩ + ⟨[I, O, I, I, I], [O, O, I, I], F, .right⟩ (by decide) + default ([O, O, I, I] ^ n +> (z4 +> r)) + have hl : ([I, I, I, O, O] : List Γ) +> (default : ListBlank Γ) = + [I] +> ([I, I, O, O] +> default) := by + rw [← append_assoc]; rfl + have hr : [O, O, I, I] +> ([O, O, I, I] ^ n +> (z4 +> r)) = + [O, O, I, I] ^ (1 + n) +> (z4 +> r) := by + rw [pow_one_add, append_assoc] + simpa only [BoundedConfig.toCfg, append_nil, hl, hr] using h + have h4 := shift_F_0011 (1 + n) ([I, O, I, I, I] +> default) (z4 +> r) + have h5 : (([I, O, I, I] ^ (1 + n) +> ([I, O, I, I, I] +> default)) {{F}}> (z4 +> r)) [tm]⊢* + (Nturn n {{C}}> ([O] +> r)) := by + have h := runSteps_spec tm 3 ⟨[], [O, O, O], F, .right⟩ + ⟨[I, I, I], [], C, .right⟩ (by decide) + ([I, O, I, I] ^ (1 + n) +> ([I, O, I, I, I] +> default)) ([O] +> r) + have hl : [I, I, I] +> ([I, O, I, I] ^ (1 + n) +> ([I, O, I, I, + I] +> (default : ListBlank Γ))) = + Nturn n := by + unfold Nturn + rw [← append_assoc, ← append_assoc] + congr 1 + have hio := IOII_pow_I (1 + n) + rw [show [I, I, I] ++ [I, O, I, I] ^ (1 + n) ++ [I, O, I, I, I] = + [I, I, I] ++ ([I, O, I, I] ^ (1 + n) ++ [I]) ++ [O, I, I, I] from by norm_word, + hio] + norm_word + have hr : ([O, O, O] : List Γ) +> ([O] +> r) = z4 +> r := by + rw [← append_assoc]; rfl + simpa only [BoundedConfig.toCfg, append_nil, hl, hr] using h + exact stepStar_trans h1 (stepStar_trans h2 (stepStar_trans h3 (stepStar_trans h4 h5))) + +private theorem shift_E_10111_step (l r : ListBlank Γ) : + (([I] +> ([O, I, I, I] +> l)) <{{E}} (z4 +> r)) [tm]⊢* + (([I] +> l) <{{E}} (z4 +> ([I, I, O, O] +> r))) := by + have h := runSteps_spec tm 10 ⟨z4, [I, O, I, I, I], E, .left⟩ + ⟨z4 ++ [I, I, O, O], [I], E, .left⟩ (by decide) l r + have hl : ([I, O, I, I, I] : List Γ) +> l = [I] +> ([O, I, I, I] +> l) := by + rw [← append_assoc]; rfl + simpa only [BoundedConfig.toCfg, append_nil, append_assoc, hl] using h + +private theorem shift_E_10111 (k : ℕ) (l r : ListBlank Γ) : + (([I] +> ([O, I, I, I] ^ k +> l)) <{{E}} (z4 +> r)) [tm]⊢* + (([I] +> l) <{{E}} (z4 +> ([I, I, O, O] ^ k +> r))) := by + induction k generalizing r with + | zero => exact stepStar_refl tm _ + | succ k ih => + rw [pow_succ_list, append_assoc] + refine stepStar_trans (shift_E_10111_step ([O, I, I, I] ^ k +> l) r) ?_ + refine stepStar_congr (ih ([I, I, O, O] +> r)) rfl ?_ + rw [← append_assoc ([I, I, O, O] ^ k) [I, I, O, O] r, ← pow_succ_list'] + +private theorem nreturn2_out_eq (n : ℕ) : + [O] ++ z4 ++ [I, I, O, O] ^ (1 + n) ++ [I, I, I, I] = + z4 ++ c4 ^ (1 + n) ++ [O, I, I, I, I] := by + have h := h_ob_out_eq (1 + n) + rw [show [O] ++ z4 ++ [I, I, O, O] ^ (1 + n) ++ [I, I, I, I] = + z4 ++ ([O] ++ [I, I, O, O] ^ (1 + n) ++ [I, I, I, I]) from by norm_word, + h] + norm_word + +theorem N_return_2 (n : ℕ) (r : ListBlank Γ) : + (Nturn n {{C}}> ([O] +> r)) [tm]⊢* (Ncfg (1 + n) r) := by + have h_nt : Nturn n = ([I, I, I, I, O, I, I] +> + ([I] +> ([O, I, I, I] ^ (1 + n) +> default))) := by + unfold Nturn + rw [show 2 + n = 1 + (1 + n) by omega, pow_one_add [O, I, I, I] (1 + n)] + rw [← append_assoc, ← append_assoc] + rfl + have h1 : (Nturn n {{C}}> ([O] +> r)) [tm]⊢* + (([I] +> ([O, I, I, I] ^ (1 + n) +> default)) <{{E}} (z4 +> ([I, I, I, I] +> r))) := by + rw [h_nt] + have h := runSteps_spec tm 14 ⟨[I, I, I, I, O, I, I], [O], C, .right⟩ + ⟨z4 ++ [I, I, I, I], [], E, .left⟩ (by decide) + ([I] +> ([O, I, I, I] ^ (1 + n) +> default)) r + simpa only [BoundedConfig.toCfg, append_nil, append_assoc] using h + have h2 := shift_E_10111 (1 + n) default ([I, I, I, I] +> r) + have h3 : (([I] +> default) <{{E}} (z4 +> ([I, I, O, O] ^ (1 + n) +> ([I, I, I, I] +> r)))) [tm]⊢* + (Ncfg (1 + n) r) := by + have h := runSteps_spec tm 1 ⟨[], [I], E, .left⟩ + ⟨[O], [], F, .left⟩ (by decide) + default (z4 +> ([I, I, O, O] ^ (1 + n) +> ([I, I, I, I] +> r))) + have hr : [O] +> (z4 +> ([I, I, O, O] ^ (1 + n) +> ([I, I, I, I] +> r))) = + (z4 ++ c4 ^ (1 + n) ++ [O, I, I, I, I]) +> r := by + rw [← append_assoc, ← append_assoc, ← append_assoc, nreturn2_out_eq] + simpa only [BoundedConfig.toCfg, Ncfg, append_nil, hr] using h + exact stepStar_trans h1 (stepStar_trans h2 h3) + +theorem N_return (n : ℕ) (r : ListBlank Γ) : + (Nleft n <{{E}} r) [tm]⊢* (Ncfg (1 + n) r) := + stepStar_trans (N_return_1 n r) (N_return_2 n r) + +theorem N_step (n : ℕ) (r r' : ListBlank Γ) (H : SideRL tm (F, []) (E, []) r r') : + (Ncfg n r) [tm]⊢⁺ (Ncfg (1 + n) r') := + stepStar_stepPlus_trans (N_out n r) + (stepPlus_stepStar_trans (H (Nleft n)) (N_return n r')) + +theorem N_run (m n : ℕ) (r r' : ListBlank Γ) (H : SideRLs tm (hf ^ m) r r') : + (Ncfg n r) [tm]⊢* (Ncfg (n + m) r') := + SegCount.N_run (fun n r r_mid h => by { cases h with | cons h_call h_rest => + cases h_rest; have h_step := + N_step n r r_mid h_call; rwa [Nat.add_comm 1 n] at h_step }) m n r r' H + +theorem N_H_lift (n a b j : ℕ) (r r' : ListBlank Γ) (H : SideRLs tm (hf ^ j) r r') : + (Ncfg n (hword a (j + b) +> r)) [tm]⊢* + (Ncfg (n + 4 ^ (a + 2) * qcount j) (hword (a + j) b +> r')) := + SegCount.N_H_lift (fun n r r_mid h => by { cases h with | cons h_call h_rest => + cases h_rest; have h_step := + N_step n r r_mid h_call; rwa [Nat.add_comm 1 n] at h_step }) H_cycle n a b j r r' H + +theorem H_empty_batch (a : ℕ) : + SegRLs tm (hf ^ (1 + ucount (a + 2))) hf (hword a 0) + ([O, O, I] ++ a4 ^ (a + 2) ++ [I]) := by + have h1 : SegRLs tm (hf ^ 1) hf _ _ := H_empty_F a + have h2 := Ufinite_all (a + 2) + exact run_trans h1 h2 + +-- ============================================================================ +-- 5. Saturated Carry, `N_E_return`, & `boundary_reset` (`SOBCv14.v:639-1085`) +-- ============================================================================ + +theorem saturated_bit (k : ℕ) : + SegRLs tm (hf ^ (4 ^ (1 + k))) [] + ([O, O, I] ++ a4 ^ (1 + k) ++ [O]) + ([O, O, I] ++ a4 ^ (1 + k) ++ [I]) := by + cases k with + | zero => exact BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + | succ k => + have h1 : SegRLs tm (hf ^ 1) [] _ _ := bridge_L2 k + have h2 := finite_suffix [O, O, O, I, I] (Vfinite_all k) + have h3 := finite_suffix1 [I] (bridge_L4_1 k) + have h4 := finite_suffix [I, I, I, I] (Ufinite_all (k + 1)) + have h5 := finite_suffix1 [I] (bridge_L3_1 k) + have h6 := finite_suffix [O, O, I, I, I] (Vfinite_all k) + have h7 := finite_suffix1 [I] (bridge_L4_3 k) + have h8 := finite_suffix [O, O, O, I] (Ufinite_all (k + 1)) + have h12 := finite_trans h1 h2 + have h123 := finite_trans h12 h3 + have h1234 := finite_trans h123 h4 + have h12345 := finite_trans h1234 h5 + have h123456 := finite_trans h12345 h6 + have h1234567 := finite_trans h123456 h7 + have h12345678 := finite_trans h1234567 h8 + refine SegRLs.congr h12345678 ?_ rfl (by norm_word) (by norm_word) + congr 1 + have := ucount_positive k + have := ucount_power (k + 1) + rw [show 1 + (k + 1) = (k + 1) + 1 by omega] + dsimp [vcount, ucount] at * + omega + +theorem saturated_zeros (p k : ℕ) : + SegRLs tm (hf ^ (4 ^ (1 + k) * ucount p)) [] + ([O, O, I] ++ a4 ^ (1 + k) ++ z4 ^ p ++ [O, O, O, I]) + ([O, O, I] ++ a4 ^ (1 + k + p) ++ b4) := by + induction p generalizing k with + | zero => + have h := finite_suffix [O, O, I] (saturated_bit k) + refine SegRLs.congr h (by rw [ucount, Nat.mul_one]) rfl (by norm_word) ?_ + rw [Nat.add_zero] + norm_word + | succ p ih => + have h1 := finite_suffix ([O, O, O] ++ z4 ^ p ++ [O, O, O, I]) (saturated_bit k) + have h2 := ih (k + 1) + have h12 := finite_trans h1 h2 + refine SegRLs.congr h12 ?_ rfl (by norm_word) + (by rw [show 1 + k + (p + 1) = 1 + (k + 1) + p by omega]) + congr 1 + rw [ucount, show 1 + (k + 1) = (1 + k) + 1 by omega, pow4_next] + ring + +private theorem shift_F_11101_step (l r : ListBlank Γ) : + (([I] +> ([I, I, O, I] +> l)) <{{F}} ([O, O, O, I, I, O, O] +> r)) [tm]⊢* + (([I] +> l) <{{F}} ([O, O, O, I, I, O, O] +> ([I, I, O, O] +> r))) := by + have h := runSteps_spec tm 12 ⟨[O, O, O, I, I, O, O], [I, I, I, O, I], F, .left⟩ + ⟨[O, O, O, I, I, O, O] ++ [I, I, O, O], [I], F, .left⟩ (by decide) l r + have hl : ([I, I, I, O, I] : List Γ) +> l = [I] +> ([I, I, O, I] +> l) := by + rw [← append_assoc]; rfl + simpa only [BoundedConfig.toCfg, append_nil, append_assoc, hl] using h + +private theorem shift_F_11101 (n : ℕ) (l r : ListBlank Γ) : + (([I] +> ([I, I, O, I] ^ n +> l)) <{{F}} ([O, O, O, I, I, O, O] +> r)) [tm]⊢* + (([I] +> l) <{{F}} ([O, O, O, I, I, O, O] +> ([I, I, O, O] ^ n +> r))) := by + induction n generalizing r with + | zero => exact stepStar_refl tm _ + | succ n ih => + rw [pow_succ_list, append_assoc] + refine stepStar_trans (shift_F_11101_step ([I, I, O, I] ^ n +> l) r) ?_ + refine stepStar_congr (ih ([I, I, O, O] +> r)) rfl ?_ + rw [← append_assoc ([I, I, O, O] ^ n) [I, I, O, O] r, ← pow_succ_list'] + +private theorem shift_C_b4_step (l r : ListBlank Γ) : + (l {{C}}> (b4 +> r)) [tm]⊢* (([O, I, I, I] +> l) {{C}}> r) := + runSteps_spec tm 4 ⟨[], b4, C, .right⟩ ⟨[O, I, I, I], [], C, .right⟩ (by decide) l r + +private theorem shift_C_b4 (n : ℕ) (l r : ListBlank Γ) : + (l {{C}}> (b4 ^ n +> r)) [tm]⊢* (([O, I, I, I] ^ n +> l) {{C}}> r) := by + induction n generalizing l with + | zero => exact stepStar_refl tm _ + | succ n ih => + rw [pow_succ_list, append_assoc] + refine stepStar_trans (shift_C_b4_step l (b4 ^ n +> r)) ?_ + refine stepStar_congr (ih ([O, I, I, I] +> l)) rfl ?_ + rw [← append_assoc, ← pow_succ_list'] + +private theorem shift_F_0111_step (l r : ListBlank Γ) : + (([O, I, I, I] +> l) <{{F}} ([O, O, O, O, O, I, I] +> r)) [tm]⊢* + (l <{{F}} ([O, O, O, O, O, I, I] +> ([O, O, I, I] +> r))) := by + have h := runSteps_spec tm 10 ⟨[O, O, O, O, O, I, I], [O, I, I, I], F, .left⟩ + ⟨[O, O, O, O, O, I, I] ++ [O, O, I, I], [], F, .left⟩ (by decide) l r + simpa only [BoundedConfig.toCfg, append_nil, append_assoc] using h + +private theorem shift_F_0111 (n : ℕ) (l r : ListBlank Γ) : + (([O, I, I, I] ^ n +> l) <{{F}} ([O, O, O, O, O, I, I] +> r)) [tm]⊢* + (l <{{F}} ([O, O, O, O, O, I, I] +> ([O, O, I, I] ^ n +> r))) := by + induction n generalizing r with + | zero => exact stepStar_refl tm _ + | succ n ih => + rw [pow_succ_list, append_assoc] + refine stepStar_trans (shift_F_0111_step ([O, I, I, I] ^ n +> l) r) ?_ + refine stepStar_congr (ih ([O, O, I, I] +> r)) rfl ?_ + rw [← append_assoc ([O, O, I, I] ^ n) [O, O, I, I] r, ← pow_succ_list'] + +private theorem neret_mid_eq (n : ℕ) : + [I, O, O, I, I, O, O] ++ [I, I, O, O] ^ n ++ z4 = + b4 ^ n ++ [I, O, O, I, I, O, O, O, O, O, O] := by + induction n with + | zero => rfl + | succ n ih => + have h1 : [I, O, O, I, I, O, O] ++ [I, I, O, O] ^ (n + 1) ++ z4 = + b4 ++ ([I, O, O, I, I, O, O] ++ [I, I, O, O] ^ n ++ z4) := by + rw [pow_succ_list]; simp only [b4, List.cons_append, List.nil_append] + rw [h1, ih, pow_succ_list, List.append_assoc] + +private theorem neret_end_eq (n : ℕ) : + [O, I, I] ++ [O, O, I, I] ^ n ++ [I, I, O, O] = + c4 ^ n ++ [O, I, I, I, I, O, O] := by + induction n with + | zero => rfl + | succ n ih => + have h1 : [O, I, I] ++ [O, O, I, I] ^ (n + 1) ++ [I, I, O, O] = + c4 ++ ([O, I, I] ++ [O, O, I, I] ^ n ++ [I, I, O, O]) := by + rw [pow_succ_list]; simp only [c4, List.cons_append, List.nil_append] + rw [h1, ih, pow_succ_list, List.append_assoc] + +theorem N_E_return (n : ℕ) (r : ListBlank Γ) : + (Nleft n <{{F}} ([O, O, O] +> r)) [tm]⊢⁺ + (Ncfg 0 (([O, O, O] ++ c4 ^ n ++ [O, I, I, I, I, O, O]) +> r)) := by + have h_nl : Nleft n = ([I, I, I, I, I, I, I, O] +> + ([I] +> ([I, I, O, I] ^ n +> ([I, I, O, O] +> default)))) := by + unfold Nleft + rw [pow_one_add [I, I, O, I] n] + simp only [← append_assoc] + rfl + have h1 : (Nleft n <{{F}} ([O, O, O] +> r)) [tm]⊢⁺ + (([I] +> ([I, I, O, I] ^ n +> ([I, I, O, O] +> default))) <{{F}} + ([O, O, O, I, I, O, O] +> (z4 +> r))) := by + rw [h_nl] + have h := runSteps1_spec tm 15 ⟨[O, O, O], [I, I, I, I, I, I, I, O], F, .left⟩ + ⟨[O, O, O, I, I, O, O] ++ z4, [], F, .left⟩ (by decide) + ([I] +> ([I, I, O, I] ^ n +> ([I, I, O, O] +> default))) r + simpa only [BoundedConfig.toCfg, append_nil, append_assoc] using h + have h2 := shift_F_11101 n ([I, I, O, O] +> default) (z4 +> r) + have h3 : (([I] +> ([I, I, O, O] +> default)) <{{F}} + ([O, O, O, I, I, O, O] +> ([I, I, O, O] ^ n +> (z4 +> r)))) [tm]⊢* + (([I, I, I, I, I, I, O, O] +> default) {{C}}> + (b4 ^ n +> ([I, O, O, I, I, O, O, O, O, O, O] +> r))) := by + have h := runSteps_spec tm 29 ⟨[O, O, O, I, I, O, O], [I, I, I, O, O, O, O, O], F, .left⟩ + ⟨[I, I, I, I, I, I, O, O], [I, O, O, I, I, O, O], C, .right⟩ (by decide) + default ([I, I, O, O] ^ n +> (z4 +> r)) + have hl : ([I, I, I, O, O, O, O, O] : List Γ) +> (default : ListBlank Γ) = + [I] +> ([I, I, O, O] +> default) := by + rw [show ([I, I, I, O, O, O, O, O] : List Γ) = [I, I, I, O, O] ++ [O, O, O] from rfl, + append_assoc, BoundedConfig.all0_spec (a := [O, O, O]) (by decide)] + rfl + have hr : [I, O, O, I, I, O, O] +> ([I, I, O, O] ^ n +> (z4 +> r)) = + b4 ^ n +> ([I, O, O, I, I, O, O, O, O, O, O] +> r) := by + rw [← append_assoc, ← append_assoc, neret_mid_eq, append_assoc] + simpa only [BoundedConfig.toCfg, append_nil, hl, hr] using h + have h4 := shift_C_b4 n ([I, I, I, I, I, I, O, O] +> default) + ([I, O, O, I, I, O, O, O, O, O, O] +> r) + have h5 : (([O, I, I, I] ^ n +> ([I, I, I, I, I, I, O, O] +> default)) {{C}}> + ([I, O, O, I, I, O, O, O, O, O, O] +> r)) [tm]⊢* + (([O, I, I, I] ^ n +> ([I, I, I, I, I, I, O, O] +> default)) <{{F}} + ([O, O, O, O, O, I, I] +> ([I, I, O, O] +> r))) := by + have h := runSteps_spec tm 23 ⟨[], [I, O, O, I, I, O, O, O, O, O, O], C, .right⟩ + ⟨[O, O, O, O, O, I, I] ++ [I, I, O, O], [], F, .left⟩ (by decide) + ([O, I, I, I] ^ n +> ([I, I, I, I, I, I, O, O] +> default)) r + simpa only [BoundedConfig.toCfg, append_nil, append_assoc] using h + have h6 := shift_F_0111 n ([I, I, I, I, I, I, O, O] +> default) ([I, I, O, O] +> r) + have h7 : (([I, I, I, I, I, I, O, O] +> default) <{{F}} + ([O, O, O, O, O, I, I] +> ([O, O, I, I] ^ n +> ([I, I, O, O] +> r)))) [tm]⊢* + (Ncfg 0 (([O, O, O] ++ c4 ^ n ++ [O, I, I, I, I, O, O]) +> r)) := by + have h := runSteps_spec tm 36 ⟨[O, O, O, O, O], [I, I, I, I, I, I, O, O], F, .left⟩ + ⟨z4 ++ [O, I, I, I, I] ++ [O, O, O] ++ [O], [], F, .left⟩ (by decide) + default ([I, I] +> ([O, O, I, I] ^ n +> ([I, I, O, O] +> r))) + have hr1 : ([O, O, O, O, O] : List Γ) +> ([I, I] +> ([O, O, I, I] ^ n +> ([I, I, O, O] +> r))) = + [O, O, O, O, O, I, I] +> ([O, O, I, I] ^ n +> ([I, I, O, O] +> r)) := by + rw [← append_assoc]; rfl + have hr2 : (z4 ++ [O, I, I, I, I] ++ [O, O, O] ++ [O]) +> + ([I, I] +> ([O, O, I, I] ^ n +> ([I, I, O, O] +> r))) = + (z4 ++ c4 ^ 0 ++ [O, I, I, I, I]) +> (([O, O, O] ++ c4 ^ n ++ [O, I, I, I, I, O, + O]) +> r) := by + rw [pow_zero_list, List.append_nil, + show (z4 ++ [O, I, I, I, I] ++ [O, O, O] ++ [O]) +> + ([I, I] +> ([O, O, I, I] ^ n +> ([I, I, O, O] +> r))) = + (z4 ++ [O, I, I, I, I]) +> (([O, O, O] ++ ([O, I, I] ++ [O, O, I, I] ^ n ++ [I, I, O, + O])) +> r) + from by simp only [← append_assoc]; rfl, + neret_end_eq, ← List.append_assoc [O, O, O]] + simpa only [BoundedConfig.toCfg, Ncfg, append_nil, hr1, hr2] using h + exact stepPlus_stepStar_trans h1 + (stepStar_trans h2 (stepStar_trans h3 (stepStar_trans h4 (stepStar_trans h5 (stepStar_trans h6 + h7))))) + +theorem N_E_reset (n : ℕ) (r r' : ListBlank Γ) + (H : SideRL tm (F, []) (F, []) r ([O, O, O] +> r')) : + (Ncfg n r) [tm]⊢⁺ (Ncfg 0 (([O, O, O] ++ c4 ^ n ++ [O, I, I, I, I, O, O]) +> r')) := + stepStar_stepPlus_trans (N_out n r) (stepPlus_trans (H (Nleft n)) (N_E_return n r')) + +theorem C_BAAZ : + SegRLs tm [((C, []), (F, []))] [] + (b4 ++ a4 ++ a4 ++ z4) (z4 ++ c4 ++ [O, O, O, I] ++ a4) := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem A_C0001 : + SegRLs tm [((A, []), (F, []))] [] + (c4 ++ [O, O, O, I]) [O, O, O, I, I, I, I, I] := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem C_B1111 : + SegRLs tm [((C, []), (F, []))] [] (b4 ++ [I, I, I, I]) (z4 ++ z4) := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem A_AZ : + SegRLs tm [((A, []), (E, []))] [] (a4 ++ z4) (z4 ++ [I, I, I, I]) := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem P_to_J (k r : ℕ) (w y : List Γ) + (H : SegRLs tm [((C, []), (F, []))] [] w (z4 ^ r ++ y)) : + SegRLs tm (hf ^ (1 + vcount (k + r))) [] + ([O, O, I] ++ a4 ^ (1 + k) ++ w) + ([O, O, I] ++ d4 ++ e4 ^ (k + r) ++ y) := by + have h1 : SegRLs tm (hf ^ 1) [] _ _ := (P_F k).concat H + have h2 := finite_suffix y (Vfinite_all (k + r)) + have h12 := finite_trans h1 h2 (by rw [pow_add_list]; norm_word) + exact SegRLs.congr h12 rfl rfl (by norm_word) (by norm_word) + +theorem J_to_P (a s : ℕ) (w y : List Γ) + (H : SegRLs tm [((A, []), (F, []))] [] w (z4 ^ s ++ [O] ++ y)) : + SegRLs tm (hf ^ (1 + ucount (1 + a + s))) [] + ([O, O, I] ++ d4 ++ e4 ^ a ++ w) + ([O, O, I] ++ a4 ^ (1 + a + s) ++ [I] ++ y) := by + have h1 : SegRLs tm (hf ^ 1) [] _ _ := (J_F a).concat H + have h2 := finite_suffix y (Ufinite_all (1 + a + s)) + have h12 := finite_trans h1 h2 (by rw [pow_add_list z4 (1 + a) s]; norm_word) + exact SegRLs.congr h12 rfl rfl (by norm_word) (by norm_word) + +theorem H_advance (a p : ℕ) : + SegRLs tm (hf ^ (4 ^ (a + 3))) [] + (hword a 0 ++ [O, O, O] ++ z4 ^ (2 + p)) + (hword (a + 2) 0 ++ [O, O, O] ++ z4 ^ p) := by + have hcall := finite_suffix ([O, O, O] ++ z4 ^ (1 + p)) Ufinite_0 + have h1 := (H_empty_batch a).concat hcall + have h2 := finite_suffix1 ([O, O, O] ++ z4 ^ p) (H_OB (a + 2) 0) + have h3 := finite_suffix ([O, I, I, I, I, O, O, O] ++ z4 ^ p) (Vfinite_all (a + 2)) + have h12 := finite_trans h1 h2 + have h123 := finite_trans h12 h3 + refine SegRLs.congr h123 ?_ rfl (by norm_word) (by norm_word) + congr 1 + have := ucount_positive (a + 2) + have := ucount_power (a + 2) + rw [show a + 3 = (a + 2) + 1 by omega] + dsimp [vcount] + omega + +theorem ucount_add (a b : ℕ) : + ucount (a + b + 1) = ucount a + 4 ^ (a + 1) * ucount b := by + have ha := ucount_power a + have hb := ucount_power b + have hab := ucount_power (a + b + 1) + rw [show a + b + 1 + 1 = (a + 1) + (b + 1) by omega, Nat.pow_add] at hab + nlinarith + +theorem H_collapse (a k : ℕ) : + SegRLs tm (hf ^ (1 + ucount (a + k + 2))) [] + (hword a 0 ++ [O, O, O] ++ a4 ^ k ++ z4) + ([O, O, I] ++ a4 ^ (a + k + 2) ++ b4 ++ a4) := by + cases k with + | zero => + have hcall := finite_suffix [O, O, O] Ufinite_0 + have h := (H_empty_batch a).concat hcall + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + | succ k => + have h1 := (H_empty_batch a).concat (F_AZ_large k) + have h2 := finite_suffix a4 (saturated_zeros k (a + 2)) + have h12 := finite_trans h1 h2 + refine SegRLs.congr h12 ?_ rfl (by norm_word) + (by rw [show a + (k + 1) + 2 = 1 + (a + 2) + k by omega]) + congr 1 + have hc := ucount_add (a + 2) k + rw [show a + 2 + k + 1 = a + (k + 1) + 2 by omega, show 1 + (a + 2) = a + 2 + 1 by omega] at * + omega + +theorem boundary_five (a b p : ℕ) : + SegRLs tm (hf ^ (4 ^ (a + 3) + 13 * 4 ^ (a + b + 5))) [] + (hword a 0 ++ [O, O, O] ++ z4 ^ 2 ++ a4 ^ b ++ z4 ++ a4 ++ z4 ^ (2 + p)) + ([O, O, I] ++ d4 ++ e4 ^ (a + b + 6) ++ a4 ++ z4 ^ (1 + p)) := by + have h1 := finite_suffix (a4 ^ b ++ z4 ++ a4 ++ z4 ^ (2 + p)) (H_advance a 0) + have h2 := finite_suffix (a4 ++ z4 ^ (2 + p)) (H_collapse (a + 2) b) + have hc3 : SegRLs tm [((C, []), (F, []))] [] + (b4 ++ a4 ++ a4 ++ z4 ^ (2 + p)) + (z4 ^ 1 ++ (c4 ++ [O, O, O, I] ++ a4 ++ z4 ^ (1 + p))) := + SegRLs.congr (segment_suffix (z4 ^ (1 + p)) C_BAAZ) rfl rfl (by norm_word) (by norm_word) + have h3 := P_to_J (a + b + 3) 1 _ _ hc3 + have hc4 : SegRLs tm [((A, []), (F, []))] [] + (c4 ++ [O, O, O, I] ++ a4 ++ z4 ^ (1 + p)) + (z4 ^ 0 ++ [O] ++ ([O, O, I, I, I, I, I] ++ a4 ++ z4 ^ (1 + p))) := + SegRLs.congr (segment_suffix (a4 ++ z4 ^ (1 + p)) A_C0001) rfl rfl (by norm_word) (by norm_word) + have h4 := J_to_P (a + b + 4) 0 _ _ hc4 + have hc5 : SegRLs tm [((C, []), (F, []))] [] + (b4 ++ [I, I, I, I] ++ a4 ++ z4 ^ (1 + p)) + (z4 ^ 2 ++ (a4 ++ z4 ^ (1 + p))) := + SegRLs.congr (segment_suffix (a4 ++ z4 ^ (1 + p)) C_B1111) rfl rfl (by norm_word) (by norm_word) + have h5 := P_to_J (a + b + 4) 2 _ _ hc5 + have h12 := finite_trans h1 h2 + have h123 := finite_trans h12 h3 + (by rw [show a + 2 + b + 2 = 1 + (a + b + 3) by omega]; norm_word) + have h1234 := finite_trans h123 h4 + (by rw [show a + b + 3 + 1 = a + b + 4 by omega]) + have h12345 := finite_trans h1234 h5 + (by rw [show 1 + (a + b + 4) + 0 = 1 + (a + b + 4) by omega]; norm_word) + refine SegRLs.congr h12345 ?_ rfl (by norm_word) + (by rw [show a + b + 4 + 2 = a + b + 6 by omega]; norm_word) + congr 1 + have := ucount_positive (a + b + 4) + have := ucount_power (a + b + 4) + rw [show a + 2 + b + 2 = a + b + 4 by omega, + show a + b + 3 + 1 = a + b + 4 by omega, + show 1 + (a + b + 4) + 0 = (a + b + 4) + 1 by omega, + show a + b + 4 + 2 = (a + b + 4) + 2 by omega, + show a + b + 5 = (a + b + 4) + 1 by omega] + dsimp [vcount, ucount] at * + omega + +theorem finite_single_side {h₁ h₂ : DH0 Γ Λ} {w₁ w₂ : List Γ} (r : ListBlank Γ) + (H : SegRLs tm [(h₁, h₂)] [] w₁ w₂) : + SideRL tm h₁ h₂ (w₁ +> r) (w₂ +> r) := by + have hs := H.sideRLs_concat (.nil r) + cases hs with + | cons hcall hnil => + cases hnil + exact hcall + +theorem J_E_finite (a p : ℕ) : + SegRLs tm [((F, []), (F, []))] [] + ([O, O, I] ++ d4 ++ e4 ^ a ++ a4 ++ z4 ^ (1 + p)) + ([O, O, O] ++ z4 ^ (a + 2) ++ [I, I, I, I] ++ z4 ^ p) := by + have h := segment_suffix (z4 ^ p) ((J_E a).concat A_AZ) + exact SegRLs.congr h rfl rfl (by norm_word) (by norm_word) + +theorem J_reset (n a p : ℕ) (r : ListBlank Γ) : + (Ncfg n (([O, O, I] ++ d4 ++ e4 ^ a ++ a4 ++ z4 ^ (1 + p)) +> r)) [tm]⊢⁺ + (Ncfg 0 (([O, O, O] ++ c4 ^ n ++ [O, I, I, I, I, O, O] ++ + z4 ^ (a + 2) ++ [I, I, I, I] ++ z4 ^ p) +> r)) := by + have h := finite_single_side r (J_E_finite a p) + have h' : SideRL tm (F, []) (F, []) + (([O, O, I] ++ d4 ++ e4 ^ a ++ a4 ++ z4 ^ (1 + p)) +> r) + ([O, O, O] +> ((z4 ^ (a + 2) ++ [I, I, I, I] ++ z4 ^ p) +> r)) := by + intro l + simpa only [append_assoc] using h l + have hn := N_E_reset n _ _ h' + refine stepPlus_congr hn rfl ?_ + simp only [Ncfg, append_assoc] + +theorem boundary_reset (n a b p : ℕ) (r : ListBlank Γ) : + (Ncfg n ((hword a 0 ++ [O, O, O] ++ z4 ^ 2 ++ a4 ^ b ++ + z4 ++ a4 ++ z4 ^ (2 + p)) +> r)) [tm]⊢⁺ + (Ncfg 0 (([O, O, O] ++ c4 ^ (n + 4 ^ (a + 3) + 13 * 4 ^ (a + b + 5)) ++ + [O, I, I, I, I, O, O] ++ z4 ^ (a + b + 8) ++ [I, I, I, I] ++ z4 ^ p) +> r)) := by + have hf_side := (boundary_five a b p).sideRLs_concat (.nil r) + have hrun := N_run (4 ^ (a + 3) + 13 * 4 ^ (a + b + 5)) n _ _ hf_side + have hreset := J_reset (n + (4 ^ (a + 3) + 13 * 4 ^ (a + b + 5))) (a + b + 6) p r + refine stepStar_stepPlus_trans hrun (stepPlus_congr hreset rfl ?_) + rw [show n + (4 ^ (a + 3) + 13 * 4 ^ (a + b + 5)) = + n + 4 ^ (a + 3) + 13 * 4 ^ (a + b + 5) by omega, + show a + b + 6 + 2 = a + b + 8 by omega] + +theorem reset_lift (j : ℕ) (r r' : ListBlank Γ) (H : SideRLs tm (hf ^ j) r r') : + (Ncfg 0 (([O, O, O] ++ c4 ^ (1 + j) ++ [O, I, I, I, I]) +> r)) [tm]⊢⁺ + (Ncfg (1 + 16 * qcount j) (hword j 0 +> r')) := by + have hv := finite_suffix (c4 ^ j ++ [O, I, I, I, I]) Vfinite_0 + have hs := finite_single_side r hv + have hs' : SideRL tm (F, []) (E, []) + (([O, O, O] ++ c4 ^ (1 + j) ++ [O, I, I, I, I]) +> r) + (hword 0 j +> r) := by + have hw1 : ([O, O, O] ++ c4 ++ z4 ^ 0) ++ (c4 ^ j ++ [O, I, I, I, I]) = + [O, O, O] ++ c4 ^ (1 + j) ++ [O, I, I, I, I] := by norm_word + have hw2 : ([O, O, I] ++ d4 ++ e4 ^ 0) ++ (c4 ^ j ++ [O, I, I, I, I]) = hword 0 j := by + norm_word + intro l + simpa only [hw1, hw2] using hs l + have h1 := N_step 0 _ _ hs' + have h2 := N_H_lift 1 0 0 j r r' H + refine stepPlus_stepStar_trans h1 (stepStar_congr h2 ?_ ?_) + · rw [Nat.add_zero] + · simp only [Nat.zero_add]; rfl + +theorem reset_suffix_recut (k p : ℕ) : + [O, I, I, I, I, O, O] ++ z4 ^ (k + 1) ++ [I, I, I, I] ++ z4 ^ p = + [O, I, I, I, I] ++ [O, O, O] ++ z4 ^ k ++ [O, O, O, I, I, I, I] ++ z4 ^ p := by + norm_word + +def reset_budget (a b : ℕ) : ℕ := 16 * ucount a + 4 ^ (a + 4) + 13 * 4 ^ (a + b + 7) +def next_a (a b : ℕ) : ℕ := 63 + 208 * ucount a + 13 * 4 ^ (a + b + 7) + +theorem reset_budget_next (a b : ℕ) : reset_budget a b = 1 + next_a a b := by + unfold reset_budget next_a + have := ucount_power a + have : 4 ^ (a + 4) = 64 * 4 ^ (a + 1) := by + rw [show a + 4 = (a + 1) + 1 + 1 + 1 by omega, pow4_next, pow4_next, pow4_next] + ring + omega + +theorem invariant_forward_count (a b : ℕ) : + 1 + 16 * ucount a + 4 ^ (1 + a + 3) + 13 * 4 ^ (1 + a + (1 + b) + 5) = 2 + next_a a b := by + have hnext := reset_budget_next a b + unfold reset_budget at hnext + rw [show 1 + a + 3 = a + 4 by omega, + show 1 + a + (1 + b) + 5 = a + b + 7 by omega] + omega + +def invariant (a b p : ℕ) (r : ListBlank Γ) : Cfg Γ Λ := + Ncfg (1 + 16 * ucount a) + ((hword (1 + a) 0 ++ [O, O, O] ++ z4 ^ 2 ++ a4 ^ (1 + b) ++ + z4 ++ a4 ++ z4 ^ (2 + p)) +> r) + +theorem qcount_succ_ucount (k : ℕ) : qcount (1 + k) = ucount k := by + rw [Nat.add_comm 1 k]; rfl + +theorem reset_finish (a b p : ℕ) (r : ListBlank Γ) : + (Ncfg 0 (([O, O, O] ++ c4 ^ (2 + next_a a b) ++ [O, I, I, I, I, O, O] ++ + z4 ^ (a + b + 10) ++ [I, I, I, I] ++ z4 ^ p) +> r)) [tm]⊢⁺ + invariant (next_a a b) a b + ((a4 ++ [I, I, I, I] ++ b4 ++ [I, I, I] ++ z4 ^ p) +> r) := by + have hs := reset_seek a b (([O, O, I, I, I, I] ++ z4 ^ p) +> r) + have hl := reset_lift (reset_budget a b) _ _ hs + refine stepPlus_congr hl ?_ ?_ + · rw [reset_budget_next, show 1 + (1 + next_a a b) = 2 + next_a a b by omega, + show a + b + 10 = (a + b + 9) + 1 by omega] + apply congrArg (Ncfg 0) + simp only [← append_assoc] + apply congrArg (· +> r) + have hrecut := reset_suffix_recut (a + b + 9) p + have hrhs : [O, O, O] ++ c4 ^ (2 + next_a a b) ++ [O, I, I, I, I, O, O] ++ + z4 ^ ((a + b + 9) + 1) ++ [I, I, I, I] ++ z4 ^ p = + [O, O, O] ++ c4 ^ (2 + next_a a b) ++ + ([O, I, I, I, I, O, O] ++ z4 ^ ((a + b + 9) + 1) ++ [I, I, I, I] ++ z4 ^ p) := by + simp only [List.append_assoc] + rw [hrhs, hrecut] + simp only [List.append_assoc, List.cons_append, List.nil_append] + · rw [reset_budget_next, qcount_succ_ucount] + unfold invariant + apply congrArg (Ncfg _) + simp only [← append_assoc] + apply congrArg (· +> r) + simp only [b4, List.append_assoc, List.cons_append, List.nil_append] + +theorem invariant_forward (a b p : ℕ) (r : ListBlank Γ) : + (invariant a b p r) [tm]⊢⁺ + invariant (next_a a b) a b + ((a4 ++ [I, I, I, I] ++ b4 ++ [I, I, I] ++ z4 ^ p) +> r) := by + have h1 := boundary_reset (1 + 16 * ucount a) (1 + a) (1 + b) p r + have h1' : (invariant a b p r) [tm]⊢⁺ + (Ncfg 0 (([O, O, O] ++ c4 ^ (2 + next_a a b) ++ [O, I, I, I, I, O, O] ++ + z4 ^ (a + b + 10) ++ [I, I, I, I] ++ z4 ^ p) +> r)) := by + refine stepPlus_congr h1 rfl ?_ + rw [invariant_forward_count a b, show 1 + a + (1 + b) + 8 = a + b + 10 by omega] + exact stepPlus_trans h1' (reset_finish a b p r) + +-- ============================================================================ +-- 6. Entrance Families & `post_to_invariant` (`SOBCv14.v:1094-1872`) +-- ============================================================================ + +theorem A_C0011 : SegRLs tm [((A, []), (F, []))] [] (c4 ++ [O, O, I, I]) ([O, O, O, I] ++ a4) := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem C_BAW : SegRLs tm [((C, []), (F, []))] [] (b4 ++ a4 ++ [I, I, I, I]) (z4 ++ c4 ++ [O, O, I, + I]) := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem C_BAA0 : SegRLs tm [((C, []), (F, []))] [] (b4 ++ a4 ++ a4 ++ [O]) (z4 ++ c4 ++ [O, O, O, I, + I]) := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem A_CZ : SegRLs tm [((A, []), (F, []))] [] (c4 ++ z4) ([O, O, O, I] ++ d4) := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem C_BDZ : SegRLs tm [((C, []), (F, []))] [] (b4 ++ d4 ++ z4) (z4 ++ z4 ++ c4) := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem C_BD0011 : SegRLs tm [((C, []), (F, []))] [] (b4 ++ d4 ++ [O, O, I, I]) (z4 ^ 3) := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem A_B111 : SegRLs tm [((A, []), (E, []))] [] (b4 ++ [I, I, I]) [O, O, I, I, O, I, I] := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem C_BA6W : + SegRLs tm [((C, []), (F, []))] [] + (b4 ++ a4 ^ 6 ++ [I, I, I, I]) (z4 ++ c4 ++ z4 ^ 5 ++ [O, O, I, I]) := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem F_AZ_small : SegRLs tm hf [] ([O, O, O] ++ z4) ([O, O, I] ++ a4) := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +theorem J_consume (a : ℕ) : + SegRLs tm (hf ^ (4 ^ (a + 2))) [] + ([O, O, I] ++ d4 ++ e4 ^ a ++ c4 ++ [O, O, I, I] ++ [I, I, I, I]) + ([O, O, I] ++ d4 ++ e4 ^ (a + 1) ++ c4 ++ [O, O, I, I]) := by + have hc1 : SegRLs tm [((A, []), (F, []))] [] (c4 ++ [O, O, I, I]) + (z4 ^ 0 ++ [O] ++ ([O, O, I] ++ a4)) := A_C0011 + have h1 := finite_suffix [I, I, I, I] (J_to_P a 0 _ _ hc1) + have hc2 : SegRLs tm [((C, []), (F, []))] [] (b4 ++ a4 ++ [I, I, I, I]) + (z4 ^ 1 ++ (c4 ++ [O, O, I, I])) := + SegRLs.congr C_BAW rfl rfl rfl (by norm_word) + have h2 := P_to_J a 1 _ _ hc2 + have h12 := finite_trans h1 h2 + refine SegRLs.congr h12 ?_ rfl (by norm_word) (by norm_word) + congr 1 + have := ucount_positive (a + 1) + have := ucount_power (a + 1) + rw [show 1 + a + 0 = a + 1 by omega, show a + 2 = (a + 1) + 1 by omega] + dsimp [vcount] + omega + +theorem J_consume_many (s a : ℕ) : + SegRLs tm (hf ^ (4 ^ (a + 2) * qcount s)) [] + ([O, O, I] ++ d4 ++ e4 ^ a ++ c4 ++ [O, O, I, I] ++ [I, I, I, I] ^ s) + ([O, O, I] ++ d4 ++ e4 ^ (a + s) ++ c4 ++ [O, O, I, I]) := by + induction s generalizing a with + | zero => + simp only [qcount, Nat.mul_zero, Nat.add_zero, pow_zero_list, List.append_nil] + exact .nil _ + | succ s ih => + have h1 := finite_suffix ([I, I, I, I] ^ s) (J_consume a) + have h2 := ih (a + 1) + have h12 := finite_trans h1 h2 + refine SegRLs.congr h12 ?_ rfl (by norm_word) + (by rw [show a + 1 + s = a + (s + 1) by omega]) + congr 1 + rw [qcount_S, show a + 1 + 2 = (a + 2) + 1 by omega, pow4_next] + ring + +theorem J_terminal (a : ℕ) : + SegRLs tm (hf ^ (4 ^ (a + 2) + 3 * 4 ^ (a + 3))) [] + ([O, O, I] ++ d4 ++ e4 ^ a ++ c4 ++ [O, O, I, I] ++ a4 ++ z4 ^ 2) + ([O, O, I] ++ d4 ++ e4 ^ (a + 3) ++ a4 ++ z4) := by + have hc1 : SegRLs tm [((A, []), (F, []))] [] (c4 ++ [O, O, I, I]) + (z4 ^ 0 ++ [O] ++ ([O, O, I] ++ a4)) := A_C0011 + have h1 := finite_suffix (a4 ++ z4 ^ 2) (J_to_P a 0 _ _ hc1) + have hc2 : SegRLs tm [((C, []), (F, []))] [] (b4 ++ a4 ++ a4 ++ z4 ^ 2) + (z4 ^ 1 ++ (c4 ++ [O, O, O, I] ++ a4 ++ z4)) := + SegRLs.congr (segment_suffix [O, O, O, O, O, O, O] C_BAA0) rfl rfl (by norm_word) (by norm_word) + have h2 := P_to_J a 1 _ _ hc2 + have hc3 : SegRLs tm [((A, []), (F, []))] [] (c4 ++ [O, O, O, I] ++ a4 ++ z4) + (z4 ^ 0 ++ [O] ++ ([O, O, I, I, I, I, I] ++ a4 ++ z4)) := + SegRLs.congr (segment_suffix (a4 ++ z4) A_C0001) rfl rfl (by norm_word) (by norm_word) + have h3 := J_to_P (a + 1) 0 _ _ hc3 + have hc4 : SegRLs tm [((C, []), (F, []))] [] (b4 ++ [I, I, I, I] ++ a4 ++ z4) + (z4 ^ 2 ++ (a4 ++ z4)) := + SegRLs.congr (segment_suffix (a4 ++ z4) C_B1111) rfl rfl (by norm_word) (by norm_word) + have h4 := P_to_J (a + 1) 2 _ _ hc4 + have h12 := finite_trans h1 h2 + have h123 := finite_trans h12 h3 + have h1234 := finite_trans h123 h4 + (by rw [show 1 + (a + 1) + 0 = 1 + (a + 1) by omega]; norm_word) + refine SegRLs.congr h1234 ?_ rfl (by norm_word) + (by rw [show a + 1 + 2 = a + 3 by omega]; norm_word) + congr 1 + have := ucount_positive (a + 1) + have := ucount_power (a + 1) + have := pow4_next ((a + 1) + 1) + rw [show 1 + a + 0 = a + 1 by omega, + show 1 + (a + 1) + 0 = (a + 1) + 1 by omega, + show a + 1 + 2 = (a + 1) + 2 by omega, + show a + 2 = (a + 1) + 1 by omega, + show a + 3 = (a + 1) + 1 + 1 by omega] + dsimp [vcount, ucount] at * + omega + +def hterminal_count (a s : ℕ) : ℕ := + 4 ^ (a + 3) + 4 ^ (a + 4) * qcount s + 4 ^ (a + s + 4) + 3 * 4 ^ (a + s + 5) + +theorem H_terminal (a s : ℕ) : + SegRLs tm (hf ^ hterminal_count a s) [] + (hword a 0 ++ [O, O, O] ++ z4 ++ [I, I, I, I] ^ (1 + s) ++ a4 ++ z4 ^ 2) + ([O, O, I] ++ d4 ++ e4 ^ (a + s + 5) ++ a4 ++ z4) := by + have hh1 := (H_empty_batch a).concat F_AZ_small + have h1 := finite_suffix ([I, I, I, I] ^ (1 + s) ++ a4 ++ z4 ^ 2) hh1 + have hc2 : SegRLs tm [((C, []), (F, []))] [] + (b4 ++ a4 ++ [I, I, I, I] ^ (1 + s) ++ a4 ++ z4 ^ 2) + (z4 ^ 1 ++ (c4 ++ [O, O, I, I] ++ [I, I, I, I] ^ s ++ a4 ++ z4 ^ 2)) := + SegRLs.congr (segment_suffix ([I, I, I, I] ^ s ++ a4 ++ z4 ^ 2) C_BAW) rfl rfl + (by norm_word) (by norm_word) + have h2 := P_to_J (a + 1) 1 _ _ hc2 + have h3 := finite_suffix (a4 ++ z4 ^ 2) (J_consume_many s (a + 2)) + have h4 := J_terminal (a + s + 2) + have h12 := finite_trans h1 h2 + (by rw [show 1 + (a + 1) = a + 2 by omega]; norm_word) + have h123 := finite_trans h12 h3 + (by rw [show a + 1 + 1 = a + 2 by omega]; norm_word) + have h1234 := finite_trans h123 h4 + (by rw [show a + 2 + s = a + s + 2 by omega]; norm_word) + refine SegRLs.congr h1234 ?_ rfl (by norm_word) + (by rw [show a + s + 2 + 3 = a + s + 5 by omega]) + congr 1 + unfold hterminal_count + have := ucount_positive (a + 2) + have := ucount_power (a + 2) + rw [show a + 1 + 1 = a + 2 by omega, + show a + 2 + 2 = a + 4 by omega, + show a + s + 2 + 2 = a + s + 4 by omega, + show a + s + 2 + 3 = a + s + 5 by omega, + show a + 3 = (a + 2) + 1 by omega] + dsimp [vcount] + omega + +theorem L_repeat (n k : ℕ) : + SegRLs tm (hf ^ (4 ^ (k + 2) * qcount n)) [] + ([O, O, O] ++ z4 ^ (k + n + 1) ++ [O]) + ([O, O, O] ++ z4 ^ (k + 1) ++ [O] ++ [O, O, O, I] ^ n) := by + induction n generalizing k with + | zero => + simp only [qcount, Nat.mul_zero, Nat.add_zero, pow_zero_list, List.append_nil] + exact .nil _ + | succ n ih => + have h1 := ih (k + 1) + have h2 := finite_suffix ([O, O, O, I] ^ n) (U_prefix_L k) + have h12 := finite_trans h1 h2 (by rw [show k + 1 + 1 = k + 2 by omega]) + refine SegRLs.congr h12 ?_ rfl + (by rw [show k + 1 + n + 1 = k + (n + 1) + 1 by omega]) + (by norm_word) + congr 1 + rw [qcount_S, show k + 1 + 2 = (k + 2) + 1 by omega, pow4_next] + ring + +def first_seek_count (k : ℕ) : ℕ := 2 * 4 ^ (k + 9) + 4 ^ (k + 4) * qcount 6 + 16 * ucount k + +theorem first_seek_finite (k : ℕ) : + SegRLs tm (hf ^ first_seek_count k) [] + ([O, O, O] ++ z4 ^ (k + 10) ++ [O]) + ([O, O, O] ++ z4 ^ 2 ++ a4 ^ (k + 1) ++ z4 ++ a4 ^ 5 ++ [I, I, I, I, I]) := by + have h1 := U_prefix_M (k + 8) + have h2 := finite_suffix [I, I, I, I] (L_repeat 6 (k + 2)) + have h3 := finite_suffix (z4 ++ [O, O, O, I] ^ 6 ++ [I, I, I, I]) (U_near_end k) + have h12 := finite_trans h1 h2 (by rw [show k + 8 + 1 = k + 2 + 6 + 1 by omega]; norm_word) + have h123 := finite_trans h12 h3 (by rw [show k + 2 + 1 = k + 3 by omega]; norm_word) + refine SegRLs.congr h123 ?_ rfl + (by rw [show k + 8 + 2 = k + 10 by omega]) (by norm_word) + congr 1 + unfold first_seek_count + rw [near_end_count, show k + 8 + 1 = k + 9 by omega, show k + 2 + 2 = k + 4 by omega] + +theorem P_advance (k p : ℕ) : + SegRLs tm (hf ^ (2 * 4 ^ (k + 3))) [] + ([O, O, I] ++ a4 ^ (1 + k) ++ b4 ++ d4 ++ z4 ^ (2 + p)) + ([O, O, I] ++ a4 ^ (k + 3) ++ b4 ++ d4 ++ z4 ^ p) := by + have hc1 : SegRLs tm [((C, []), (F, []))] [] (b4 ++ d4 ++ z4 ^ (2 + p)) + (z4 ^ 2 ++ (c4 ++ z4 ^ (1 + p))) := + SegRLs.congr (segment_suffix (z4 ^ (1 + p)) C_BDZ) rfl rfl (by norm_word) (by norm_word) + have h1 := P_to_J k 2 _ _ hc1 + have hc2 : SegRLs tm [((A, []), (F, []))] [] (c4 ++ z4 ^ (1 + p)) + (z4 ^ 0 ++ [O] ++ ([O, O, I] ++ d4 ++ z4 ^ p)) := + SegRLs.congr (segment_suffix (z4 ^ p) A_CZ) rfl rfl (by norm_word) (by norm_word) + have h2 := J_to_P (k + 2) 0 _ _ hc2 + have h12 := finite_trans h1 h2 + refine SegRLs.congr h12 ?_ rfl (by norm_word) + (by rw [show 1 + (k + 2) + 0 = k + 3 by omega]; norm_word) + congr 1 + have := ucount_positive (k + 2) + have := ucount_power (k + 2) + rw [show 1 + (k + 2) + 0 = (k + 2) + 1 by omega, show k + 3 = (k + 2) + 1 by omega] + dsimp [vcount, ucount] at * + omega + +def post_count (j : ℕ) : ℕ := + 4 ^ (j + 3) + 4 ^ (j + 49) + 2731 * 4 ^ (j + 50) + 2 * 4 ^ (j + 51) + 2 * 4 ^ (j + 53) + +theorem post_count_components (j : ℕ) : + (((((4 ^ (j + 3) + (1 + ucount (j + 48))) + (1 + vcount (j + 48))) + + (1 + ucount (j + 49))) + 2 * 4 ^ (j + 51)) + 2 * 4 ^ (j + 53)) + (1 + vcount (j + 55)) + = post_count j := by + have hu5 : ucount 5 = 1365 := rfl + have hsum := ucount_add (j + 49) 5 + rw [show j + 49 + 5 + 1 = j + 55 by omega, show (j + 49) + 1 = j + 50 by omega, hu5] at hsum + have h48 := ucount_power (j + 48) + rw [show (j + 48) + 1 = j + 49 by omega] at h48 + have h49 := ucount_power (j + 49) + rw [show (j + 49) + 1 = j + 50 by omega] at h49 + have := ucount_positive (j + 48) + have := ucount_positive (j + 55) + unfold post_count vcount + omega + +theorem post_finite (j : ℕ) : + SegRLs tm (hf ^ post_count j) [] (post_input j) + ([O, O, I] ++ d4 ++ e4 ^ (j + 55) ++ b4 ++ [I, I, I]) := by + have h1 := finite_suffix (a4 ^ 44 ++ z4 ++ a4 ^ 5 ++ [I, I, I, I] ++ b4 ++ [I, I, I]) + (H_advance j 0) + have h2 := finite_suffix (a4 ^ 5 ++ [I, I, I, I] ++ b4 ++ [I, I, I]) + (H_collapse (j + 2) 44) + have hc3 : SegRLs tm [((C, []), (F, []))] [] + (b4 ++ a4 ^ 6 ++ [I, I, I, I] ++ b4 ++ [I, I, I]) + (z4 ^ 1 ++ (c4 ++ z4 ^ 5 ++ [O, O, I, I] ++ b4 ++ [I, I, I])) := + SegRLs.congr (segment_suffix (b4 ++ [I, I, I]) C_BA6W) rfl rfl (by flat_word) (by flat_word) + have h3 := P_to_J (j + 47) 1 _ _ hc3 + have hc4 : SegRLs tm [((A, []), (F, []))] [] + (c4 ++ z4 ^ 5 ++ [O, O, I, I] ++ b4 ++ [I, I, I]) + (z4 ^ 0 ++ [O] ++ ([O, O, I] ++ d4 ++ z4 ^ 4 ++ [O, O, I, I] ++ b4 ++ [I, I, I])) := + SegRLs.congr (segment_suffix (z4 ^ 4 ++ [O, O, I, I] ++ b4 ++ [I, I, I]) A_CZ) + rfl rfl (by flat_word) (by flat_word) + have h4 := J_to_P (j + 48) 0 _ _ hc4 + have h5 := finite_suffix ([O, O, I, I] ++ b4 ++ [I, I, I]) (P_advance (j + 48) 2) + have h6 := finite_suffix ([O, O, I, I] ++ b4 ++ [I, I, I]) (P_advance (j + 50) 0) + have hc7 : SegRLs tm [((C, []), (F, []))] [] + (b4 ++ d4 ++ [O, O, I, I] ++ b4 ++ [I, I, I]) + (z4 ^ 3 ++ (b4 ++ [I, I, I])) := + SegRLs.congr (segment_suffix (b4 ++ [I, I, I]) C_BD0011) rfl rfl (by flat_word) (by flat_word) + have h7 := P_to_J (j + 52) 3 _ _ hc7 + have h12 := finite_trans h1 h2 (by flat_word) + have h123 := finite_trans h12 h3 + (by rw [show j + 2 + 44 + 2 = 1 + (j + 47) by omega]; flat_word) + have h1234 := finite_trans h123 h4 + (by rw [show j + 47 + 1 = j + 48 by omega]) + have h12345 := finite_trans h1234 h5 + (by rw [show 1 + (j + 48) + 0 = 1 + (j + 48) by omega]; flat_word) + have h123456 := finite_trans h12345 h6 + (by rw [show j + 48 + 3 = 1 + (j + 50) by omega]) + have h1234567 := finite_trans h123456 h7 + (by rw [show j + 50 + 3 = 1 + (j + 52) by omega]; flat_word) + refine SegRLs.congr h1234567 ?_ rfl (by flat_word) + (by rw [show j + 52 + 3 = j + 55 by omega]; flat_word) + apply congrArg (hf ^ ·) + rw [show j + 2 + 44 + 2 = j + 48 by omega, + show j + 47 + 1 = j + 48 by omega, + show 1 + (j + 48) + 0 = j + 49 by omega, + show j + 48 + 3 = j + 51 by omega, + show j + 50 + 3 = j + 53 by omega, + show j + 52 + 3 = j + 55 by omega] + exact post_count_components j + +theorem prefix_M (k : ℕ) : + SegRLs tm (hf ^ (2 * 4 ^ (k + 1))) [] + ([O, O, O] ++ z4 ^ (k + 2) ++ [O]) ([O, O, O] ++ z4 ^ (k + 1) ++ [O, I, I, I, I]) := + U_prefix_M k + +theorem prefix_L (k : ℕ) : + SegRLs tm (hf ^ (4 ^ (k + 2))) [] + ([O, O, O] ++ z4 ^ (k + 2) ++ [O]) ([O, O, O] ++ z4 ^ (k + 1) ++ [O, O, O, O, I]) := + U_prefix_L k + +def second_top_count (k : ℕ) : ℕ := + 2 * 4 ^ (k + 56) + 3 * 4 ^ (k + 55) + 3 * 4 ^ (k + 53) + 3 * 4 ^ (k + 51) + 4 ^ (k + 50) + +theorem second_top (k : ℕ) : + SegRLs tm (hf ^ second_top_count k) [] + ([O, O, O] ++ z4 ^ (k + 57) ++ [O]) + ([O, O, O] ++ z4 ^ (k + 49) ++ [O] ++ second_tail) := by + have h1 := prefix_M (k + 55) + have h2 := finite_suffix [I, I, I, I] (prefix_M (k + 54)) + have h3 := finite_suffix ([I, I, I, I] ++ [I, I, I, I]) (prefix_L (k + 53)) + have h4 := finite_suffix ([O, O, O, I] ++ [I, I, I, I] ++ [I, I, I, I]) (prefix_M (k + 52)) + have h5 := finite_suffix ([I, I, I, I] ++ [O, O, O, I] ++ [I, I, I, I] ++ [I, I, I, I]) + (prefix_L (k + 51)) + have h6 := finite_suffix + ([O, O, O, I] ++ [I, I, I, I] ++ [O, O, O, I] ++ [I, I, I, I] ++ [I, I, I, I]) + (prefix_M (k + 50)) + have h7 := finite_suffix + ([I, I, I, I] ++ [O, O, O, I] ++ [I, I, I, I] ++ [O, O, O, I] ++ [I, I, I, I] ++ [I, I, I, I]) + (prefix_L (k + 49)) + have h8 := finite_suffix + ([O, O, O, I] ++ [I, I, I, I] ++ [O, O, O, I] ++ [I, I, I, I] ++ + [O, O, O, I] ++ [I, I, I, I] ++ [I, I, I, I]) + (prefix_L (k + 48)) + have h12 := finite_trans h1 h2 (by rw [show k + 55 + 1 = k + 54 + 2 by omega]; flat_word) + have h123 := finite_trans h12 h3 (by rw [show k + 54 + 1 = k + 53 + 2 by omega]; flat_word) + have h1234 := finite_trans h123 h4 (by rw [show k + 53 + 1 = k + 52 + 2 by omega]; flat_word) + have h12345 := finite_trans h1234 h5 (by rw [show k + 52 + 1 = k + 51 + 2 by omega]; flat_word) + have h123456 := finite_trans h12345 h6 (by rw [show k + 51 + 1 = k + 50 + 2 by omega]; flat_word) + have h1234567 := + finite_trans h123456 h7 (by rw [show k + 50 + 1 = k + 49 + 2 by omega]; flat_word) + have h12345678 := + finite_trans h1234567 h8 (by rw [show k + 49 + 1 = k + 48 + 2 by omega]; flat_word) + refine SegRLs.congr h12345678 ?_ rfl + (by rw [show k + 55 + 2 = k + 57 by omega]) + (by rw [show k + 48 + 1 = k + 49 by omega]; flat_word) + apply congrArg (hf ^ ·) + unfold second_top_count + rw [show k + 55 + 1 = k + 56 by omega, + show k + 54 + 1 = k + 55 by omega, + show k + 53 + 2 = k + 55 by omega, + show k + 52 + 1 = k + 53 by omega, + show k + 51 + 2 = k + 53 by omega, + show k + 50 + 1 = k + 51 by omega, + show k + 49 + 2 = k + 51 by omega, + show k + 48 + 2 = k + 50 by omega] + omega + +def second_seek_count (k : ℕ) : ℕ := 16 * ucount k + post_count (1 + k) + +theorem second_seek_count_sum (k : ℕ) : + second_top_count k + (4 ^ (k + 4) + 16 * ucount k) = second_seek_count k := by + unfold second_top_count second_seek_count post_count + rw [show 1 + k + 3 = k + 4 by omega, + show 1 + k + 49 = k + 50 by omega, + show 1 + k + 50 = (k + 50) + 1 by omega, + show 1 + k + 51 = (k + 50) + 1 + 1 by omega, + show 1 + k + 53 = (k + 50) + 1 + 1 + 1 + 1 by omega, + show k + 51 = (k + 50) + 1 by omega, + show k + 53 = (k + 50) + 1 + 1 + 1 by omega, + show k + 55 = (k + 50) + 1 + 1 + 1 + 1 + 1 by omega, + show k + 56 = (k + 50) + 1 + 1 + 1 + 1 + 1 + 1 by omega] + repeat rw [pow4_next] + omega + +theorem second_tail_join (q : ℕ) : + [I] ++ z4 ^ q ++ second_tail = a4 ++ z4 ^ q ++ second_result_tail := by + norm_word + +theorem second_seek_finite (k : ℕ) : + SegRLs tm (hf ^ second_seek_count k) [] + ([O, O, O] ++ z4 ^ (k + 57) ++ [O]) + ([O, O, O] ++ z4 ^ 2 ++ a4 ^ (1 + k) ++ z4 ++ a4 ++ z4 ^ 45 ++ second_result_tail) := by + have h1 := second_top k + have h2 := finite_suffix (z4 ^ 45 ++ second_tail) (seek_lower k) + have hw : [O, O, O] ++ z4 ^ (k + 49) ++ [O] ++ second_tail = + ([O, O, O] ++ z4 ^ (k + 4) ++ [O]) ++ (z4 ^ 45 ++ second_tail) := by + have hrec := z4_recut (k + 4) 45 + rw [show k + 49 = (k + 4) + 45 by omega, + show [O, O, O] ++ z4 ^ ((k + 4) + 45) ++ [O] ++ second_tail = + [O, O, O] ++ (z4 ^ ((k + 4) + 45) ++ [O]) ++ + second_tail from by simp only [List.append_assoc], + hrec] + simp only [List.append_assoc] + have h12 := finite_trans h1 h2 hw + refine SegRLs.congr h12 (by rw [second_seek_count_sum]) rfl rfl ?_ + rw [show k + 1 = 1 + k by omega, + show ([O, O, O] ++ z4 ^ 2 ++ a4 ^ (1 + k) ++ z4 ++ [I]) ++ (z4 ^ 45 ++ second_tail) = + [O, O, O] ++ z4 ^ 2 ++ a4 ^ (1 + k) ++ z4 ++ ([I] ++ z4 ^ 45 ++ second_tail) + from by simp only [List.append_assoc], + second_tail_join 45] + simp only [List.append_assoc] + +theorem first_seek_positive (k : ℕ) : 1 ≤ first_seek_count k := by + have := ucount_positive k + unfold first_seek_count + omega + +def second_index (k : ℕ) : ℕ := 15 + 16 * (ucount k - 1) + post_count (1 + k) + +theorem second_index_eq (k : ℕ) : second_seek_count k = 1 + second_index k := by + have := ucount_positive k + unfold second_seek_count second_index + omega + +def first_index_of (k : ℕ) : ℕ := first_seek_count k - 1 + +theorem first_index_of_eq (k : ℕ) : first_seek_count k = 1 + first_index_of k := by + have := first_seek_positive k + unfold first_index_of + omega + +def first_index : ℕ := first_index_of 43 + +private theorem entrance_count_eq_gen (k : ℕ) : + 1 + 16 * qcount (k + 1) + hterminal_count (k + 1) 3 = 1 + first_seek_count k := by + have hq3 : qcount 3 = 21 := rfl + have hq6 : qcount 6 = 1365 := rfl + have hqk : qcount (k + 1) = ucount k := rfl + unfold hterminal_count first_seek_count + rw [hq3, hq6, hqk, + show k + 1 + 3 = k + 4 by omega, + show k + 1 + 4 = (k + 4) + 1 by omega, + show k + 1 + 3 + 4 = (k + 4) + 4 by omega, + show k + 1 + 3 + 5 = (k + 4) + 5 by omega, + show k + 9 = (k + 4) + 5 by omega, + Nat.pow_add 4 (k + 4) 1, + Nat.pow_add 4 (k + 4) 4, + Nat.pow_add 4 (k + 4) 5] + ring + +private theorem entrance_count_eq : + 1 + 16 * qcount 44 + hterminal_count 44 3 = 1 + first_seek_count 43 := + entrance_count_eq_gen 43 + +theorem second_seek_step_eq (k : ℕ) : + 1 + 16 * ucount k + post_count (1 + k) = 1 + second_seek_count k := by + unfold second_seek_count + omega + +theorem second_reset_recut (m : ℕ) : + [O, I, I, I, I, O, O] ++ z4 ^ m ++ [O, O, I, I, O, I, I] = + [O, I, I, I, I] ++ [O, O, O] ++ z4 ^ m ++ [O] ++ [I, I, O, I, I] := by + norm_word + +theorem J_short_reset (n a : ℕ) (r : ListBlank Γ) : + (Ncfg n (([O, O, I] ++ d4 ++ e4 ^ a ++ b4 ++ [I, I, I]) +> r)) [tm]⊢⁺ + (Ncfg 0 (([O, O, O] ++ c4 ^ n ++ [O, I, I, I, I, O, O] ++ + z4 ^ (1 + a) ++ [O, O, I, I, O, I, I]) +> r)) := by + have hf_seg : SegRLs tm [((F, []), (F, []))] [] + ([O, O, I] ++ d4 ++ e4 ^ a ++ b4 ++ [I, I, I]) + ([O, O, O] ++ z4 ^ (1 + a) ++ [O, O, I, I, O, I, I]) := + SegRLs.congr ((J_E a).concat A_B111) rfl rfl (by norm_word) (by norm_word) + have h := finite_single_side r hf_seg + have h' : SideRL tm (F, []) (F, []) + (([O, O, I] ++ d4 ++ e4 ^ a ++ b4 ++ [I, I, I]) +> r) + ([O, O, O] +> ((z4 ^ (1 + a) ++ [O, O, I, I, O, I, I]) +> r)) := by + intro l + simpa only [append_assoc] using h l + have hn := N_E_reset n _ _ h' + refine stepPlus_congr hn rfl ?_ + simp only [Ncfg, append_assoc] + +theorem post_to_invariant (k : ℕ) (r : ListBlank Γ) : + (Ncfg (1 + 16 * ucount k) (post_input (1 + k) +> r)) [tm]⊢⁺ + invariant (second_index k) k 43 (entry_tail +> r) := by + have hf_side := (post_finite (1 + k)).sideRLs_concat (.nil r) + have hn := N_run (post_count (1 + k)) (1 + 16 * ucount k) _ _ hf_side + have hr := J_short_reset (1 + second_seek_count k) (1 + k + 55) r + have hs := (second_seek_finite k).sideRLs_concat (.nil ([I, I, O, I, I] +> r)) + have hl := reset_lift (second_seek_count k) _ _ hs + have hn' : (Ncfg (1 + 16 * ucount k) (post_input (1 + k) +> r)) [tm]⊢* + (Ncfg (1 + second_seek_count k) (([O, O, I] ++ d4 ++ e4 ^ (1 + k + 55) ++ b4 ++ [I, I, + I]) +> r)) := by + refine stepStar_congr hn rfl ?_ + rw [second_seek_step_eq k] + have hr' : (Ncfg (1 + second_seek_count k) + (([O, O, I] ++ d4 ++ e4 ^ (1 + k + 55) ++ b4 ++ [I, I, I]) +> r)) [tm]⊢⁺ + (Ncfg 0 (([O, O, O] ++ c4 ^ (1 + second_seek_count k) ++ [O, I, I, I, I]) +> + (([O, O, O] ++ z4 ^ (k + 57) ++ [O]) +> ([I, I, O, I, I] +> r)))) := by + refine stepPlus_congr hr rfl ?_ + rw [show 1 + (1 + k + 55) = k + 57 by omega] + apply congrArg (Ncfg 0) + simp only [← append_assoc] + apply congrArg (· +> r) + have hrec := second_reset_recut (k + 57) + have hlhs : [O, O, O] ++ c4 ^ (1 + second_seek_count k) ++ [O, I, I, I, I, O, O] ++ + z4 ^ (k + 57) ++ [O, O, I, I, O, I, I] = + [O, O, O] ++ c4 ^ (1 + second_seek_count k) ++ + ([O, I, I, I, I, O, O] ++ z4 ^ (k + 57) ++ [O, O, I, I, O, I, I]) := by + simp only [List.append_assoc] + rw [hlhs, hrec] + simp only [List.append_assoc] + have hl' : (Ncfg 0 (([O, O, O] ++ c4 ^ (1 + second_seek_count k) ++ [O, I, I, I, I]) +> + (([O, O, O] ++ z4 ^ (k + 57) ++ [O]) +> ([I, I, O, I, I] +> r)))) [tm]⊢⁺ + invariant (second_index k) k 43 (entry_tail +> r) := by + refine stepPlus_congr hl rfl ?_ + rw [second_index_eq k, qcount_succ_ucount] + unfold invariant + apply congrArg (Ncfg _) + simp only [← append_assoc] + apply congrArg (· +> r) + simp only [second_result_tail, entry_tail, d4, List.append_assoc, List.cons_append, + List.nil_append] + exact stepStar_stepPlus_trans hn' (stepPlus_trans hr' hl') + +theorem first_reset_to_post_aux (n idx : ℕ) (h_eq : n = 1 + idx) + (h_seek : SegRLs tm (hf ^ n) [] + ([O, O, O] ++ z4 ^ 53 ++ [O]) + ([O, O, O] ++ z4 ^ 2 ++ a4 ^ 44 ++ z4 ++ a4 ^ 5 ++ [I, I, I, I, I])) + (r : ListBlank Γ) : + (Ncfg 0 (([O, O, O] ++ c4 ^ (1 + n) ++ [O, I, I, I, I, O, O] ++ + z4 ^ 54 ++ [I, I, I, I]) +> r)) [tm]⊢⁺ + (Ncfg (1 + 16 * ucount idx) (post_input (1 + idx) +> r)) := by + have hs := h_seek.sideRLs_concat (.nil ([O, O, I, I, I, I] +> r)) + have hl := reset_lift n _ _ hs + refine stepPlus_congr hl ?_ ?_ + · apply congrArg (Ncfg 0) + simp only [← append_assoc] + apply congrArg (· +> r) + have hrec := reset_suffix_recut 53 0 + rw [pow_zero_list, List.append_nil, List.append_nil] at hrec + have hrhs : [O, O, O] ++ c4 ^ (1 + n) ++ [O, I, I, I, I, O, O] ++ + z4 ^ 54 ++ [I, I, I, I] = + [O, O, O] ++ c4 ^ (1 + n) ++ + ([O, I, I, I, I, O, O] ++ z4 ^ 54 ++ [I, I, I, I]) := by + simp only [List.append_assoc] + rw [hrhs, hrec] + simp only [List.append_assoc, List.cons_append, List.nil_append] + · rw [h_eq, qcount_succ_ucount] + apply congrArg (Ncfg _) + simp only [← append_assoc] + apply congrArg (· +> r) + simp only [post_input, b4, List.append_assoc, List.cons_append, List.nil_append] + +theorem first_reset_to_post (r : ListBlank Γ) : + (Ncfg 0 (([O, O, O] ++ c4 ^ (1 + first_seek_count 43) ++ [O, I, I, I, I, O, O] ++ + z4 ^ 54 ++ [I, I, I, I]) +> r)) [tm]⊢⁺ + (Ncfg (1 + 16 * ucount first_index) (post_input (1 + first_index) +> r)) := + first_reset_to_post_aux (first_seek_count 43) first_index (first_index_of_eq 43) + (first_seek_finite 43) r + +-- Symbolic Entrance (`init [] -> first_reset_to_post`) +private abbrev w0 : List Γ := [O, O, O, O, I, I, I, I, O, O, I, I, I, I, I, I, I, I] +private abbrev w45 : List Γ := [O, O, I, I, I, I, O, O, O, I, O, O, O, I, O, I, I, I] + +private theorem w0_to_w45_side : + SideRLs tm (hf ^ 45) (w0 +> default) (w45 +> default) := + BoundedConfig.sideRLs_c_spec tm (T := 1000) (by decide) + +private theorem reset45_side : + SideRLs tm [((F, []), (F, []))] + (w45 +> default) + (([O, O, O] ++ [O, O] ++ z4 ^ 3 ++ [I, I, I, I] ^ 2) +> default) := + BoundedConfig.sideRLs_c_spec tm (T := 1000) (by decide) + +private theorem seed_tail_4 : + SegRLs tm (hf ^ 4) [] (z4 ^ 4 ++ [I, I, I, I] ^ 2 ++ [O, O, O]) seed_tail := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +private theorem seed_tail_counter : SegRLs tm (hf ^ 40) [] seed_tail seed_tail40 := + BoundedConfig.segRLs_c_spec tm (T := 100) (by decide) + +private theorem seed_tail_44 : + SegRLs tm (hf ^ 44) [] (z4 ^ 4 ++ [I, I, I, I] ^ 2 ++ [O, O, O]) seed_tail40 := + finite_trans seed_tail_4 seed_tail_counter rfl + +private theorem init_to_step33935 : + (init []) [tm]⊢* + (Ncfg 0 (([O, O, O] ++ c4 ^ (1 + 44) ++ [O, I, I, I, I] ++ + (z4 ^ 4 ++ [I, I, I, I] ^ 2 ++ [O, O, O]) ++ z4 ^ 2) +> default)) := by + have h1 : (init []) [tm]⊢* (Ncfg 0 (w0 +> default)) := by + have h := runSteps_spec tm 264 + ⟨List.replicate 13 O, List.replicate 14 O, A, .right⟩ + ⟨z4 ++ [O, I, I, I, I] ++ w0, [], F, .left⟩ (by decide) default default + have hl : List.replicate 13 O +> (default : ListBlank Γ) = default := + BoundedConfig.all0_spec (by decide) + have hr : List.replicate 14 O +> (default : ListBlank Γ) = default := + BoundedConfig.all0_spec (by decide) + refine stepStar_congr h ?_ ?_ + · simp only [BoundedConfig.toCfg, hl, hr]; rfl + · simp only [BoundedConfig.toCfg, Ncfg, pow_zero_list, List.append_nil, append_nil, + append_assoc] + have h2 : (Ncfg 0 (w0 +> default)) [tm]⊢* (Ncfg 45 (w45 +> default)) := + N_run 45 0 _ _ w0_to_w45_side + have h3 : (Ncfg 45 (w45 +> default)) [tm]⊢⁺ + (Ncfg 0 (([O, O, O] ++ c4 ^ (1 + 44) ++ [O, I, I, I, I] ++ + (z4 ^ 4 ++ [I, I, I, I] ^ 2 ++ [O, O, O]) ++ z4 ^ 2) +> default)) := by + have hs' : SideRL tm (F, []) (F, []) + (w45 +> default) + ([O, O, O] +> (([O, O] ++ z4 ^ 3 ++ [I, I, I, I] ^ 2) +> default)) := by + cases reset45_side with + | cons hcall hnil => + cases hnil + intro l + simpa only [append_assoc] using hcall l + have hn := N_E_reset 45 _ _ hs' + refine stepPlus_congr hn rfl ?_ + have hd2 : ([O, O, O] ++ z4 ^ 2) +> (default : ListBlank Γ) = default := + BoundedConfig.all0_spec (by decide) + have hlhs : Ncfg 0 (([O, O, O] ++ c4 ^ 45 ++ [O, I, I, I, I, O, O]) +> + (([O, O] ++ z4 ^ 3 ++ [I, I, I, I] ^ 2) +> (default : ListBlank Γ))) = + Ncfg 0 (([O, O, O] ++ c4 ^ 45 ++ [O, I, I, I, I, O, O]) +> + (([O, O] ++ z4 ^ 3 ++ [I, I, I, I] ^ 2) +> (([O, O, O] ++ z4 ^ 2) +> default))) := by + rw [hd2] + exact hlhs + exact stepStar_trans h1 (stepStar_trans h2 (stepPlus_to_stepStar h3)) + +private theorem step33935_to_first_reset : + (Ncfg 0 (([O, O, O] ++ c4 ^ (1 + 44) ++ [O, I, I, I, I] ++ + (z4 ^ 4 ++ [I, I, I, I] ^ 2 ++ [O, O, O]) ++ z4 ^ 2) +> default)) [tm]⊢⁺ + (Ncfg 0 (([O, O, O] ++ c4 ^ (1 + first_seek_count 43) ++ [O, I, I, I, I, O, O] ++ + z4 ^ 54 ++ [I, I, I, I]) +> default)) := by + have hs1 := seed_tail_44.sideRLs_concat (.nil (z4 ^ 2 +> default)) + have hl := reset_lift 44 _ _ hs1 + have hl' : (Ncfg 0 (([O, O, O] ++ c4 ^ (1 + 44) ++ [O, I, I, I, I] ++ + (z4 ^ 4 ++ [I, I, I, I] ^ 2 ++ [O, O, O]) ++ z4 ^ 2) +> default)) [tm]⊢⁺ + (Ncfg (1 + 16 * qcount 44) + ((hword 44 0 ++ [O, O, O] ++ z4 ++ [I, I, I, I] ^ (1 + 3) ++ a4 ++ z4 ^ 2) +> default)) := + by + refine stepPlus_congr hl ?_ ?_ + · simp only [append_assoc] + · rfl + have hs2 := (H_terminal 44 3).sideRLs_concat (.nil default) + have hrun := N_run (hterminal_count 44 3) (1 + 16 * qcount 44) _ _ hs2 + have hrun' : (Ncfg (1 + 16 * qcount 44) + ((hword 44 0 ++ [O, O, O] ++ z4 ++ [I, I, I, I] ^ (1 + 3) ++ a4 ++ z4 ^ 2) +> default)) [tm]⊢* + (Ncfg (1 + first_seek_count 43) (([O, O, + I] ++ d4 ++ e4 ^ 52 ++ a4 ++ z4 ^ (1 + 0)) +> default)) := by + refine stepStar_congr hrun rfl ?_ + rw [entrance_count_eq] + congr 1 + have hreset := J_reset (1 + first_seek_count 43) 52 0 default + have hreset' : (Ncfg (1 + first_seek_count 43) + (([O, O, I] ++ d4 ++ e4 ^ 52 ++ a4 ++ z4 ^ (1 + 0)) +> default)) [tm]⊢⁺ + (Ncfg 0 (([O, O, O] ++ c4 ^ (1 + first_seek_count 43) ++ [O, I, I, I, I, O, O] ++ + z4 ^ 54 ++ [I, I, I, I]) +> default)) := by + refine stepPlus_congr hreset rfl ?_ + apply congrArg (Ncfg _) + simp only [pow_zero_list, List.append_nil, List.append_assoc] + exact stepPlus_trans (stepPlus_stepStar_trans hl' hrun') hreset' + +end + +public section + +theorem is_not_halt : IsNotHalt target := by + have h1 := init_to_step33935 + have h2 := stepPlus_to_stepStar step33935_to_first_reset + have h3 := stepPlus_to_stepStar (first_reset_to_post default) + have h4 := stepPlus_to_stepStar (post_to_invariant first_index default) + have hreach := stepStar_trans h1 (stepStar_trans h2 (stepStar_trans h3 h4)) + refine IsNotHalt.of_reachesPlus_invariant hreach + (P := fun c => ∃ x y z t, c = invariant x y z t) ⟨_, _, _, _, rfl⟩ ?_ + rintro _ ⟨x, y, z, t, rfl⟩ + exact ⟨_, invariant_forward x y z t, next_a x y, x, y, _, rfl⟩ + +end + +end BusyBeaver.M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE diff --git a/BusyBeaver/BB6/NonHalt/M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB.lean b/BusyBeaver/BB6/NonHalt/M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB.lean new file mode 100644 index 00000000..dd1a586f --- /dev/null +++ b/BusyBeaver/BB6/NonHalt/M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB.lean @@ -0,0 +1,1843 @@ +/- +Copyright (c) 2026 Google LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +-/ +module + +import BusyBeaver.Basic +public import BusyBeaver.Bridge + +open Mathlib Relation Nat Turing BusyBeaver SixState + +namespace BusyBeaver.M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB + +@[expose] public section + +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB" + +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB + +end + +abbrev target_tm : Machine (Fin 2) (Fin 6) := target + +local notation "zB" => ListBlank (Fin 2) +local notation "zF" => List (Fin 2) + +attribute [local simp] pow_zero_list pow_succ_list listblank_append_nil listblank_append_cons + +@[simp] theorem tape_mk1_nil : Tape.mk₁ ([] : List (Fin 2)) = ⟨0, default, default⟩ := rfl + +theorem str_app_assoc (l₁ l₂ : List (Fin 2)) (s : zB) : + l₁ +> (l₂ +> s) = (l₁ ++ l₂) +> s := + ListBlank.append_append s l₂ l₁ + +macro "finish" : tactic => `(tactic| exists 0 <;> fail) +macro "step" : tactic => + `(tactic| (try refine ReachesPlus.to_star ?_) <;> + refine step_stepStar_stepPlus (by (try simp only [listblank_append_cons, listblank_append_nil, + Turing.ListBlank.head_cons, ListBlank.head_default_fin]); rfl) ?_ <;> + simp only [listblank_append_cons, listblank_append_nil, Turing.Tape.move, + Turing.ListBlank.head_cons, Turing.ListBlank.tail_cons, Tape.write, + ListBlank.cons_zero_default, ListBlank.head_default_fin, ListBlank.tail_default]) +macro "execute5" : tactic => + `(tactic| (any_goals (first | finish | step)) <;> (any_goals (first | finish | step)) <;> + (any_goals (first | finish | step)) <;> (any_goals (first | finish | step)) <;> + (any_goals (first | finish | step))) +macro "execute" : tactic => + `(tactic| execute5 <;> execute5 <;> execute5 <;> execute5 <;> execute5 <;> execute5 <;> + execute5 <;> execute5) + +-- Shift rules (`⊢*`) + +theorem SW (k : Nat) (l r : zB) : + ((([1, 0] : zF) ^ k +> l) <{{C}} r) [target_tm]⊢* (l <{{C}} (([0, 1] : zF) ^ k +> r)) := by + induction k generalizing r with + | zero => exact ⟨0, rfl⟩ + | succ k ih => + have h1 : ((([1, 0] : zF) +> (([1, 0] : zF) ^ k +> l)) <{{C}} r) [target_tm]⊢⁺ + ((([1, 0] : zF) ^ k +> l) <{{C}} (([0, 1] : zF) +> r)) := by + execute + rw [pow_succ_list, ← str_app_assoc] + have h2 := ih (([0, 1] : zF) +> r) + rw [str_app_assoc, list_pow_append_one] at h2 + exact ReachesPlus.to_star (ReachesPlus.trans_star h1 h2) + +theorem TT (j : Nat) (l r : zB) : + ((([1, 1, 1] : zF) ^ j +> l) <{{C}} r) [target_tm]⊢* (l <{{C}} (([0, 1, 1] : zF) ^ j +> r)) := + by + induction j generalizing r with + | zero => exact ⟨0, rfl⟩ + | succ j ih => + have h1 : ((([1, 1, 1] : zF) +> (([1, 1, 1] : zF) ^ j +> l)) <{{C}} r) [target_tm]⊢⁺ + ((([1, 1, 1] : zF) ^ j +> l) <{{C}} (([0, 1, 1] : zF) +> r)) := by + execute + rw [pow_succ_list, ← str_app_assoc] + have h2 := ih (([0, 1, 1] : zF) +> r) + rw [str_app_assoc, list_pow_append_one] at h2 + exact ReachesPlus.to_star (ReachesPlus.trans_star h1 h2) + +theorem PS (b : Nat) (l r : zB) : + ((([1, 1, 0] : zF) +> l) {{B}}> (([1, 0] : zF) ^ b +> r)) [target_tm]⊢* + ((([1, 1] : zF) +> (([0, 1] : zF) ^ b +> (([0] : zF) +> l))) {{B}}> r) := by + induction b generalizing l with + | zero => exact ⟨0, rfl⟩ + | succ b ih => + have h1 : ((([1, 1, 0] : zF) +> l) {{B}}> (([1, 0] : zF) +> (([1, + 0] : zF) ^ b +> r))) [target_tm]⊢⁺ + ((([1, 1, 0] : zF) +> (([1, 0] : zF) +> l)) {{B}}> (([1, 0] : zF) ^ b +> r)) := by + execute + rw [pow_succ_list, ← str_app_assoc] + have h2 := ih (([1, 0] : zF) +> l) + have heq : (([1, 1] : zF) +> (([0, 1] : zF) ^ b +> (([0] : zF) +> (([1, 0] : zF) +> l)))) = + (([1, 1] : zF) +> (([0, 1] : zF) ^ (b + 1) +> (([0] : zF) +> l))) := by + have hpow : (([0, 1] : zF) ^ b +> (([0] : zF) +> (([1, 0] : zF) +> l))) = + (([0, 1] : zF) ^ (b + 1) +> (([0] : zF) +> l)) := by + change (([0, 1] : zF) ^ b +> (([0, 1] : zF) +> (([0] : zF) +> l))) = _ + rw [str_app_assoc, list_pow_append_one] + rw [hpow] + rw [heq] at h2 + exact ReachesPlus.to_star (ReachesPlus.trans_star h1 h2) + +theorem BR3 (j : Nat) (l r : zB) : + (l {{B}}> (([1, 1, 1] : zF) ^ j +> r)) [target_tm]⊢* ((([1, 1, 1] : zF) ^ j +> l) {{B}}> r) := + by + induction j generalizing l with + | zero => exact ⟨0, rfl⟩ + | succ j ih => + have h1 : (l {{B}}> (([1, 1, 1] : zF) +> (([1, 1, 1] : zF) ^ j +> r))) [target_tm]⊢⁺ + ((([1, 1, 1] : zF) +> l) {{B}}> (([1, 1, 1] : zF) ^ j +> r)) := by + execute + rw [pow_succ_list, ← str_app_assoc] + have h2 := ih (([1, 1, 1] : zF) +> l) + rw [str_app_assoc, list_pow_append_one] at h2 + exact ReachesPlus.to_star (ReachesPlus.trans_star h1 h2) + +theorem E_push (k : Nat) (l r : zB) : + ((([0, 0] : zF) +> l) {{E}}> (([1, 1, 0] : zF) ^ k +> r)) [target_tm]⊢* + ((([0, 0] : zF) +> (([1, 0, 0] : zF) ^ k +> l)) {{E}}> r) := by + induction k generalizing l with + | zero => exact ⟨0, rfl⟩ + | succ k ih => + have h1 : ((([0, 0] : zF) +> l) {{E}}> (([1, 1, 0] : zF) +> (([1, 1, + 0] : zF) ^ k +> r))) [target_tm]⊢⁺ + ((([0, 0] : zF) +> (([1, 0, 0] : zF) +> l)) {{E}}> (([1, 1, 0] : zF) ^ k +> r)) := by + execute + rw [pow_succ_list, ← str_app_assoc] + have h2 := ih (([1, 0, 0] : zF) +> l) + have heq : (([0, 0] : zF) +> (([1, 0, 0] : zF) ^ k +> (([1, 0, 0] : zF) +> l))) = + (([0, 0] : zF) +> (([1, 0, 0] : zF) ^ (k + 1) +> l)) := by + rw [str_app_assoc (([1, 0, 0] : zF) ^ k), list_pow_append_one] + rw [heq] at h2 + exact ReachesPlus.to_star (ReachesPlus.trans_star h1 h2) + +theorem lpow_rot2 (n : Nat) (a b : Fin 2) (s : zB) : + ([a, b] : zF) ^ n +> ([a] +> s) = [a] +> (([b, a] : zF) ^ n +> s) := by + induction n with + | zero => rfl + | succ n ih => + rw [pow_succ_list, ← str_app_assoc, ih] + rfl + +theorem PS' (b : Nat) (l r : zB) : + ((([1, 1, 0] : zF) +> l) {{B}}> (([1, 0] : zF) ^ b +> r)) [target_tm]⊢* + ((([1, 1, 0] : zF) +> (([1, 0] : zF) ^ b +> l)) {{B}}> r) := by + have h := PS b l r + rw [lpow_rot2 b 0 1 l] at h + exact h + +theorem ones_comm (b : Nat) : ([1, 1] : zF) ++ ([1, 1, 1] : zF) ^ b = ([1, 1, 1] : zF) ^ b ++ [1, + 1] := + by + induction b with + | zero => rfl + | succ b ih => + rw [pow_succ_list] + change ([1, 1, 1] : zF) ++ (([1, 1] : zF) ++ ([1, 1, 1] : zF) ^ b) = _ + rw [ih, List.append_assoc] + +theorem one_comm (b : Nat) : ([1] : zF) ++ ([1, 1, 1] : zF) ^ b = ([1, 1, 1] : zF) ^ b ++ [1] := by + induction b with + | zero => rfl + | succ b ih => + rw [pow_succ_list] + change ([1, 1, 1] : zF) ++ (([1] : zF) ++ ([1, 1, 1] : zF) ^ b) = _ + rw [ih, List.append_assoc] + +theorem sh110 (b : Nat) : ([1, 1] : zF) ++ ([0, 1, 1] : zF) ^ b = ([1, 1, 0] : zF) ^ b ++ [1, 1] := + by + induction b with + | zero => rfl + | succ b ih => + rw [pow_succ_list, pow_succ_list] + change ([1, 1, 0] : zF) ++ (([1, 1] : zF) ++ ([0, 1, 1] : zF) ^ b) = _ + rw [ih, List.append_assoc] + +theorem S_ones2 (b : Nat) (s : zB) : + ([1, 1] : zF) +> (([1, 1, 1] : zF) ^ b +> s) = ([1, 1, 1] : zF) ^ b +> (([1, 1] : zF) +> s) := + by + rw [str_app_assoc, ones_comm, ← str_app_assoc] + +theorem S_ones1 (b : Nat) (s : zB) : + ([1] : zF) +> (([1, 1, 1] : zF) ^ b +> s) = ([1, 1, 1] : zF) ^ b +> (([1] : zF) +> s) := by + rw [str_app_assoc, one_comm, ← str_app_assoc] + +theorem S_sh110 (b : Nat) (s : zB) : + ([1, 1] : zF) +> (([0, 1, 1] : zF) ^ b +> s) = ([1, 1, 0] : zF) ^ b +> (([1, 1] : zF) +> s) := + by + rw [str_app_assoc, sh110, ← str_app_assoc] + +theorem C_left_right (l r : zB) : + ((([0] : zF) +> l) <{{C}} (([0] : zF) +> r)) = (l {{C}}> (([0, 0] : zF) +> r)) := by + simp only [listblank_append_cons, listblank_append_nil, Turing.ListBlank.head_cons, + Turing.ListBlank.tail_cons] + +theorem RND2 (q j : Nat) (l r : zB) : + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (q + 3) +> (([1, 1, 1] : zF) ^ j +> (([1, 1, + 0] : zF) +> r))))) [target_tm]⊢⁺ + ((([1, 0, 1, 0] : zF) +> l) {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (q + 1) +> (([1, 1, + 0] : zF) ^ j +> (([1, 1, 1] : zF) +> r))))) := by + rw [Nat.add_comm q 3, list_pow_add, ← str_app_assoc] + set R0 : zB := ([1, 1, 1] : zF) ^ j +> (([1, 1, 0] : zF) +> r) + set L0 : zB := ([0, 1, 0, 1, 0] : zF) +> l + have h1 : (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ 3 +> (([1, 0] : zF) ^ q +> R0)))) + [target_tm]⊢⁺ + ((([1, 1, 0] : zF) +> L0) {{B}}> (([1, 0] : zF) ^ q +> R0)) := by + change (l {{C}}> (([0, 0] : zF) +> (([1, 0, 1, 0, 1, 0] : zF) +> (([1, + 0] : zF) ^ q +> R0)))) [target_tm]⊢⁺ _ + execute + have h2 := PS' q L0 R0 + set L1 : zB := ([1, 0] : zF) ^ q +> L0 + have h3 := BR3 j (([1, 1, 0] : zF) +> L1) (([1, 1, 0] : zF) +> r) + have h4 : ((([1, 1, 1] : zF) ^ j +> (([1, 1, 0] : zF) +> L1)) {{B}}> (([1, 1, + 0] : zF) +> r)) [target_tm]⊢⁺ + ((([1, 1] : zF) +> (([1, 1, 1] : zF) ^ j +> (([1, 1, + 0] : zF) +> L1))) <{{C}} (([1] : zF) +> r)) := by + execute + rw [S_ones2] at h4 + have h5 := TT j (([1, 1] : zF) +> (([1, 1, 0] : zF) +> L1)) (([1] : zF) +> r) + set R2 : zB := ([0, 1, 1] : zF) ^ j +> (([1] : zF) +> r) + have h6 : ((([1, 1] : zF) +> (([1, 1, 0] : zF) +> L1)) <{{C}} R2) [target_tm]⊢⁺ + (L1 <{{C}} (([0, 1, 0, 1, 1] : zF) +> R2)) := by + execute + have h7 := SW q L0 (([0, 1, 0, 1, 1] : zF) +> R2) + have h8 : (L0 <{{C}} (([0, 1] : zF) ^ q +> (([0, 1, 0, 1, 1] : zF) +> R2))) = + ((([1, 0, 1, 0] : zF) +> l) {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (q + 1) +> (([1, + 1, + 0] : zF) ^ j +> (([1, 1, 1] : zF) +> r))))) := by + have hrot : (([0, 1] : zF) ^ q +> (([0, 1, 0, 1, 1] : zF) +> R2)) = + ([0] : zF) +> (([1, 0] : zF) ^ (q + 1) +> (([1, 1, 0] : zF) ^ j +> (([1, 1, + 1] : zF) +> r))) := by + change (([0, 1] : zF) ^ q +> (([0] : zF) +> (([1, 0] : zF) +> (([1, 1] : zF) +> (([0, 1, + 1] : zF) ^ j +> (([1] : zF) +> r)))))) = _ + rw [lpow_rot2 q 0 1, S_sh110 j (([1] : zF) +> r), str_app_assoc (([1, 0] : zF) ^ q) ([1, + 0] : zF), list_pow_append_one] + rfl + rw [hrot] + exact C_left_right (([1, 0, 1, 0] : zF) +> l) _ + rw [h8] at h7 + exact ReachesPlus.trans_star (ReachesPlus.trans_star (ReachesPlus.trans_star + (ReachesPlus.trans_star (ReachesPlus.trans_star h1 h2) h3) (ReachesPlus.to_star h4)) h5) + (ReachesPlus.trans_star h6 h7 |> ReachesPlus.to_star) + +theorem RND1 (q j : Nat) (l r : zB) : + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (q + 3) +> (([1, 1, 1] : zF) ^ j +> (([1, 1, 1, 1, + 0] : zF) +> r))))) [target_tm]⊢⁺ + ((([1, 0, 1, 0] : zF) +> l) {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (q + 1) +> (([1, 1, 1, + 1] : zF) +> (([0, 1, 1] : zF) ^ j +> (([1] : zF) +> r)))))) := by + rw [Nat.add_comm q 3, list_pow_add, ← str_app_assoc] + set R0 : zB := ([1, 1, 1] : zF) ^ j +> (([1, 1, 1, 1, 0] : zF) +> r) + set L0 : zB := ([0, 1, 0, 1, 0] : zF) +> l + have h1 : (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ 3 +> (([1, 0] : zF) ^ q +> R0)))) + [target_tm]⊢⁺ + ((([1, 1, 0] : zF) +> L0) {{B}}> (([1, 0] : zF) ^ q +> R0)) := by + change (l {{C}}> (([0, 0] : zF) +> (([1, 0, 1, 0, 1, 0] : zF) +> (([1, + 0] : zF) ^ q +> R0)))) [target_tm]⊢⁺ _ + execute + have h2 := PS' q L0 R0 + set L1 : zB := ([1, 0] : zF) ^ q +> L0 + have h3 := BR3 j (([1, 1, 0] : zF) +> L1) (([1, 1, 1, 1, 0] : zF) +> r) + have h4 : ((([1, 1, 1] : zF) ^ j +> (([1, 1, 0] : zF) +> L1)) {{B}}> (([1, 1, 1, 1, + 0] : zF) +> r)) [target_tm]⊢⁺ + ((([1, 1] : zF) +> (([1, 1] : zF) +> (([1, 1, 1] : zF) ^ j +> (([1, 1, + 0] : zF) +> L1)))) <{{C}} (([1] : zF) +> r)) := by + execute + rw [S_ones2, S_ones2] at h4 + have h5 := TT j (([1, 1] : zF) +> (([1, 1] : zF) +> (([1, 1, 0] : zF) +> L1))) (([1] : zF) +> r) + set R2 : zB := ([0, 1, 1] : zF) ^ j +> (([1] : zF) +> r) + have h6 : ((([1, 1] : zF) +> (([1, 1] : zF) +> (([1, 1, 0] : zF) +> L1))) <{{C}} R2) [target_tm]⊢⁺ + (L1 <{{C}} (([0, 1, 0, 1, 1, 1, 1] : zF) +> R2)) := by + execute + have h7 := SW q L0 (([0, 1, 0, 1, 1, 1, 1] : zF) +> R2) + have h8 : (L0 <{{C}} (([0, 1] : zF) ^ q +> (([0, 1, 0, 1, 1, 1, 1] : zF) +> R2))) = + ((([1, 0, 1, 0] : zF) +> l) {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (q + 1) +> (([1, + 1, + 1, 1] : zF) +> (([0, 1, 1] : zF) ^ j +> (([1] : zF) +> r)))))) := by + have hrot : (([0, 1] : zF) ^ q +> (([0, 1, 0, 1, 1, 1, 1] : zF) +> R2)) = + ([0] : zF) +> (([1, 0] : zF) ^ (q + 1) +> (([1, 1, 1, 1] : zF) +> R2)) := by + change (([0, 1] : zF) ^ q +> (([0] : zF) +> (([1, 0] : zF) +> (([1, 1, 1, 1] : zF) +> R2)))) + = _ + rw [lpow_rot2 q 0 1, str_app_assoc (([1, 0] : zF) ^ q) ([1, 0] : zF), list_pow_append_one] + rw [hrot] + exact C_left_right (([1, 0, 1, 0] : zF) +> l) _ + rw [h8] at h7 + exact ReachesPlus.trans_star (ReachesPlus.trans_star (ReachesPlus.trans_star + (ReachesPlus.trans_star (ReachesPlus.trans_star h1 h2) h3) (ReachesPlus.to_star h4)) h5) + (ReachesPlus.trans_star h6 h7 |> ReachesPlus.to_star) + +theorem RND0 (q j : Nat) (l r : zB) : + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (q + 3) +> (([1, 1, 1] : zF) ^ j +> (([1, 1, 1, + 0] : zF) +> r))))) [target_tm]⊢⁺ + ((([1, 0, 1, 0] : zF) +> l) {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ q +> (([1, 1, 1, 1, + 1] : zF) +> (([0, 1, 1] : zF) ^ j +> (([1] : zF) +> r)))))) := by + rw [Nat.add_comm q 3, list_pow_add, ← str_app_assoc] + set R0 : zB := ([1, 1, 1] : zF) ^ j +> (([1, 1, 1, 0] : zF) +> r) + set L0 : zB := ([0, 1, 0, 1, 0] : zF) +> l + have h1 : (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ 3 +> (([1, 0] : zF) ^ q +> R0)))) + [target_tm]⊢⁺ + ((([1, 1, 0] : zF) +> L0) {{B}}> (([1, 0] : zF) ^ q +> R0)) := by + change (l {{C}}> (([0, 0] : zF) +> (([1, 0, 1, 0, 1, 0] : zF) +> (([1, + 0] : zF) ^ q +> R0)))) [target_tm]⊢⁺ _ + execute + have h2 := PS' q L0 R0 + set L1 : zB := ([1, 0] : zF) ^ q +> L0 + have h3 := BR3 j (([1, 1, 0] : zF) +> L1) (([1, 1, 1, 0] : zF) +> r) + have h4 : ((([1, 1, 1] : zF) ^ j +> (([1, 1, 0] : zF) +> L1)) {{B}}> (([1, 1, 1, + 0] : zF) +> r)) [target_tm]⊢⁺ + ((([1] : zF) +> (([1, 1] : zF) +> (([1, 1, 1] : zF) ^ j +> (([1, 1, + 0] : zF) +> L1)))) <{{C}} (([1] : zF) +> r)) := by + execute + rw [S_ones2, S_ones1] at h4 + have h5 := TT j (([1] : zF) +> (([1, 1] : zF) +> (([1, 1, 0] : zF) +> L1))) (([1] : zF) +> r) + set R2 : zB := ([0, 1, 1] : zF) ^ j +> (([1] : zF) +> r) + have h6 : ((([1] : zF) +> (([1, 1] : zF) +> (([1, 1, 0] : zF) +> L1))) <{{C}} R2) [target_tm]⊢⁺ + (L1 <{{C}} (([0, 1, 1, 1, 1, 1] : zF) +> R2)) := by + execute + have h7 := SW q L0 (([0, 1, 1, 1, 1, 1] : zF) +> R2) + have h8 : (L0 <{{C}} (([0, 1] : zF) ^ q +> (([0, 1, 1, 1, 1, 1] : zF) +> R2))) = + ((([1, 0, 1, 0] : zF) +> l) {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ q +> (([1, 1, 1, + 1, + 1] : zF) +> (([0, 1, 1] : zF) ^ j +> (([1] : zF) +> r)))))) := by + have hrot : (([0, 1] : zF) ^ q +> (([0, 1, 1, 1, 1, 1] : zF) +> R2)) = + ([0] : zF) +> (([1, 0] : zF) ^ q +> (([1, 1, 1, 1, 1] : zF) +> R2)) := by + change (([0, 1] : zF) ^ q +> (([0] : zF) +> (([1, 1, 1, 1, 1] : zF) +> R2))) = _ + rw [lpow_rot2 q 0 1] + rw [hrot] + exact C_left_right (([1, 0, 1, 0] : zF) +> l) _ + rw [h8] at h7 + exact ReachesPlus.trans_star (ReachesPlus.trans_star (ReachesPlus.trans_star + (ReachesPlus.trans_star (ReachesPlus.trans_star h1 h2) h3) (ReachesPlus.to_star h4)) h5) + (ReachesPlus.trans_star h6 h7 |> ReachesPlus.to_star) + +theorem PUSH (k : Nat) (l r : zB) : + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ 2 +> (([1, 1, 0] : zF) ^ k +> (([1, 1, + 1] : zF) +> r))))) [target_tm]⊢⁺ + ((([1, 0, 0] : zF) ^ k +> (([1, 0, 1, 0] : zF) +> l)) {{C}}> (([0, 0] : zF) +> (([1, + 0] : zF) +> (([1] : zF) +> r)))) := by + have h1 : (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ 2 +> (([1, 1, 0] : zF) ^ k +> (([1, 1, + 1] : zF) +> r))))) [target_tm]⊢⁺ + ((([0, 0] : zF) +> (([1, 0, 1, 0] : zF) +> l)) {{E}}> (([1, 1, 0] : zF) ^ k +> (([1, 1, + 1] : zF) +> r))) := by + change (l {{C}}> (([0, 0] : zF) +> (([1, 0, 1, 0] : zF) +> (([1, 1, 0] : zF) ^ k +> (([1, 1, + 1] : zF) +> r))))) [target_tm]⊢⁺ _ + execute + have h2 := E_push k (([1, 0, 1, 0] : zF) +> l) (([1, 1, 1] : zF) +> r) + have h3 : ((([0, 0] : zF) +> (([1, 0, 0] : zF) ^ k +> (([1, 0, 1, 0] : zF) +> l))) {{E}}> (([1, 1, + 1] : zF) +> r)) [target_tm]⊢⁺ + ((([1, 0, 0] : zF) ^ k +> (([1, 0, 1, 0] : zF) +> l)) {{C}}> (([0, 0] : zF) +> (([1, + 0] : zF) +> (([1] : zF) +> r)))) := by + execute + exact ReachesPlus.trans_star (ReachesPlus.trans_star h1 h2) (ReachesPlus.to_star h3) + +theorem BITE1 (p : Nat) (l r : zB) : + ((([1] : zF) +> (([0, 1] : zF) ^ p +> (([0, 0] : zF) +> l))) {{C}}> (([0, 0] : zF) +> (([1, + 0] : zF) +> (([1, 1] : zF) +> r)))) [target_tm]⊢⁺ + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (p + 3) +> (([1] : zF) +> r)))) := by + have hrotL : (([1] : zF) +> (([0, 1] : zF) ^ p +> (([0, 0] : zF) +> l))) = + (([1, 0] : zF) +> (([1, 0] : zF) ^ p +> (([0] : zF) +> l))) := by + change ([1] : zF) +> (([0, 1] : zF) ^ p +> (([0] : zF) +> (([0] : zF) +> l))) = _ + rw [lpow_rot2 p 0 1] + rfl + rw [hrotL] + have h1 : ((([1, 0] : zF) +> (([1, 0] : zF) ^ p +> (([0] : zF) +> l))) {{C}}> (([0, + 0] : zF) +> (([1, 0] : zF) +> (([1, 1] : zF) +> r)))) [target_tm]⊢⁺ + ((([1, 0] : zF) ^ p +> (([0] : zF) +> l)) <{{C}} (([0, 1, 0, 1, 0, 1, 0, + 1] : zF) +> r)) := by + execute + have h2 := SW p (([0] : zF) +> l) (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> r) + have h3 : ((([0] : zF) +> l) <{{C}} (([0, 1] : zF) ^ p +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> + r))) = + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (p + 3) +> (([1] : zF) +> r)))) := by + have hrotR : (([0, 1] : zF) ^ p +> (([0, 1, 0, 1, 0, 1, 0, 1] : zF) +> r)) = + ([0] : zF) +> (([1, 0] : zF) ^ (p + 3) +> (([1] : zF) +> r)) := by + change (([0, 1] : zF) ^ p +> (([0] : zF) +> (([1, 0] : zF) ^ 3 +> (([1] : zF) +> r)))) = _ + rw [lpow_rot2 p 0 1, str_app_assoc (([1, 0] : zF) ^ p) (([1, 0] : zF) ^ 3), ← list_pow_add] + rw [hrotR] + exact C_left_right l _ + rw [h3] at h2 + exact ReachesPlus.trans_star h1 h2 + +theorem BITE0 (p j : Nat) (l r : zB) : + ((([1] : zF) +> (([0, 1] : zF) ^ p +> (([0, 0] : zF) +> l))) {{C}}> (([0, 0] : zF) +> (([1, 1, + 1] : zF) ^ j +> (([1, 1, 0] : zF) +> r)))) [target_tm]⊢⁺ + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (p + 2) +> (([1] : zF) +> (([0, 1, + 1] : zF) ^ j +> (([1] : zF) +> r)))))) := by + have hrotL : (([1] : zF) +> (([0, 1] : zF) ^ p +> (([0, 0] : zF) +> l))) = + (([1, 0] : zF) +> (([1, 0] : zF) ^ p +> (([0] : zF) +> l))) := by + change ([1] : zF) +> (([0, 1] : zF) ^ p +> (([0] : zF) +> (([0] : zF) +> l))) = _ + rw [lpow_rot2 p 0 1] + rfl + rw [hrotL] + set L0 : zB := ([1, 0] : zF) +> (([1, 0] : zF) ^ p +> (([0] : zF) +> l)) + have hcommR : (([1, 1, 1] : zF) ^ j +> (([1, 1, 0] : zF) +> r)) = + ([1] : zF) +> (([1, 1, 1] : zF) ^ j +> (([1, 0] : zF) +> r)) := by + change (([1, 1, 1] : zF) ^ j +> (([1] : zF) +> (([1, 0] : zF) +> r))) = _ + rw [← S_ones1] + rw [hcommR] + have h1 : (L0 {{C}}> (([0, 0] : zF) +> (([1] : zF) +> (([1, 1, 1] : zF) ^ j +> (([1, + 0] : zF) +> r))))) [target_tm]⊢⁺ + ((([0, 1, 0] : zF) +> L0) {{B}}> (([1, 1, 1] : zF) ^ j +> (([1, 0] : zF) +> r))) := by + execute + have h2 := BR3 j (([0, 1, 0] : zF) +> L0) (([1, 0] : zF) +> r) + have h3 : ((([1, 1, 1] : zF) ^ j +> (([0, 1, 0] : zF) +> L0)) {{B}}> (([1, + 0] : zF) +> r)) [target_tm]⊢⁺ + ((([1] : zF) +> (([1, 1, 1] : zF) ^ j +> (([0, 1, + 0] : zF) +> L0))) <{{C}} (([1] : zF) +> r)) := by + execute + rw [S_ones1] at h3 + have h4 := TT j (([1] : zF) +> (([0, 1, 0] : zF) +> L0)) (([1] : zF) +> r) + set R2 : zB := ([0, 1, 1] : zF) ^ j +> (([1] : zF) +> r) + have h5 : ((([1] : zF) +> (([0, 1, 0] : zF) +> L0)) <{{C}} R2) [target_tm]⊢⁺ + ((([1, 0] : zF) ^ p +> (([0] : zF) +> l)) <{{C}} (([0, 1, 0, 1, 0, 1] : zF) +> R2)) := + by + dsimp [L0] + execute + have h6 := SW p (([0] : zF) +> l) (([0, 1, 0, 1, 0, 1] : zF) +> R2) + have h7 : ((([0] : zF) +> l) <{{C}} (([0, 1] : zF) ^ p +> (([0, 1, 0, 1, 0, 1] : zF) +> R2))) = + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (p + 2) +> (([1] : zF) +> R2)))) := by + have hrotR : (([0, 1] : zF) ^ p +> (([0, 1, 0, 1, 0, 1] : zF) +> R2)) = + ([0] : zF) +> (([1, 0] : zF) ^ (p + 2) +> (([1] : zF) +> R2)) := by + change (([0, 1] : zF) ^ p +> (([0] : zF) +> (([1, 0] : zF) ^ 2 +> (([1] : zF) +> R2)))) = _ + rw [lpow_rot2 p 0 1, str_app_assoc (([1, 0] : zF) ^ p) (([1, 0] : zF) ^ 2), ← list_pow_add] + rw [hrotR] + exact C_left_right l _ + rw [h7] at h6 + exact ReachesPlus.trans_star (ReachesPlus.trans_star (ReachesPlus.trans_star + (ReachesPlus.trans_star h1 h2) (ReachesPlus.to_star h3)) h4) (ReachesPlus.trans_star h5 h6 + |> ReachesPlus.to_star) + +theorem BITE0c (p j : Nat) (l r : zB) : + ((([1] : zF) +> (([0, 1] : zF) ^ p +> (([0, 0] : zF) +> l))) {{C}}> (([0, 0] : zF) +> (([1, 1, + 1] : zF) ^ j +> (([1, 1, 1, 1, 1, 1, 0] : zF) +> r)))) [target_tm]⊢⁺ + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (p + 2) +> (([1, 1, 1] : zF) +> (([1, 1, + 0] : zF) ^ j +> (([1, 1, 1] : zF) +> r)))))) := by + have hrotL : (([1] : zF) +> (([0, 1] : zF) ^ p +> (([0, 0] : zF) +> l))) = + (([1, 0] : zF) +> (([1, 0] : zF) ^ p +> (([0] : zF) +> l))) := by + change ([1] : zF) +> (([0, 1] : zF) ^ p +> (([0] : zF) +> (([0] : zF) +> l))) = _ + rw [lpow_rot2 p 0 1] + rfl + rw [hrotL] + set L0 : zB := ([1, 0] : zF) +> (([1, 0] : zF) ^ p +> (([0] : zF) +> l)) + have hcommR : (([1, 1, 1] : zF) ^ j +> (([1, 1, 1, 1, 1, 1, 0] : zF) +> r)) = + ([1] : zF) +> (([1, 1, 1] : zF) ^ j +> (([1, 1, 1, 1, 1, 0] : zF) +> r)) := by + change (([1, 1, 1] : zF) ^ j +> (([1] : zF) +> (([1, 1, 1, 1, 1, 0] : zF) +> r))) = _ + rw [← S_ones1] + rw [hcommR] + have h1 : (L0 {{C}}> (([0, 0] : zF) +> (([1] : zF) +> (([1, 1, 1] : zF) ^ j +> (([1, 1, 1, 1, 1, + 0] : zF) +> r))))) [target_tm]⊢⁺ + ((([0, 1, 0] : zF) +> L0) {{B}}> (([1, 1, 1] : zF) ^ j +> (([1, 1, 1, 1, 1, + 0] : zF) +> r))) := by + execute + have h2 := BR3 j (([0, 1, 0] : zF) +> L0) (([1, 1, 1, 1, 1, 0] : zF) +> r) + have h3 : ((([1, 1, 1] : zF) ^ j +> (([0, 1, 0] : zF) +> L0)) {{B}}> (([1, 1, 1, 1, 1, + 0] : zF) +> r)) [target_tm]⊢⁺ + ((([1] : zF) +> (([1, 1] : zF) +> (([1, 1] : zF) +> (([1, 1, 1] : zF) ^ j +> (([0, 1, + 0] : zF) +> L0))))) <{{C}} (([1] : zF) +> r)) := by + execute + rw [S_ones2, S_ones2, S_ones1] at h3 + have h4 := + TT j (([1] : zF) +> (([1, 1] : zF) +> (([1, 1] : zF) +> (([0, 1, + 0] : zF) +> L0)))) (([1] : zF) +> r) + set R2 : zB := ([0, 1, 1] : zF) ^ j +> (([1] : zF) +> r) + have h5 : ((([1] : zF) +> (([1, 1] : zF) +> (([1, 1] : zF) +> (([0, 1, + 0] : zF) +> L0)))) <{{C}} R2) [target_tm]⊢⁺ + ((([1, 0] : zF) ^ p +> (([0] : zF) +> l)) <{{C}} (([0, 1, 0, 1, 0, 1, 1, 1, 1, + 1] : zF) +> R2)) := by + dsimp [L0] + execute + have h6 := SW p (([0] : zF) +> l) (([0, 1, 0, 1, 0, 1, 1, 1, 1, 1] : zF) +> R2) + have h7 : ((([0] : zF) +> l) <{{C}} (([0, 1] : zF) ^ p +> (([0, 1, 0, 1, 0, 1, 1, 1, 1, + 1] : zF) +> R2))) = + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (p + 2) +> (([1, 1, 1] : zF) +> (([1, 1, + 0] : zF) ^ j +> (([1, 1, 1] : zF) +> r)))))) := by + have hrotR : (([0, 1] : zF) ^ p +> (([0, 1, 0, 1, 0, 1, 1, 1, 1, 1] : zF) +> R2)) = + ([0] : zF) +> (([1, 0] : zF) ^ (p + 2) +> (([1, 1, 1] : zF) +> (([1, 1, + 0] : zF) ^ j +> (([1, 1, 1] : zF) +> r)))) := by + change (([0, 1] : zF) ^ p +> (([0] : zF) +> (([1, 0] : zF) ^ 2 +> (([1, 1, 1] : zF) +> (([1, + 1] : zF) +> (([0, 1, 1] : zF) ^ j +> (([1] : zF) +> r))))))) = _ + rw [lpow_rot2 p 0 1, S_sh110 j (([1] : zF) +> r), str_app_assoc (([1, 0] : zF) ^ p) (([1, + 0] : zF) ^ 2), ← list_pow_add] + rfl + rw [hrotR] + exact C_left_right l _ + rw [h7] at h6 + exact ReachesPlus.trans_star (ReachesPlus.trans_star (ReachesPlus.trans_star + (ReachesPlus.trans_star h1 h2) (ReachesPlus.to_star h3)) h4) (ReachesPlus.trans_star h5 h6 + |> ReachesPlus.to_star) + +theorem BITE0c3 (p : Nat) (l r : zB) : + ((([1] : zF) +> (([0, 1] : zF) ^ p +> (([0, 0] : zF) +> l))) {{C}}> (([0, 0] : zF) +> (([1, 1, + 1, + 0, 0] : zF) +> r))) [target_tm]⊢⁺ + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (p + 1) +> (([1, 1, 1, 1, 1, 1] : zF) +> r)))) := + by + have hrotL : (([1] : zF) +> (([0, 1] : zF) ^ p +> (([0, 0] : zF) +> l))) = + (([1, 0] : zF) +> (([1, 0] : zF) ^ p +> (([0] : zF) +> l))) := by + change ([1] : zF) +> (([0, 1] : zF) ^ p +> (([0] : zF) +> (([0] : zF) +> l))) = _ + rw [lpow_rot2 p 0 1] + rfl + rw [hrotL] + have h1 : ((([1, 0] : zF) +> (([1, 0] : zF) ^ p +> (([0] : zF) +> l))) {{C}}> (([0, + 0] : zF) +> (([1, 1, 1, 0, 0] : zF) +> r))) [target_tm]⊢⁺ + ((([1, 0] : zF) ^ p +> (([0] : zF) +> l)) <{{C}} (([0, 1, 0, 1, 1, 1, 1, 1, + 1] : zF) +> r)) := by + execute + have h2 := SW p (([0] : zF) +> l) (([0, 1, 0, 1, 1, 1, 1, 1, 1] : zF) +> r) + have h3 : ((([0] : zF) +> l) <{{C}} (([0, 1] : zF) ^ p +> (([0, 1, 0, 1, 1, 1, 1, 1, + 1] : zF) +> r))) = + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (p + 1) +> (([1, 1, 1, 1, 1, + 1] : zF) +> r)))) := by + have hrotR : (([0, 1] : zF) ^ p +> (([0, 1, 0, 1, 1, 1, 1, 1, 1] : zF) +> r)) = + ([0] : zF) +> (([1, 0] : zF) ^ (p + 1) +> (([1, 1, 1, 1, 1, 1] : zF) +> r)) := by + change (([0, 1] : zF) ^ p +> (([0] : zF) +> (([1, 0] : zF) +> (([1, 1, 1, 1, 1, + 1] : zF) +> r)))) = _ + rw [lpow_rot2 p 0 1, str_app_assoc (([1, 0] : zF) ^ p) ([1, 0] : zF), list_pow_append_one] + rw [hrotR] + exact C_left_right l _ + rw [h3] at h2 + exact ReachesPlus.trans_star h1 h2 + +-- Zone and Digit Lemmas + +def bitc (v : Nat) : Fin 2 := if v % 2 = 1 then 0 else 1 + +def dg : Nat → Nat → zF + | 0, _ => [] + | L + 1, v => [1, 1, bitc v] ++ dg L (v / 2) + +def zone (r L v : Nat) : zF := ([1] : zF) ^ r ++ dg L v ++ [1, 1, 1] + +theorem bitc_even (v : Nat) : bitc (2 * v) = 1 := by + unfold bitc + have h : (2 * v) % 2 = 0 := by omega + simp [h] + +theorem bitc_odd (v : Nat) : bitc (2 * v + 1) = 0 := by + unfold bitc + have h : (2 * v + 1) % 2 = 1 := by omega + simp [h] + +theorem div2_odd (v : Nat) : (2 * v + 1) / 2 = v := by omega + +theorem dg_even (L v : Nat) : dg (L + 1) (2 * v) = [1, 1, 1] ++ dg L v := by + simp [dg, bitc_even] + +theorem dg_odd (L v : Nat) : dg (L + 1) (2 * v + 1) = [1, 1, 0] ++ dg L v := by + simp [dg, bitc_odd, div2_odd] + +theorem pow_pos (P : Nat) : 1 ≤ 2 ^ P := Nat.one_le_two_pow + +theorem pow2_succ (n : Nat) : 2 ^ (n + 1) = 2 * 2 ^ n := by ring + +theorem dg_zero (L : Nat) : dg L 0 = ([1, 1, 1] : zF) ^ L := by + induction L with + | zero => rfl + | succ L ih => + rw [dg, show bitc 0 = 1 from rfl, show 0 / 2 = 0 from rfl, ih, pow_succ_list] + +theorem dg_full (L : Nat) : dg L (2 ^ L - 1) = ([1, 1, 0] : zF) ^ L := by + induction L with + | zero => rfl + | succ L ih => + have h1 : 2 ^ (L + 1) - 1 = 2 * (2 ^ L - 1) + 1 := by + have := pow_pos L + rw [pow2_succ] + omega + rw [h1, dg_odd, ih, pow_succ_list] + +theorem dg_low (b L o : Nat) : + dg (b + (L + 1)) (2 ^ b * (2 * o + 1)) = ([1, 1, 1] : zF) ^ b ++ [1, 1, 0] ++ dg L o := by + induction b with + | zero => + rw [Nat.zero_add, Nat.pow_zero, Nat.one_mul, dg_odd] + rfl + | succ b ih => + have h1 : 2 ^ (b + 1) * (2 * o + 1) = 2 * (2 ^ b * (2 * o + 1)) := by ring + rw [Nat.succ_add, h1, dg_even, ih, pow_succ_list] + simp only [List.append_assoc] + +theorem dg_lowones (k L o : Nat) : + dg (k + (L + 1)) (2 ^ k - 1 + 2 ^ (k + 1) * o) = ([1, 1, 0] : zF) ^ k ++ [1, 1, 1] ++ dg L o := + by + induction k with + | zero => + have h1 : 2 ^ 0 - 1 + 2 ^ 1 * o = 2 * o := by omega + rw [Nat.zero_add, h1, dg_even] + rfl + | succ k ih => + have h1 : 2 ^ (k + 1) - 1 + 2 ^ (k + 2) * o = 2 * (2 ^ k - 1 + 2 ^ (k + 1) * o) + 1 := by + have := pow_pos k + have : 2 ^ (k + 1) = 2 * 2 ^ k := pow2_succ k + have : 2 ^ (k + 2) * o = 4 * (2 ^ k * o) := by rw [pow2_succ, pow2_succ]; ring + have : 2 ^ (k + 1) * o = 2 * (2 ^ k * o) := by rw [pow2_succ]; ring + omega + rw [Nat.succ_add, h1, dg_odd, ih, pow_succ_list] + simp only [List.append_assoc] + +theorem nat_strong_ind {P : Nat → Prop} (h : ∀ n, (∀ m < n, P m) → P n) (n : Nat) : P n := + h n (fun m _ => nat_strong_ind h m) + +theorem lowbit (x : Nat) (hx : x ≠ 0) : ∃ P o, x = 2 ^ P * (2 * o + 1) := by + refine @nat_strong_ind (fun x => x ≠ 0 → ∃ P o, x = 2 ^ P * (2 * o + 1)) (fun x ih hx => ?_) x hx + rcases Nat.even_or_odd' x with ⟨x', rfl | rfl⟩ + · rcases ih x' (by omega) (by omega) with ⟨P, o, ho⟩ + exact ⟨P + 1, o, by rw [ho]; ring⟩ + · exact ⟨0, x', by ring⟩ + +theorem lowbit_lt (b o L : Nat) (h : 2 ^ b * (2 * o + 1) < 2 ^ L) : b < L ∧ o < 2 ^ (L - b - 1) := + by + have hb : b < L := by + by_cases hlt : b < L + · exact hlt + · have hle : 2 ^ L ≤ 2 ^ b := Nat.pow_le_pow_right (by decide) (by omega) + have hp := pow_pos b + nlinarith + refine ⟨hb, ?_⟩ + have hL : L = b + (L - b - 1 + 1) := by omega + rw [hL, Nat.pow_add, pow2_succ] at h + have hp := pow_pos b + nlinarith + +theorem default_zero : (default : zB) = ([0] : zF) +> default := ListBlank.cons_zero_default.symm + +def RT (l : zB) (q : Nat) (Z : zF) : Cfg (Fin 2) (Fin 6) := + l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ q +> (Z +> default))) + +theorem R1z (l : zB) (q L v : Nat) (h1 : 1 ≤ v) (h2 : v < 2 ^ L) : + (RT l (q + 3) (zone 0 L v)) [target_tm]⊢⁺ (RT (([1, 0, 1, + 0] : zF) +> l) (q + 1) (zone 0 L (v - 1))) := by + rcases lowbit v (by omega) with ⟨b, o, rfl⟩ + rcases lowbit_lt b o L h2 with ⟨hb, ho⟩ + set L' := L - b - 1 + have hL : L = b + (L' + 1) := by omega + have hv : 2 ^ b * (2 * o + 1) - 1 = 2 ^ b - 1 + 2 ^ (b + 1) * o := by + have : 2 ^ b * (2 * o + 1) = 2 ^ b + 2 ^ (b + 1) * o := by ring + have := pow_pos b + omega + rw [hL, hv] + unfold RT zone + rw [dg_low, dg_lowones] + simp only [← str_app_assoc, pow_zero_list, listblank_append_nil] + exact RND2 q b l (dg L' o +> (([1, 1, 1] : zF) +> default)) + +theorem R1t (l : zB) (q L v : Nat) (h1 : 1 ≤ v) (h2 : v < 2 ^ L) : + (RT l (q + 3) (zone 2 L v)) [target_tm]⊢⁺ (RT (([1, 0, 1, + 0] : zF) +> l) (q + 1) (zone 2 L (v - 1))) := by + rcases lowbit v (by omega) with ⟨b, o, rfl⟩ + rcases lowbit_lt b o L h2 with ⟨hb, ho⟩ + set L' := L - b - 1 + have hL : L = b + (L' + 1) := by omega + have hv : 2 ^ b * (2 * o + 1) - 1 = 2 ^ b - 1 + 2 ^ (b + 1) * o := by + have : 2 ^ b * (2 * o + 1) = 2 ^ b + 2 ^ (b + 1) * o := by ring + have := pow_pos b + omega + rw [hL, hv] + unfold RT zone + rw [dg_low, dg_lowones] + simp only [← str_app_assoc] + set R : zB := dg L' o +> (([1, 1, 1] : zF) +> default) + have hLHS : (([1] : zF) ^ 2 +> (([1, 1, 1] : zF) ^ b +> (([1, 1, 0] : zF) +> R))) = + (([1, 1, 1] : zF) ^ b +> (([1, 1, 1, 1, 0] : zF) +> R)) := by + change (([1, 1] : zF) +> (([1, 1, 1] : zF) ^ b +> (([1, 1, 0] : zF) +> R))) = _ + rw [S_ones2, str_app_assoc ([1, 1] : zF) ([1, 1, 0] : zF)] + rfl + have hRHS : (([1, 1, 1, 1] : zF) +> (([0, 1, 1] : zF) ^ b +> (([1] : zF) +> R))) = + (([1] : zF) ^ 2 +> (([1, 1, 0] : zF) ^ b +> (([1, 1, 1] : zF) +> R))) := by + change (([1, 1] : zF) +> (([1, 1] : zF) +> (([0, 1, 1] : zF) ^ b +> (([1] : zF) +> R)))) = + (([1, 1] : zF) +> (([1, 1, 0] : zF) ^ b +> (([1, 1, 1] : zF) +> R))) + rw [S_sh110 b (([1] : zF) +> R), str_app_assoc ([1, 1] : zF) ([1] : zF)] + rfl + rw [hLHS, ← hRHS] + exact RND1 q b l R + +theorem R2r (l : zB) (q L v : Nat) (h1 : 1 ≤ v) (h2 : v < 2 ^ L) : + (RT l (q + 3) (zone 1 L v)) [target_tm]⊢⁺ (RT (([1, 0, 1, + 0] : zF) +> l) q (zone 0 (L + 1) (2 * v - 2))) := by + rcases lowbit v (by omega) with ⟨b, o, rfl⟩ + rcases lowbit_lt b o L h2 with ⟨hb, ho⟩ + set L' := L - b - 1 + have hL : L = b + (L' + 1) := by omega + have hv : 2 * (2 ^ b * (2 * o + 1)) - 2 = 2 * (2 ^ b - 1 + 2 ^ (b + 1) * o) := by + have : 2 ^ b * (2 * o + 1) = 2 ^ b + 2 ^ (b + 1) * o := by ring + have := pow_pos b + omega + rw [hL, hv] + unfold RT zone + rw [dg_low, dg_even, dg_lowones] + simp only [← str_app_assoc, pow_zero_list, listblank_append_nil] + set R : zB := dg L' o +> (([1, 1, 1] : zF) +> default) + have hLHS : (([1] : zF) ^ 1 +> (([1, 1, 1] : zF) ^ b +> (([1, 1, 0] : zF) +> R))) = + (([1, 1, 1] : zF) ^ b +> (([1, 1, 1, 0] : zF) +> R)) := by + change (([1] : zF) +> (([1, 1, 1] : zF) ^ b +> (([1, 1, 0] : zF) +> R))) = _ + rw [S_ones1, str_app_assoc ([1] : zF) ([1, 1, 0] : zF)] + rfl + have hRHS : (([1, 1, 1, 1, 1] : zF) +> (([0, 1, 1] : zF) ^ b +> (([1] : zF) +> R))) = + (([1, 1, 1] : zF) +> (([1, 1, 0] : zF) ^ b +> (([1, 1, 1] : zF) +> R))) := by + change (([1, 1, 1] : zF) +> (([1, 1] : zF) +> (([0, 1, 1] : zF) ^ b +> (([1] : zF) +> R)))) = _ + rw [S_sh110 b (([1] : zF) +> R), str_app_assoc ([1, 1] : zF) ([1] : zF)] + rfl + rw [hLHS, ← hRHS] + exact RND0 q b l R + +theorem O2r (l : zB) (q L : Nat) : + (RT l (q + 3) (zone 2 L 0)) [target_tm]⊢⁺ (RT (([1, 0, 1, + 0] : zF) +> l) (q + 1) (zone 0 (L + 1) (2 ^ (L + 1) - 1))) := by + unfold RT zone + rw [dg_zero, dg_full] + simp only [← str_app_assoc, pow_zero_list, listblank_append_nil] + have hE : (([1] : zF) ^ 2 +> (([1, 1, 1] : zF) ^ L +> (([1, 1, 1] : zF) +> default))) = + (([1, 1, 1] : zF) ^ (L + 1) +> (([1, 1, 0] : zF) +> default)) := by + change (([1, 1] : zF) +> (([1, 1, 1] : zF) ^ L +> (([1, 1, 1] : zF) +> default))) = _ + rw [S_ones2, str_app_assoc ([1, 1] : zF) ([1, 1, 1] : zF)] + change (([1, 1, 1] : zF) ^ L +> (([1, 1, 1] : zF) +> (([1, 1] : zF) +> default))) = _ + rw [str_app_assoc (([1, 1, 1] : zF) ^ L) ([1, 1, 1] : zF), list_pow_append_one] + conv_lhs => rw [default_zero] + rw [str_app_assoc ([1, 1] : zF) ([0] : zF)] + rfl + rw [hE] + exact RND2 q (L + 1) l default + +theorem O1r (l : zB) (q L : Nat) : + (RT l (q + 3) (zone 1 L 0)) [target_tm]⊢⁺ (RT (([1, 0, 1, + 0] : zF) +> l) (q + 1) (zone 2 L (2 ^ L - 1))) := by + unfold RT zone + rw [dg_zero, dg_full] + simp only [← str_app_assoc] + have hLHS : (([1] : zF) ^ 1 +> (([1, 1, 1] : zF) ^ L +> (([1, 1, 1] : zF) +> default))) = + (([1, 1, 1] : zF) ^ L +> (([1, 1, 1, 1, 0] : zF) +> default)) := by + change (([1] : zF) +> (([1, 1, 1] : zF) ^ L +> (([1, 1, 1] : zF) +> default))) = _ + rw [S_ones1] + conv_lhs => rw [default_zero] + rfl + have hRHS : (([1, 1, 1, 1] : zF) +> (([0, 1, 1] : zF) ^ L +> (([1] : zF) +> default))) = + (([1] : zF) ^ 2 +> (([1, 1, 0] : zF) ^ L +> (([1, 1, 1] : zF) +> default))) := by + change (([1, 1] : zF) +> (([1, 1] : zF) +> (([0, 1, 1] : zF) ^ L +> (([1] : zF) +> default)))) = + (([1, 1] : zF) +> (([1, 1, 0] : zF) ^ L +> (([1, 1, 1] : zF) +> default))) + rw [S_sh110 L (([1] : zF) +> default), str_app_assoc ([1, 1] : zF) ([1] : zF)] + rfl + rw [hLHS, ← hRHS] + exact RND1 q L l default + +theorem O0r (l : zB) (q L : Nat) : + (RT l (q + 3) (zone 0 L 0)) [target_tm]⊢⁺ (RT (([1, 0, 1, + 0] : zF) +> l) q (zone 0 (L + 1) (2 ^ (L + 1) - 2))) := by + have hv : 2 ^ (L + 1) - 2 = 2 * (2 ^ L - 1) := by + have := pow_pos L + rw [pow2_succ] + omega + rw [hv] + unfold RT zone + rw [dg_zero, dg_even, dg_full] + simp only [← str_app_assoc, pow_zero_list, listblank_append_nil] + have hLHS : (([1, 1, 1] : zF) ^ L +> (([1, 1, 1] : zF) +> default)) = + (([1, 1, 1] : zF) ^ L +> (([1, 1, 1, 0] : zF) +> default)) := by + conv_lhs => rw [default_zero] + rw [str_app_assoc ([1, 1, 1] : zF) ([0] : zF)] + rfl + have hRHS : (([1, 1, 1, 1, 1] : zF) +> (([0, 1, 1] : zF) ^ L +> (([1] : zF) +> default))) = + (([1, 1, 1] : zF) +> (([1, 1, 0] : zF) ^ L +> (([1, 1, 1] : zF) +> default))) := by + change (([1, 1, 1] : zF) +> (([1, 1] : zF) +> (([0, 1, + 1] : zF) ^ L +> (([1] : zF) +> default)))) = _ + rw [S_sh110 L (([1] : zF) +> default), str_app_assoc ([1, 1] : zF) ([1] : zF)] + rfl + rw [hLHS, ← hRHS] + exact RND0 q L l default + +def FR (p : Nat) (l : zB) : zB := ([1] : zF) +> (([0, 1] : zF) ^ p +> (([0, 0] : zF) +> l)) + +theorem PUSHr (l : zB) (k L o : Nat) : + (RT l 2 (zone 0 (k + (L + 1)) (2 ^ k - 1 + 2 ^ (k + 1) * o))) [target_tm]⊢⁺ + (RT (([1, 0, 0] : zF) ^ k +> (([1, 0, 1, 0] : zF) +> l)) 1 (zone 1 L o)) := by + unfold RT zone + rw [dg_lowones] + simp only [← str_app_assoc, pow_zero_list, listblank_append_nil] + exact PUSH k l (dg L o +> (([1, 1, 1] : zF) +> default)) + +theorem B1z0 (p : Nat) (l : zB) (L v : Nat) : + (RT (FR p l) 1 (zone 0 (L + 1) (2 * v))) [target_tm]⊢⁺ (RT l (p + 3) (zone 2 L v)) := by + unfold RT FR zone + rw [dg_even] + simp only [← str_app_assoc, pow_zero_list, listblank_append_nil] + exact BITE1 p l (([1] : zF) +> (dg L v +> (([1, 1, 1] : zF) +> default))) + +theorem B1z1 (p : Nat) (l : zB) (L v : Nat) : + (RT (FR p l) 1 (zone 0 (L + 1) (2 * v + 1))) [target_tm]⊢⁺ (RT l (p + 4) (zone 0 L v)) := by + unfold RT FR zone + rw [dg_odd] + simp only [← str_app_assoc, pow_zero_list, listblank_append_nil] + have h1 := BITE1 p l (([0] : zF) +> (dg L v +> (([1, 1, 1] : zF) +> default))) + have h2 : (([1, 0] : zF) ^ (p + 3) +> (([1] : zF) +> (([0] : zF) +> (dg L v +> (([1, 1, + 1] : zF) +> default))))) = + (([1, 0] : zF) ^ (p + 4) +> (dg L v +> (([1, 1, 1] : zF) +> default))) := by + change (([1, 0] : zF) ^ (p + 3) +> (([1, 0] : zF) +> (dg L v +> (([1, 1, + 1] : zF) +> default)))) = _ + rw [str_app_assoc (([1, 0] : zF) ^ (p + 3)) ([1, 0] : zF), list_pow_append_one] + rw [h2] at h1 + exact h1 + +theorem B1o (p : Nat) (l : zB) (L v : Nat) : + (RT (FR p l) 1 (zone 1 L v)) [target_tm]⊢⁺ (RT l (p + 3) (zone 0 L v)) := by + unfold RT FR zone + cases L with + | zero => + dsimp [dg] + exact BITE1 p l (([1, 1] : zF) +> default) + | succ L => + dsimp [dg] + simp only [← str_app_assoc] + exact BITE1 p l (([1, bitc v] : zF) +> (dg L (v / 2) +> (([1, 1, 1] : zF) +> default))) + +theorem B1t (p : Nat) (l : zB) (L v : Nat) : + (RT (FR p l) 1 (zone 2 L v)) [target_tm]⊢⁺ (RT l (p + 3) (zone 1 L v)) := by + unfold RT FR zone + simp only [← str_app_assoc] + exact BITE1 p l (dg L v +> (([1, 1, 1] : zF) +> default)) + +theorem B0r (p : Nat) (l : zB) (b L o : Nat) : + (RT (FR p l) 0 (zone 0 (b + 1 + (L + 1)) (2 ^ (b + 1) * (2 * o + 1)))) [target_tm]⊢⁺ + (RT l (p + 3) (zone 0 (b + (L + 1)) (2 ^ b - 1 + 2 ^ (b + 1) * o))) := by + unfold RT FR zone + rw [dg_low, dg_lowones] + simp only [← str_app_assoc, pow_zero_list, listblank_append_nil] + set R : zB := dg L o +> (([1, 1, 1] : zF) +> default) + have h1 := BITE0 p (b + 1) l R + have h2 : (([1, 0] : zF) ^ (p + 2) +> (([1] : zF) +> (([0, 1, + 1] : zF) ^ (b + 1) +> (([1] : zF) +> R)))) = + (([1, 0] : zF) ^ (p + 3) +> (([1, 1, 0] : zF) ^ b +> (([1, 1, 1] : zF) +> R))) := by + rw [pow_succ_list ([0, 1, 1] : zF) b, ← str_app_assoc ([0, 1, 1] : zF)] + change (([1, 0] : zF) ^ (p + 2) +> (([1, 0] : zF) +> (([1, 1] : zF) +> (([0, 1, + 1] : zF) ^ b +> (([1] : zF) +> R))))) = _ + rw [S_sh110 b (([1] : zF) +> R)] + change (([1, 0] : zF) ^ (p + 2) +> (([1, 0] : zF) +> (([1, 1, 0] : zF) ^ b +> (([1, 1, + 1] : zF) +> R)))) = _ + rw [str_app_assoc (([1, 0] : zF) ^ (p + 2)) ([1, 0] : zF), list_pow_append_one] + rw [h2] at h1 + exact h1 + +theorem B0cr (p : Nat) (l : zB) (L : Nat) : + (RT (FR p l) 0 (zone 0 (L + 1) 0)) [target_tm]⊢⁺ (RT l (p + 2) (zone 0 (L + 1) (2 ^ (L + 1) - + 2))) := by + have hv : 2 ^ (L + 1) - 2 = 2 * (2 ^ L - 1) := by + have := pow_pos L + rw [pow2_succ] + omega + rw [hv] + unfold RT FR zone + rw [dg_zero, dg_even, dg_full] + simp only [← str_app_assoc, pow_zero_list, listblank_append_nil] + have hE : (([1, 1, 1] : zF) ^ (L + 1) +> (([1, 1, 1] : zF) +> default)) = + (([1, 1, 1] : zF) ^ L +> (([1, 1, 1, 1, 1, 1, 0] : zF) +> default)) := by + rw [← list_pow_append_one, ← str_app_assoc (([1, 1, 1] : zF) ^ L) ([1, 1, 1] : zF)] + conv_lhs => rw [default_zero] + rfl + rw [hE] + exact BITE0c p L l default + +theorem B0c3r (p : Nat) (l : zB) : + (RT (FR p l) 0 (zone 0 0 0)) [target_tm]⊢⁺ (RT l (p + 1) (zone 0 1 0)) := by + unfold RT FR + change ((([1] : zF) +> (([0, 1] : zF) ^ p +> (([0, 0] : zF) +> l))) {{C}}> + (([0, 0] : zF) +> (([1, 0] : zF) ^ 0 +> (([1, 1, 1] : zF) +> default)))) [target_tm]⊢⁺ + (l {{C}}> (([0, 0] : zF) +> (([1, 0] : zF) ^ (p + 1) +> (([1, 1, 1, 1, 1, + 1] : zF) +> default)))) + simp only [pow_zero_list, listblank_append_nil] + have hE : (([1, 1, 1] : zF) +> default) = (([1, 1, 1, 0, 0] : zF) +> default) := by + conv_lhs => rw [default_zero] + conv_lhs => rw [default_zero] + rfl + rw [hE] + exact BITE0c3 p l default + +theorem FR_round (p : Nat) (l : zB) : + (([1, 0, 1, 0] : zF) +> FR p l) = FR (p + 2) l := by + unfold FR + have hp : p + 2 = (p + 1) + 1 := rfl + rw [hp, pow_succ_list, pow_succ_list, ← str_app_assoc, ← str_app_assoc] + rfl + +theorem init_step : (init []) [target_tm]⊢* RT default 6 (zone 2 0 0) := by + have h1 : (init []) [target_tm]⊢⁺ (default {{C}}> (([0, 0, 1, 0, 1, 0, 1] : zF) +> default)) := by + unfold init + rw [tape_mk1_nil] + change (default {{A}}> default) [target_tm]⊢⁺ _ + execute + have h2 : (default {{C}}> (([0, 0, 1, 0, 1, 0, 1] : zF) +> default)) [target_tm]⊢⁺ + RT default 3 (zone 0 0 0) := by + unfold RT zone dg + execute + have hFR1 : (([1, 0, 1, 0] : zF) +> default) = FR 1 default := by + unfold FR + conv_lhs => rw [default_zero] + rfl + have h3 := O0r default 0 0 + rw [hFR1] at h3 + have h4 := B0cr 1 default 0 + have h5 := O0r default 0 1 + rw [hFR1] at h5 + have h6 := B0r 1 default 0 0 0 + have h7 := O0r default 1 1 + rw [hFR1] at h7 + have h8 := B1z0 1 default 1 1 + have h9 := R1t default 1 1 1 (by omega) (by decide) + rw [hFR1] at h9 + have h10 : (RT (FR 1 default) 2 (zone 2 1 0)) [target_tm]⊢⁺ RT default 6 (zone 2 0 0) := by + unfold RT FR zone dg + execute + exact ReachesPlus.to_star (stepPlus_trans h1 (stepPlus_trans h2 (stepPlus_trans h3 + (stepPlus_trans h4 + (stepPlus_trans h5 (stepPlus_trans h6 (stepPlus_trans h7 (stepPlus_trans h8 + (stepPlus_trans h9 h10))))))))) + +def lev (P : Nat) (l : zB) : zB := + match P with + | 0 => l + | p + 1 => FR p l + +def okL (P : Nat) (l : zB) : Prop := P = 0 → l = default + +theorem lev_round (P : Nat) (l : zB) (h : okL P l) : + (([1, 0, 1, 0] : zF) +> lev P l) = lev (P + 2) l := by + cases P with + | zero => + have hl := h rfl + subst hl + unfold lev FR + conv_lhs => rw [default_zero] + rfl + | succ p => + change (([1, 0, 1, 0] : zF) +> FR p l) = FR (p + 2) l + exact FR_round p l + +theorem okL_S (P : Nat) (l : zB) : okL (P + 1) l := by + intro h + omega + +inductive Rnd : Nat → Nat → Nat → Nat → Nat → Nat → Nat → Nat → Prop where + | RR1z (q L v : Nat) (h : 1 ≤ v) : Rnd (q + 3) 0 L v (q + 1) 0 L (v - 1) + | RR1t (q L v : Nat) (h : 1 ≤ v) : Rnd (q + 3) 2 L v (q + 1) 2 L (v - 1) + | RR2 (q L v : Nat) (h : 1 ≤ v) : Rnd (q + 3) 1 L v q 0 (L + 1) (2 * v - 2) + | RO2 (q L : Nat) : Rnd (q + 3) 2 L 0 (q + 1) 0 (L + 1) (2 ^ (L + 1) - 1) + | RO1 (q L : Nat) : Rnd (q + 3) 1 L 0 (q + 1) 2 L (2 ^ L - 1) + | RO0 (q L : Nat) : Rnd (q + 3) 0 L 0 q 0 (L + 1) (2 ^ (L + 1) - 2) + +theorem Rnd_tape (q r L v q' r' L' v' P : Nat) (l : zB) + (h : Rnd q r L v q' r' L' v') (hv : v < 2 ^ L) (hl : okL P l) : + (RT (lev P l) q (zone r L v)) [target_tm]⊢⁺ (RT (lev (P + 2) l) q' (zone r' L' v')) := by + rw [← lev_round P l hl] + cases h with + | RR1z q0 _ _ h1 => exact R1z (lev P l) q0 L v h1 hv + | RR1t q0 _ _ h1 => exact R1t (lev P l) q0 L v h1 hv + | RR2 _ _ _ h1 => exact R2r (lev P l) q' L v h1 hv + | RO2 q0 _ => exact O2r (lev P l) q0 L + | RO1 q0 _ => exact O1r (lev P l) q0 L + | RO0 _ _ => exact O0r (lev P l) q' L + +theorem Rnd_valid (q r L v q' r' L' v' : Nat) + (h : Rnd q r L v q' r' L' v') (hv : v < 2 ^ L) (hr : r < 3) : + v' < 2 ^ L' ∧ r' < 3 := by + have hL := pow_pos L + cases h <;> (try simp only [pow2_succ] at *) <;> omega + +theorem Rnd_exists (q r L v : Nat) (hq : 3 ≤ q) (hr : r < 3) : + ∃ q' r' L' v', Rnd q r L v q' r' L' v' := by + have hq' : q = (q - 3) + 3 := by omega + rw [hq'] + by_cases hv : v = 0 + · subst hv + rcases r with _ | _ | _ | r + · exact ⟨_, _, _, _, Rnd.RO0 (q - 3) L⟩ + · exact ⟨_, _, _, _, Rnd.RO1 (q - 3) L⟩ + · exact ⟨_, _, _, _, Rnd.RO2 (q - 3) L⟩ + · omega + · rcases r with _ | _ | _ | r + · exact ⟨_, _, _, _, Rnd.RR1z (q - 3) L v (by omega)⟩ + · exact ⟨_, _, _, _, Rnd.RR2 (q - 3) L v (by omega)⟩ + · exact ⟨_, _, _, _, Rnd.RR1t (q - 3) L v (by omega)⟩ + · omega + +theorem okL_ge (P : Nat) (l : zB) (h : 1 ≤ P) : okL P l := by + cases P with + | zero => omega + | succ p => exact okL_S p l + +-- High-Level Invariants and Induction (`cap`, `Kst`, `Jst`, `Mv`, `Qv`, `Ist`, `EB`, `safe`, `U`, +-- `cycles`) + +def cap (r L : Nat) : Nat := + match r with + | 1 => L + 1 + | _ => L + +@[simp] theorem cap0 (L : Nat) : cap 0 L = L := rfl +@[simp] theorem cap1 (L : Nat) : cap 1 L = L + 1 := rfl +@[simp] theorem cap2 (L : Nat) : cap 2 L = L := rfl + +theorem pow2_1 (L : Nat) : 2 ^ (L + 1) = 2 * 2 ^ L := pow2_succ L +theorem pow2_2 (L : Nat) : 2 ^ (L + 2) = 4 * 2 ^ L := by + rw [show L + 2 = (L + 1) + 1 by omega, pow2_succ, pow2_succ]; ring +theorem pow2_3 (L : Nat) : 2 ^ (L + 3) = 8 * 2 ^ L := by + rw [show L + 3 = (L + 2) + 1 by omega, pow2_succ, pow2_2]; ring +theorem pow2_4 (L : Nat) : 2 ^ (L + 4) = 16 * 2 ^ L := by + rw [show L + 4 = (L + 3) + 1 by omega, pow2_succ, pow2_3]; ring + +def Kst (n r L : Nat) : Prop := 2 ^ (cap r L + 1) + 2 ≤ n + +def Jst (n r : Nat) : Prop := 3 ≤ n ∧ (r ≠ 0 → n % 2 = 1) + +def Mv (n r L v : Nat) : Nat := + match r with + | 1 => (n + v + 2 * 2 ^ (L + 3)) % 3 + | _ => (n + 2 * v + 2 * 2 ^ (L + 2)) % 3 + +@[simp] theorem Mv0 (n L v : Nat) : Mv n 0 L v = (n + 2 * v + 2 * 2 ^ (L + 2)) % 3 := rfl +@[simp] theorem Mv1 (n L v : Nat) : Mv n 1 L v = (n + v + 2 * 2 ^ (L + 3)) % 3 := rfl +@[simp] theorem Mv2 (n L v : Nat) : Mv n 2 L v = (n + 2 * v + 2 * 2 ^ (L + 2)) % 3 := rfl + +def Qv (P q r L v : Nat) : Nat := (Mv q r L v + 2 * P) % 3 + +def Ist (n r L v : Nat) : Prop := + r < 3 ∧ v < 2 ^ L ∧ Kst n r L ∧ Mv n r L v ≠ 0 ∧ ¬ (n = 6 ∧ r = 1 ∧ L = 0 ∧ v = 0) + +theorem init_I : Ist 6 2 0 0 := by + unfold Ist Kst Mv cap + decide + +theorem Rnd_sign (P q r L v q' r' L' v' : Nat) (h : Rnd q r L v q' r' L' v') : + Qv P q r L v = Qv (P + 2) q' r' L' v' := by + unfold Qv + have hL := pow_pos L + cases h <;> simp only [Mv0, Mv1, Mv2, pow2_1] at * <;> omega + +inductive EB : Nat → Nat → Nat → Nat → Nat → Nat → Nat → Nat → Prop where + | EB1z0 (L v : Nat) : EB 1 0 (L + 1) (2 * v) 2 2 L v + | EB1z1 (L v : Nat) : EB 1 0 (L + 1) (2 * v + 1) 3 0 L v + | EB1o (L v : Nat) : EB 1 1 L v 2 0 L v + | EB1t (L v : Nat) : EB 1 2 L v 2 1 L v + | EB0 (b L o : Nat) : EB 0 0 (b + 1 + (L + 1)) (2 ^ (b + 1) * (2 * o + 1)) 2 0 (b + (L + 1)) (2 ^ + b - + 1 + 2 ^ (b + 1) * o) + | EB0c (L : Nat) : EB 0 0 (L + 1) 0 1 0 (L + 1) (2 ^ (L + 1) - 2) + | EB0c3 : EB 0 0 0 0 0 0 1 0 + +theorem EB_tape (q r L v e r' L' v' p : Nat) (l : zB) (h : EB q r L v e r' L' v') : + (RT (FR p l) q (zone r L v)) [target_tm]⊢⁺ (RT l (p + 1 + e) (zone r' L' v')) := by + cases h with + | EB1z0 => + rw [show p + 1 + 2 = p + 3 by omega] + exact B1z0 p l L' v' + | EB1z1 => + rw [show p + 1 + 3 = p + 4 by omega] + exact B1z1 p l L' v' + | EB1o => + rw [show p + 1 + 2 = p + 3 by omega] + exact B1o p l L v + | EB1t => + rw [show p + 1 + 2 = p + 3 by omega] + exact B1t p l L v + | EB0 b L0 o => + rw [show p + 1 + 2 = p + 3 by omega] + exact B0r p l b L0 o + | EB0c L0 => + rw [show p + 1 + 1 = p + 2 by omega] + exact B0cr p l L0 + | EB0c3 => + rw [show p + 1 + 0 = p + 1 by omega] + exact B0c3r p l + +theorem EB_sign (q r L v e r' L' v' P : Nat) (h : EB q r L v e r' L' v') : + (Mv (P + e) r' L' v' + Qv P q r L v) % 3 = 0 := by + unfold Qv + cases h with + | EB1z0 => + have := pow_pos L' + simp only [Mv0, Mv2, pow2_1] at * + omega + | EB1z1 => + have := pow_pos L' + simp only [Mv0, pow2_1] at * + omega + | EB1o => + have := pow_pos L + simp only [Mv0, Mv1, pow2_1] at * + omega + | EB1t => + have := pow_pos L + simp only [Mv1, Mv2, pow2_1] at * + omega + | EB0 b L0 o => + have hb := pow_pos b + have hL := pow_pos (b + L0) + have h1 : 2 ^ (b + 1) * (2 * o + 1) = 4 * (2 ^ b * o) + 2 * 2 ^ b := by + rw [pow2_succ]; ring + have h2 : 2 ^ b - 1 + 2 ^ (b + 1) * o = 2 ^ b - 1 + 2 * (2 ^ b * o) := by + rw [pow2_succ]; ring + have h3 : 2 ^ (b + 1 + (L0 + 1) + 2) = 16 * 2 ^ (b + L0) := by + rw [show b + 1 + (L0 + 1) + 2 = (b + L0) + 4 by omega, pow2_4] + have h4 : 2 ^ (b + (L0 + 1) + 2) = 8 * 2 ^ (b + L0) := by + rw [show b + (L0 + 1) + 2 = (b + L0) + 3 by omega, pow2_3] + simp only [Mv0] + rw [h1, h2, h3, h4] + omega + | EB0c L0 => + have := pow_pos L0 + simp only [Mv0, pow2_1] at * + omega + | EB0c3 => + simp only [Mv0] + omega + +theorem iter_FR0 (k : Nat) (X : zB) : + (([1, 0, 0] : zF) ^ k +> X) = (FR 0)^[k] X := by + induction k with + | zero => rfl + | succ k ih => + rw [Function.iterate_succ', Function.comp_apply, pow_succ_list, ← str_app_assoc, ih] + rfl + +theorem PUSH_lev (k L o P : Nat) (l : zB) (hl : okL P l) : + (RT (lev P l) 2 (zone 0 (k + (L + 1)) (2 ^ k - 1 + 2 ^ (k + 1) * o))) [target_tm]⊢⁺ + (RT ((FR 0)^[k] (lev (P + 2) l)) 1 (zone 1 L o)) := by + rw [← lev_round P l hl, ← iter_FR0] + exact PUSHr (lev P l) k L o + +theorem inner1 (k L o : Nat) (X : zB) : + (RT ((FR 0)^[k + 1] X) 1 (zone 1 L o)) [target_tm]⊢⁺ (RT ((FR 0)^[k] X) 3 (zone 0 L o)) := by + rw [Function.iterate_succ', Function.comp_apply] + exact EB_tape 1 1 L o 2 0 L o 0 ((FR 0)^[k] X) (EB.EB1o L o) + +def safe (c : Cfg (Fin 2) (Fin 6)) (N : Nat) : Prop := + ∀ M ≤ N, ∀ cfg, multiStep target_tm c M = some cfg → (step target_tm cfg).isSome + +theorem safe_mono (c : Cfg (Fin 2) (Fin 6)) (N N' : Nat) (h : safe c N) (hle : N' ≤ N) : safe c + N' := by + intro M hM cfg hrun + exact h M (by omega) cfg hrun + +theorem multiStep_lt_isSome {c c' cfg : Cfg (Fin 2) (Fin 6)} {n M : Nat} + (hn : c [target_tm]⊢^{n} c') (hM : c [target_tm]⊢^{M} cfg) (hlt : M < n) : + (step target_tm cfg).isSome := by + have hsplit : n = (M + 1) + (n - (M + 1)) := by omega + rw [hsplit, multiStep_add, multiStep_succ', hM] at hn + dsimp [Option.bind] at hn + cases hstep : step target_tm cfg with + | none => rw [hstep] at hn; simp at hn + | some c2 => rfl + +theorem multiStep_ge_drop {c c' cfg : Cfg (Fin 2) (Fin 6)} {n M : Nat} + (hn : c [target_tm]⊢^{n} c') (hM : c [target_tm]⊢^{M} cfg) (hle : n ≤ M) : + c' [target_tm]⊢^{M - n} cfg := by + have hsplit : M = n + (M - n) := by omega + rw [hsplit, multiStep_add, hn] at hM + exact hM + +theorem safe_ev (c c' : Cfg (Fin 2) (Fin 6)) (N : Nat) + (h : c [target_tm]⊢* c') (hN : safe c' N) : safe c N := by + rcases h with ⟨n, hn⟩ + intro M hM cfg hrun + by_cases hle : n ≤ M + · exact hN (M - n) (by omega) cfg (multiStep_ge_drop hn hrun hle) + · exact multiStep_lt_isSome hn hrun (by omega) + +theorem safe_prog (c c' : Cfg (Fin 2) (Fin 6)) (N : Nat) + (h : c [target_tm]⊢⁺ c') (hN : safe c' (N - 1)) : safe c N := by + rcases h with ⟨n, hn_pos, hn⟩ + intro M hM cfg hrun + by_cases hle : n ≤ M + · exact hN (M - n) (by omega) cfg (multiStep_ge_drop hn hrun hle) + · exact multiStep_lt_isSome hn hrun (by omega) + +theorem safe_prog0 (c c' : Cfg (Fin 2) (Fin 6)) + (h : c [target_tm]⊢⁺ c') : safe c 0 := by + rcases h with ⟨n, hn_pos, hn⟩ + intro M hM cfg hrun + exact multiStep_lt_isSome hn hrun (by omega) + +theorem safe_RT0 (l : zB) (q : Nat) (Z : zF) : safe (RT l q Z) 0 := by + intro M hM cfg hrun + have hM0 : M = 0 := by omega + subst hM0 + change some (RT l q Z) = some cfg at hrun + injection hrun with hcfg + subst hcfg + unfold RT + simp only [step, listblank_append_cons, Turing.ListBlank.head_cons] + rfl + +theorem phase (Inv : Nat → Nat → Nat → Nat → Nat → Prop) + (Hstep : ∀ j q r L v q' r' L' v', Rnd q r L v q' r' L' v' → v < 2 ^ L → + Inv j q r L v → Inv (j + 2) q' r' L' v') + (q j P : Nat) (l : zB) (r L v : Nat) + (hl : okL (P + j) l) (hr : r < 3) (hv : v < 2 ^ L) (hI : Inv j q r L v) : + ∃ j' q' r' L' v', q' ≤ 2 ∧ r' < 3 ∧ v' < 2 ^ L' ∧ Inv j' q' r' L' v' ∧ + j ≤ j' ∧ (3 ≤ q → j + 2 ≤ j') ∧ + ((RT (lev (P + j) l) q (zone r L v)) [target_tm]⊢* (RT (lev (P + j') l) q' (zone r' L' + v'))) := by + by_cases hq : q ≤ 2 + · exact ⟨j, q, r, L, v, hq, hr, hv, hI, by omega, by omega, ⟨0, rfl⟩⟩ + · rcases Rnd_exists q r L v (by omega) hr with ⟨q', r', L', v', hR⟩ + have hq' : q' < q := by cases hR <;> omega + rcases Rnd_valid q r L v q' r' L' v' hR hv hr with ⟨hv', hr'⟩ + have hl' : okL (P + (j + 2)) l := okL_ge (P + (j + 2)) l (by omega) + rcases phase Inv Hstep q' (j + 2) P l r' L' v' hl' hr' hv' (Hstep j q r L v q' r' L' v' hR hv + hI) with + ⟨j2, q2, r2, L2, v2, h1, h2, h3, h4, h5, h6, h7⟩ + refine ⟨j2, q2, r2, L2, v2, h1, h2, h3, h4, by omega, by omega, ?_⟩ + have hstep := Rnd_tape q r L v q' r' L' v' (P + j) l hR hv hl + rw [show (P + j) + 2 = P + (j + 2) by omega] at hstep + exact stepStar_trans (ReachesPlus.to_star hstep) h7 +termination_by q + +theorem pow0 (L : Nat) (h : L = 0) : 2 ^ L = 1 := by subst h; rfl + +def Kx (n r L v : Nat) : Prop := + Kst n r L ∧ ¬ (r = 2 ∧ v = 2 ^ L - 1 ∧ n = 2 ^ (L + 1) + 2) ∧ + ¬ (n = 6 ∧ r = 1 ∧ L = 0 ∧ v = 0) + +def Pre (n r L v : Nat) : Prop := Jst n r ∨ Kx n r L v + +def Saf (q r L v : Nat) : Prop := + match r with + | 0 => (L = 0 → 3 ≤ q) ∧ ¬ (q = 2 ∧ v = 2 ^ L - 1) ∧ (q = 0 → v % 2 = 0) + | 1 => 3 ≤ q ∧ (v = 0 → q ≤ 2 ^ (L + 1) + 2 → q % 2 = 1) ∧ (v = 0 → q ≠ 2 ^ (L + 1) + 4) + | _ + 2 => (q ≤ 2 * v + 2 → q % 2 = 1) ∧ q ≠ 2 * v + 4 + +@[simp] theorem Saf0 (q L v : Nat) : + Saf q 0 L v = ((L = 0 → 3 ≤ q) ∧ ¬ (q = 2 ∧ v = 2 ^ L - 1) ∧ (q = 0 → v % 2 = 0)) := rfl +@[simp] theorem Saf1 (q L v : Nat) : + Saf q 1 L v = (3 ≤ q ∧ (v = 0 → q ≤ 2 ^ (L + 1) + 2 → q % 2 = 1) ∧ (v = 0 → q ≠ 2 ^ (L + 1) + + 4)) := + rfl +@[simp] theorem Saf2 (q L v : Nat) : + Saf q 2 L v = ((q ≤ 2 * v + 2 → q % 2 = 1) ∧ q ≠ 2 * v + 4) := rfl + +def KI (j q r L v : Nat) : Prop := + match r with + | 0 => 2 ^ L ≤ j + q ∧ (2 ^ (L + 1) ≤ j + 2 * v + 2 ∨ 2 ^ (L + 1) + 1 ≤ j + q) ∧ + (q = 0 → v ≠ 0) ∧ (L = 0 → 4 ≤ q) + | 1 => 2 ^ (L + 2) + 2 ≤ q ∧ (v = 0 → 2 ^ (L + 1) + 5 ≤ q) + | _ + 2 => 2 ^ (L + 1) + 2 ≤ j + q ∧ 2 * v + 5 ≤ q + +@[simp] theorem KI0 (j q L v : Nat) : + KI j q 0 L v = (2 ^ L ≤ j + q ∧ (2 ^ (L + 1) ≤ j + 2 * v + 2 ∨ 2 ^ (L + 1) + 1 ≤ j + q) ∧ + (q = 0 → v ≠ 0) ∧ (L = 0 → 4 ≤ q)) := rfl +@[simp] theorem KI1 (j q L v : Nat) : + KI j q 1 L v = (2 ^ (L + 2) + 2 ≤ q ∧ (v = 0 → 2 ^ (L + 1) + 5 ≤ q)) := rfl +@[simp] theorem KI2 (j q L v : Nat) : + KI j q 2 L v = (2 ^ (L + 1) + 2 ≤ j + q ∧ 2 * v + 5 ≤ q) := rfl + +def ZI (C q r L v : Nat) : Prop := + 1 ≤ C ∧ + match r with + | 0 => L ≤ C + 1 ∧ q + 2 ^ (L + 2) + C ≤ 2 * v + L + 2 ^ (C + 3) + 1 ∧ + (q = 0 → v = 0 → L ≤ C) + | 1 => L + 2 ≤ C ∧ q ≤ 2 ^ (L + 2) + 1 ∧ 3 ≤ q + | _ + 2 => L + 1 ≤ C ∧ q ≤ 2 * v + 2 ^ (L + 1) + 1 + +@[simp] theorem ZI0 (C q L v : Nat) : + ZI C q 0 L v = (1 ≤ C ∧ L ≤ C + 1 ∧ q + 2 ^ (L + 2) + C ≤ 2 * v + L + 2 ^ (C + 3) + 1 ∧ + (q = 0 → v = 0 → L ≤ C)) := rfl +@[simp] theorem ZI1 (C q L v : Nat) : + ZI C q 1 L v = (1 ≤ C ∧ L + 2 ≤ C ∧ q ≤ 2 ^ (L + 2) + 1 ∧ 3 ≤ q) := rfl +@[simp] theorem ZI2 (C q L v : Nat) : + ZI C q 2 L v = (1 ≤ C ∧ L + 1 ≤ C ∧ q ≤ 2 * v + 2 ^ (L + 1) + 1) := rfl + +theorem true_imp {P : Prop} : (True → P) = P := propext ⟨fun h => h trivial, fun h _ => h⟩ +theorem true_and_eq {P : Prop} : (True ∧ P) = P := propext ⟨fun h => h.2, fun h => ⟨trivial, h⟩⟩ +theorem one_add_one : 1 + 1 = 2 := rfl + +theorem Saf_step (q r L v q' r' L' v' : Nat) + (h : Rnd q r L v q' r' L' v') (hv : v < 2 ^ L) (hS : Saf q r L v) : + Saf q' r' L' v' := by + have hL := pow_pos L + have h0 := pow0 L + cases h <;> simp only [Saf0, Saf1, Saf2, pow2_1, true_imp] at * <;> omega + +theorem KI_step (j q r L v q' r' L' v' : Nat) + (h : Rnd q r L v q' r' L' v') (hv : v < 2 ^ L) (hK : KI j q r L v) : + KI (j + 2) q' r' L' v' := by + have hL := pow_pos L + have h0 := pow0 L + cases h with + | RO0 => + cases L with + | zero => simp only [KI0, pow2_1, Nat.pow_zero, true_imp] at *; omega + | succ L0 => + have := pow_pos L0 + simp only [KI0, pow2_1] at * + omega + | _ => simp only [KI0, KI1, KI2, pow2_1, true_imp] at *; omega + +theorem pow_mono (a b : Nat) (h : a ≤ b) : 2 ^ a ≤ 2 ^ b := + Nat.pow_le_pow_right (by decide) h + +theorem pow_lin (a : Nat) : a + 1 ≤ 2 ^ a := by + induction a with + | zero => decide + | succ a ih => rw [pow2_succ]; omega + +theorem ZI_step (C q r L v q' r' L' v' : Nat) + (h : Rnd q r L v q' r' L' v') (hv : v < 2 ^ L) (hZ : ZI C q r L v) : + ZI C q' r' L' v' := by + have hL := pow_pos L + have hlC := pow_lin C + have h0 := pow0 L + cases h with + | RR1z q0 _ _ h1 => + simp only [ZI0, pow2_1] at *; omega + | RR1t q0 _ _ h1 => + simp only [ZI2, pow2_1] at *; omega + | RR2 _ _ _ h1 => + simp only [ZI0, ZI1] at * + have hm := pow_mono (L + 2) C (by omega) + simp only [pow2_1] at *; omega + | RO2 q0 _ => + simp only [ZI0, ZI2] at * + have hm := pow_mono (L + 1) C (by omega) + simp only [pow2_1] at *; omega + | RO1 q0 _ => + simp only [ZI1, ZI2, pow2_1] at *; omega + | RO0 _ _ => + simp only [ZI0] at * + by_cases hE : L = C + 1 + · subst hE; simp only [pow2_1] at *; omega + · cases L with + | zero => simp only [pow2_1, Nat.pow_zero] at *; omega + | succ L0 => have := pow_pos L0; simp only [pow2_1] at *; omega + +def PI (n r L v j q r' L' v' : Nat) : Prop := + j % 2 = 0 ∧ Qv j q r' L' v' = Mv n r L v ∧ + (r' = 1 → j = 0) ∧ (r' = 2 → L' = 0 → j ≤ 2) ∧ + Saf q r' L' v' ∧ (Kx n r L v → KI j q r' L' v') ∧ + (Jst n r → ¬ Kst n r L → ZI (cap r L + 1) q r' L' v') + +theorem PI_step (n r L v j q r1 L1 v1 q' r' L' v' : Nat) + (h : Rnd q r1 L1 v1 q' r' L' v') (hv : v1 < 2 ^ L1) (hP : PI n r L v j q r1 L1 v1) : + PI n r L v (j + 2) q' r' L' v' := by + rcases hP with ⟨h1, h2, h3, h4, h5, h6, h7⟩ + refine ⟨by omega, ?_, ?_, ?_, Saf_step q r1 L1 v1 q' r' L' v' h hv h5, + fun hK => KI_step j q r1 L1 v1 q' r' L' v' h hv (h6 hK), + fun hJ hK => ZI_step (cap r L + 1) q r1 L1 v1 q' r' L' v' h hv (h7 hJ hK)⟩ + · rw [← h2] + exact (Rnd_sign j q r1 L1 v1 q' r' L' v' h).symm + · intro hE + cases h <;> omega + · intro hE1 hE2 + cases h with + | RR1t q L1 v1 h1 => + subst hE2 + simp at hv + omega + | RO1 q L1 => + have := h3 rfl + omega + | _ => omega + +theorem Mv_lt3 (n r L v : Nat) : Mv n r L v < 3 := by + rcases r with _ | _ | r <;> simp only [Mv] <;> omega + +theorem Qv0 (q r L v : Nat) : Qv 0 q r L v = Mv q r L v := by + unfold Qv + have := Mv_lt3 q r L v + omega + +theorem Pre_n3 (n r L v : Nat) (h : Pre n r L v) : 3 ≤ n := by + rcases h with ⟨h, _⟩ | ⟨h, _⟩ + · exact h + · unfold Kst at h + have := pow_pos (cap r L + 1) + omega + +theorem Saf_start (n r L v : Nat) (hr : r < 3) (hv : v < 2 ^ L) (hP : Pre n r L v) : + Saf n r L v := by + have hL := pow_pos L + have h0 := pow0 L + rcases hP with ⟨hn, hp⟩ | ⟨hK, hT, h6⟩ + · rcases r with _ | _ | _ | r <;> (try simp only [Nat.zero_add, one_add_one, Saf0, Saf1, Saf2, + pow2_1] at *) <;> omega + · unfold Kst at hK + rcases r with _ | _ | _ | r + · simp only [Saf0, cap0, pow2_1] at *; omega + · simp only [Nat.zero_add, Saf1, cap1, pow2_1, true_and_eq] at * + cases L with + | zero => simp only [Nat.pow_zero, true_imp, true_and_eq] at *; omega + | succ L0 => have := pow_pos L0; simp only [pow2_1] at *; omega + · simp only [Nat.zero_add, one_add_one, Saf2, cap2, pow2_1, true_and_eq] at *; omega + · omega + +theorem KI_start (n r L v : Nat) (hr : r < 3) (hv : v < 2 ^ L) (hK : Kx n r L v) : + KI 0 n r L v := by + rcases hK with ⟨hK, hT, h6⟩ + have hL := pow_pos L + have h0 := pow0 L + unfold Kst at hK + rcases r with _ | _ | _ | r + · simp only [Nat.zero_add, KI0, cap0, pow2_1] at *; omega + · simp only [Nat.zero_add, KI1, cap1, pow2_1, true_and_eq] at * + cases L with + | zero => simp only [Nat.pow_zero, true_imp, true_and_eq] at *; omega + | succ L0 => have := pow_pos L0; simp only [pow2_1] at *; omega + · simp only [Nat.zero_add, one_add_one, KI2, cap2, pow2_1, true_and_eq] at *; omega + · omega + +theorem ZI_start (n r L v : Nat) (hr : r < 3) (hv : v < 2 ^ L) (hJ : Jst n r) (hK : ¬ Kst n r L) : + ZI (cap r L + 1) n r L v := by + rcases hJ with ⟨hn, hp⟩ + have hL := pow_pos L + have h0 := pow0 L + unfold Kst at hK + rcases r with _ | _ | _ | r <;> (try simp only [Nat.zero_add, one_add_one, ZI0, ZI1, ZI2, cap0, + cap1, cap2, pow2_1] at *) <;> omega + +theorem PI_start (n r L v : Nat) (hr : r < 3) (hv : v < 2 ^ L) (hP : Pre n r L v) : + PI n r L v 0 n r L v := + ⟨rfl, Qv0 n r L v, fun _ => rfl, fun _ _ => by omega, + Saf_start n r L v hr hv hP, + fun hK => KI_start n r L v hr hv hK, + fun hJ hK => ZI_start n r L v hr hv hJ hK⟩ + +def Post (n r L v n' r' L' v' : Nat) : Prop := + r' < 3 ∧ v' < 2 ^ L' ∧ + (Jst n r → Jst (n' + 1) r') ∧ + (Kx n r L v → Kst n' r' L') ∧ + (Jst n r → ¬ Kst n r L → Kst (n' + 1) r' L' ∨ cap r' L' ≤ cap r L + 1) ∧ + (Mv n' r' L' v' + Mv n r L v) % 3 = 0 ∧ + (r' = 1 → L' = 0 → v' = 0 → n' = 4 ∨ 8 ≤ n') + +def U (N : Nat) : Prop := + ∀ P l n r L v, okL P l → r < 3 → v < 2 ^ L → Pre n r L v → + (∀ n' r' L' v', Post n r L v n' r' L' v' → safe (RT l (P + n') (zone r' L' v')) (N - 1)) → + safe (RT (lev P l) n (zone r L v)) N + +theorem lowones (L : Nat) : ∀ v, v < 2 ^ L → v ≠ 2 ^ L - 1 → + ∃ k L' o, L = k + (L' + 1) ∧ v = 2 ^ k - 1 + 2 ^ (k + 1) * o ∧ o < 2 ^ L' := by + induction L with + | zero => + intro v hv hne + simp at hv hne + omega + | succ L ih => + intro v hv hne + rw [pow2_succ] at hv hne + rcases Nat.even_or_odd' v with ⟨o, rfl | rfl⟩ + · exact ⟨0, L, o, by omega, by omega, by omega⟩ + · rcases ih o (by omega) (by omega) with ⟨k, L', o', rfl, rfl, ho'⟩ + refine ⟨k + 1, L', o', by omega, ?_, ho'⟩ + have := pow_pos k + have : 2 ^ (k + 1) = 2 * 2 ^ k := pow2_succ k + have : 2 ^ (k + 1 + 1) * o' = 4 * (2 ^ k * o') := by rw [pow2_succ, pow2_succ]; ring + have : 2 ^ (k + 1) * o' = 2 * (2 ^ k * o') := by rw [pow2_succ]; ring + omega + +theorem bite_shape (j qb rb Lb vb : Nat) + (hq : qb ≤ 2) (hr : rb < 3) (hv : vb < 2 ^ Lb) (hS : Saf qb rb Lb vb) + (hj : 2 ≤ j) (h1 : rb = 1 → j = 0) : + (∃ e r' L' v', EB qb rb Lb vb e r' L' v') ∨ + (qb = 2 ∧ rb = 0 ∧ ∃ k L' o, Lb = k + (L' + 1) ∧ vb = 2 ^ k - 1 + 2 ^ (k + 1) * o ∧ o < 2 ^ L') + := by + rcases rb with _ | _ | _ | rb + · simp only [Saf0] at hS + rcases hS with ⟨hS1, hS2, hS3⟩ + rcases qb with _ | _ | _ | qb + · cases Lb with + | zero => omega + | succ Lb => + left + by_cases hne : vb = 0 + · subst hne; exact ⟨_, _, _, _, EB.EB0c Lb⟩ + · rcases lowbit vb hne with ⟨b, o, rfl⟩ + cases b with + | zero => have := hS3 rfl; omega + | succ b => + rcases lowbit_lt (b + 1) o (Lb + 1) hv with ⟨hb, ho⟩ + rw [show Lb + 1 = (b + 1) + (Lb - b - 1 + 1) by omega] + exact ⟨_, _, _, _, EB.EB0 b (Lb - b - 1) o⟩ + · cases Lb with + | zero => omega + | succ Lb => + left + rcases Nat.even_or_odd' vb with ⟨w, rfl | rfl⟩ + · exact ⟨_, _, _, _, EB.EB1z0 Lb w⟩ + · exact ⟨_, _, _, _, EB.EB1z1 Lb w⟩ + · right + exact ⟨rfl, rfl, lowones Lb vb hv (fun hE => hS2 ⟨rfl, hE⟩)⟩ + · omega + · omega + · simp only [Nat.zero_add, one_add_one, Saf2] at hS + have hqb : qb = 1 := by omega + subst hqb + exact Or.inl ⟨_, _, _, _, EB.EB1t Lb vb⟩ + · omega + +theorem EB_valid (q r L v e r' L' v' : Nat) + (h : EB q r L v e r' L' v') (hv : v < 2 ^ L) : + r' < 3 ∧ v' < 2 ^ L' := by + cases h with + | EB1z0 L v => + rw [pow2_succ] at hv + exact ⟨by omega, by omega⟩ + | EB1z1 L v => + rw [pow2_succ] at hv + exact ⟨by omega, by omega⟩ + | EB1o L v => + exact ⟨by omega, hv⟩ + | EB1t L v => + exact ⟨by omega, hv⟩ + | EB0 b L o => + refine ⟨by omega, ?_⟩ + have hb := pow_pos b + have h1 : 2 ^ (b + 1) * (2 * o + 1) = 2 * (2 ^ b + 2 ^ (b + 1) * o) := by + rw [pow2_succ]; ring + have h2 : 2 ^ (b + 1 + (L + 1)) = 2 * 2 ^ (b + (L + 1)) := by + rw [Nat.succ_add, pow2_succ] + rw [h1, h2] at hv + omega + | EB0c L => + have := pow_pos L + rw [pow2_succ] + exact ⟨by omega, by omega⟩ + | EB0c3 => + exact ⟨by omega, by decide⟩ + +theorem EB_lev (q r L v e r' L' v' P : Nat) (l : zB) + (hP : 1 ≤ P) (h : EB q r L v e r' L' v') : + (RT (lev P l) q (zone r L v)) [target_tm]⊢⁺ (RT l (P + e) (zone r' L' v')) := by + cases P with + | zero => omega + | succ p => exact EB_tape q r L v e r' L' v' p l h + +theorem Kst_mono (n n' r L : Nat) (h : Kst n r L) (hle : n ≤ n') : Kst n' r L := by + unfold Kst at * + omega + +theorem ending (n r L v j qb rb Lb vb e r' L' v' : Nat) + (h : EB qb rb Lb vb e r' L' v') (hP : PI n r L v j qb rb Lb vb) + (hj : 2 ≤ j) (hvb : vb < 2 ^ Lb) : + Post n r L v (j + e) r' L' v' := by + rcases hP with ⟨h1, h2, h3, h4, h5, h6, h7⟩ + rcases EB_valid qb rb Lb vb e r' L' v' h hvb with ⟨hr', hv'⟩ + have hS := EB_sign qb rb Lb vb e r' L' v' j h + rw [h2] at hS + refine ⟨hr', hv', ?_, ?_, ?_, hS, ?_⟩ + · intro _ + unfold Jst + cases h <;> omega + · intro hK + have hKI := h6 hK + unfold Kst + cases h with + | EB1z0 => + have := pow_pos L' + simp only [KI0, cap2, pow2_1] at * + omega + | EB1z1 => + have := pow_pos L' + simp only [KI0, cap0, pow2_1] at * + omega + | EB1o => + have := pow_pos L + simp only [KI1, cap0, pow2_1, true_imp] at * + omega + | EB1t => + have := pow_pos L + simp only [KI2, cap1, pow2_1, true_imp] at * + omega + | EB0 b L0 o => + simp only [KI0, cap0, true_imp] at * + rw [show b + (L0 + 1) + 1 = b + 1 + (L0 + 1) by omega] + omega + | EB0c L0 => + simp only [KI0, cap0, true_imp] at * + omega + | EB0c3 => + simp only [KI0, cap0, true_imp] at * + omega + · intro hJ hK + have hZ := h7 hJ hK + right + cases h <;> simp only [ZI0, ZI1, ZI2, cap0, cap1, cap2, true_imp] at * <;> omega + · intro hE1 hE2 hE3 + cases h with + | EB1t _ _ => + subst hE2 hE3 + have := h4 rfl rfl + omega + | _ => omega + +theorem ending_B2 (n r L v j L' o : Nat) + (hP : PI n r L v j 2 0 (0 + (L' + 1)) (2 ^ 0 - 1 + 2 ^ 1 * o)) + (hj : 2 ≤ j) (ho : o < 2 ^ L') : + Post n r L v (j + 4) 0 L' o := by + rcases hP with ⟨h1, h2, h3, h4, h5, h6, h7⟩ + simp only [Nat.zero_add, Nat.pow_zero, Nat.pow_one] at * + refine ⟨by omega, ho, fun _ => by unfold Jst; omega, ?_, ?_, ?_, fun hE => by omega⟩ + · intro hK + have hKI := h6 hK + unfold Kst + have := pow_pos L' + simp only [KI0, cap0, pow2_1] at * + omega + · intro hJ hK + have hZ := h7 hJ hK + right + simp only [ZI0, cap0] at * + omega + · rw [← h2] + unfold Qv + have := pow_pos L' + simp only [Mv0, pow2_1] at * + omega + +def Budget (n r L C : Nat) : Prop := Kst n r L ∨ cap r L ≤ C + +def SR (j a b : Nat) : Prop := + (j % 2 = 0 → b = a) ∧ (j % 2 = 1 → (a + b + 2) % 3 = 0) + +theorem JK (n r L v : Nat) (hJ : Jst n r) (hK : Kst n r L) : Kx n r L v := by + rcases hJ with ⟨hn, hp⟩ + refine ⟨hK, ?_, ?_⟩ + · rintro ⟨rfl, _, rfl⟩ + have := hp (by omega) + rw [pow2_succ] at this + omega + · rintro ⟨rfl, rfl, _⟩ + have := hp (by omega) + omega + +theorem Budget_step (n r L v C n' r' L' v' : Nat) + (hJ : Jst n r) (hB : Budget n r L C) (hP : Post n r L v n' r' L' v') : + Budget (n' + 1) r' L' (C + 1) := by + rcases hP with ⟨_, _, _, hU2, hU3, _⟩ + by_cases hK : 2 ^ (cap r L + 1) + 2 ≤ n + · left + exact Kst_mono n' (n' + 1) r' L' (hU2 (JK n r L v hJ hK)) (by omega) + · rcases hB with hB | hB + · unfold Kst at hB; omega + · rcases hU3 hJ hK with h | h + · exact Or.inl h + · exact Or.inr (by omega) + +theorem Mv_shift (a n r L v : Nat) : Mv (a + n) r L v = (Mv n r L v + a) % 3 := by + rcases r with _ | _ | r <;> simp only [Mv] <;> omega + +theorem SR_step (j n r L v n' r' L' v' b : Nat) + (hb : b < 3) (hP : Post n r L v n' r' L' v') (hSR : SR j (Mv (n' + 1) r' L' v') b) : + SR (j + 1) (Mv n r L v) b := by + rcases hP with ⟨_, _, _, _, _, hU4, _⟩ + rcases hSR with ⟨hE, hO⟩ + rw [show n' + 1 = 1 + n' by omega, Mv_shift] at hE hO + have := Mv_lt3 n r L v + have := Mv_lt3 n' r' L' v' + exact ⟨fun hj => by omega, fun hj => by omega⟩ + +theorem pow2_mod3 (k : Nat) : ∃ x, 2 ^ k = 3 * x + 1 + k % 2 := by + induction k with + | zero => exact ⟨0, rfl⟩ + | succ k ih => + rcases ih with ⟨x, hx⟩ + refine ⟨2 * x + k % 2, ?_⟩ + rw [pow2_succ, hx] + omega + +theorem QvN (j k L o : Nat) : + (k % 2 = 0 → + Qv j 2 0 (k + 1 + (L + 1)) (2 ^ (k + 1) - 1 + 2 ^ (k + 2) * o) = (Mv 3 0 L o + 1 + 2 * j) % + 3) ∧ + (k % 2 = 1 → + Qv j 2 0 (k + 1 + (L + 1)) (2 ^ (k + 1) - 1 + 2 ^ (k + 2) * o) = + (2 * (Mv 3 0 L o + 1) + 2 * j) % 3) := by + rcases pow2_mod3 k with ⟨x, hx⟩ + have hL := pow_pos L + unfold Qv + simp only [Mv0] + have h1 : 2 ^ (k + 1) = 2 * 2 ^ k := by rw [pow2_succ] + have h2 : 2 ^ (k + 2) * o = 4 * (2 ^ k * o) := by rw [pow2_succ, pow2_succ]; ring + have h3 : 2 ^ (k + 1 + (L + 1) + 2) = 16 * (2 ^ k * 2 ^ L) := by + rw [show k + 1 + (L + 1) + 2 = (k + L) + 4 by omega, pow2_4, Nat.pow_add] + have h4 : 2 ^ (L + 2) = 4 * 2 ^ L := pow2_2 L + have h2k : 2 ^ k ≥ 1 := pow_pos k + have hmul1 : 2 ^ k * o = 3 * (x * o) + o + (k % 2) * o := by + calc 2 ^ k * o = (3 * x + 1 + k % 2) * o := by rw [hx] + _ = 3 * (x * o) + o + (k % 2) * o := by ring + have hmul2 : 2 ^ k * 2 ^ L = 3 * (x * 2 ^ L) + 2 ^ L + (k % 2) * 2 ^ L := by + calc 2 ^ k * 2 ^ L = (3 * x + 1 + k % 2) * 2 ^ L := by rw [hx] + _ = 3 * (x * 2 ^ L) + 2 ^ L + (k % 2) * 2 ^ L := by ring + rw [h1, h2, h3, h4, hmul1, hmul2, hx] + constructor <;> intro hk <;> rw [hk] <;> simp only [Nat.zero_mul, Nat.one_mul] <;> omega + +theorem compose (n r L v j k L' o n1 r1 L1 v1 n3 r3 L3 v3 : Nat) + (hPI : PI n r L v j 2 0 (k + 1 + (L' + 1)) (2 ^ (k + 1) - 1 + 2 ^ (k + 2) * o)) + (hj : 2 ≤ j) (hJ1 : Jst n1 r1) (hB1 : Budget n1 r1 L1 (L' + k)) + (hSR : SR k (Mv 3 0 L' o) (Mv n1 r1 L1 v1)) + (hP : Post n1 r1 L1 v1 n3 r3 L3 v3) : + Post n r L v (j + 2 + n3) r3 L3 v3 := by + have hB3 := Budget_step n1 r1 L1 v1 (L' + k) n3 r3 L3 v3 hJ1 hB1 hP + rcases hPI with ⟨h1, h2, h3, h4, h5, h6, h7⟩ + rcases hP with ⟨hr3, hv3, hU1, hU2, hU3, hU4, hU5⟩ + rcases hU1 hJ1 with ⟨hn3, hp3⟩ + refine ⟨hr3, hv3, ?_, ?_, ?_, ?_, ?_⟩ + · intro _ + refine ⟨by omega, fun hE => ?_⟩ + have := hp3 hE + omega + · intro hK + have hKI := h6 hK + simp only [KI0] at hKI + unfold Kst + rcases hB3 with hB3 | hB3 + · unfold Kst at hB3; omega + · have hm := pow_mono (cap r3 L3 + 1) (k + 1 + (L' + 1)) (by omega) + omega + · intro hJ hK + have hZ := h7 hJ hK + simp only [ZI0] at hZ + rcases hB3 with hB3 | hB3 + · exact Or.inl (Kst_mono (n3 + 1) (j + 2 + n3 + 1) r3 L3 hB3 (by omega)) + · exact Or.inr (by omega) + · rw [Mv_shift (j + 2) n3] + rcases hSR with ⟨hE, hO⟩ + rcases QvN j k L' o with ⟨hQE, hQO⟩ + have := Mv_lt3 n3 r3 L3 v3 + have := Mv_lt3 n1 r1 L1 v1 + have := Mv_lt3 3 0 L' o + rw [← h2] + by_cases hk : k % 2 = 0 + · rw [hQE hk]; have := hE hk; omega + · have hk1 : k % 2 = 1 := by omega + rw [hQO hk1]; have := hO hk1; omega + · intro hE1 hE2 hE3 + right + have := hU5 hE1 hE2 hE3 + omega + +theorem STK (j B : Nat) (hU : ∀ B', B' ≤ B → U B') (n r L v C : Nat) (X : zB) + (hJ : Jst n r) (hB : Budget n r L C) (hr : r < 3) (hv : v < 2 ^ L) + (hk : ∀ n1 r1 L1 v1, Jst n1 r1 → Budget n1 r1 L1 (C + j) → r1 < 3 → v1 < 2 ^ L1 → + SR j (Mv n r L v) (Mv n1 r1 L1 v1) → safe (RT X n1 (zone r1 L1 v1)) (B - j)) : + safe (RT ((FR 0)^[j] X) n (zone r L v)) B := by + induction j generalizing B n r L v C with + | zero => + have h := hk n r L v hJ (by rw [Nat.add_zero]; exact hB) hr hv ⟨fun _ => rfl, fun h => by omega⟩ + rw [Nat.sub_zero] at h + exact h + | succ j ih => + rw [Function.iterate_succ', Function.comp_apply] + change safe (RT (lev 1 ((FR 0)^[j] X)) n (zone r L v)) B + apply hU B (Nat.le_refl B) 1 ((FR 0)^[j] X) n r L v (okL_S 0 _) hr hv (Or.inl hJ) + intro n' r' L' v' hP + rw [show 1 + n' = n' + 1 by omega] + have ⟨hr', hv', hU1, _⟩ := hP + apply ih (B - 1) (fun B' hB' => hU B' (by omega)) (n' + 1) r' L' v' (C + 1) (hU1 hJ) + (Budget_step n r L v C n' r' L' v' hJ hB hP) hr' hv' + intro n1 r1 L1 v1 hJ1 hB1 hr1 hv1 hS1 + rw [show B - 1 - j = B - (j + 1) by omega] + apply hk n1 r1 L1 v1 hJ1 (by rw [show C + (j + 1) = (C + 1) + j by omega]; exact hB1) hr1 hv1 + exact SR_step j n r L v n' r' L' v' (Mv n1 r1 L1 v1) (Mv_lt3 n1 r1 L1 v1) hP hS1 + +theorem U_all (N : Nat) : U N := by + refine nat_strong_ind (fun N ih => ?_) N + intro P l n r L v hl hr hv hpre hk + have hn := Pre_n3 n r L v hpre + cases N with + | zero => + rcases Rnd_exists n r L v hn hr with ⟨q', r', L', v', hR⟩ + exact safe_prog0 _ _ (Rnd_tape n r L v q' r' L' v' P l hR hv hl) + | succ N' => + rcases phase (PI n r L v) (PI_step n r L v) n 0 P l r L v + (by rw [Nat.add_zero]; exact hl) hr hv (PI_start n r L v hr hv hpre) with + ⟨j, qb, rb, Lb, vb, hqb, hrb, hvb, hI, _, hj_fn, hrun⟩ + have hj := hj_fn hn + rw [Nat.add_zero] at hrun + rw [Nat.zero_add] at hj + apply safe_ev _ _ (N' + 1) hrun + have hlP : okL (P + j) l := okL_ge (P + j) l (by omega) + have ⟨_, _, hI3, _, hI5, _⟩ := hI + rcases bite_shape j qb rb Lb vb hqb hrb hvb hI5 hj hI3 with + ⟨e, r', L', v', hE⟩ | ⟨rfl, rfl, k, L', o, rfl, rfl, ho⟩ + · apply safe_prog _ _ (N' + 1) (EB_lev qb rb Lb vb e r' L' v' (P + j) l (by omega) hE) + rw [show P + j + e = P + (j + e) by omega] + exact hk (j + e) r' L' v' (ending n r L v j qb rb Lb vb e r' L' v' hE hI hj hvb) + · cases k with + | zero => + have hstep1 := PUSH_lev 0 L' o (P + j) l hlP + have hstep2 := EB_lev 1 1 L' o 2 0 L' o (P + j + 2) l (by omega) (EB.EB1o L' o) + apply safe_prog _ _ (N' + 1) (stepPlus_trans hstep1 hstep2) + rw [show P + j + 2 + 2 = P + (j + 4) by omega] + exact hk (j + 4) 0 L' o (ending_B2 n r L v j L' o hI hj ho) + | succ k => + have hpush := + stepPlus_trans (PUSH_lev (k + 1) L' o (P + j) l hlP) (inner1 k L' o (lev (P + j + 2) l)) + apply safe_prog _ _ (N' + 1) hpush + rw [show N' + 1 - 1 = N' by omega] + apply STK k N' (fun B hB => ih B (by omega)) 3 0 L' o L' (lev (P + j + 2) l) + ⟨by omega, fun hE => by omega⟩ (Or.inr (by rw [cap0])) (by omega) ho + intro n1 r1 L1 v1 hJ1 hB1 hr1 hv1 hS1 + apply ih (N' - k) (by omega) (P + j + 2) l n1 r1 L1 v1 + (okL_ge (P + j + 2) l (by omega)) hr1 hv1 (Or.inl hJ1) + intro n3 r3 L3 v3 hP3 + rw [show P + j + 2 + n3 = P + (j + 2 + n3) by omega] + apply safe_mono _ (N' + 1 - 1) (N' - k - 1) + (hk (j + 2 + n3) r3 L3 v3 (compose n r L v j k L' o n1 r1 L1 v1 n3 r3 L3 v3 hI hj hJ1 hB1 + hS1 hP3)) + (by omega) + +theorem Ist_Kx (n r L v : Nat) (h : Ist n r L v) : Kx n r L v := by + rcases h with ⟨hr, hv, hK, hM, h6⟩ + refine ⟨hK, ?_, h6⟩ + rintro ⟨rfl, rfl, rfl⟩ + apply hM + have := pow_pos L + simp only [Mv2, pow2_1] at * + omega + +theorem cycles (N : Nat) : ∀ n r L v, Ist n r L v → safe (RT default n (zone r L v)) N := by + refine @nat_strong_ind (fun N => + ∀ n r L v, Ist n r L v → safe (RT default n (zone r L v)) N) (fun N ih n r L v hI => ?_) N + have hK := Ist_Kx n r L v hI + rcases hI with ⟨hr, hv, hKs, hM, h6⟩ + apply U_all N 0 default n r L v (fun _ => rfl) hr hv (Or.inr hK) + intro n' r' L' v' ⟨hr', hv', _, hU2, _, hU4, hU5⟩ + cases N with + | zero => exact safe_RT0 default (0 + n') (zone r' L' v') + | succ N' => + rw [show N' + 1 - 1 = N' by omega, Nat.zero_add] + apply ih N' (by omega) n' r' L' v' + have := Mv_lt3 n r L v + have := Mv_lt3 n' r' L' v' + refine ⟨hr', hv', hU2 hK, by omega, ?_⟩ + rintro ⟨rfl, rfl, rfl, rfl⟩ + have := hU5 rfl rfl rfl + omega + + + +public section + +theorem is_not_halt : IsNotHalt target := by + intro cfg ⟨N, hrun⟩ + have hsafe := safe_ev (init []) (RT default 6 (zone 2 0 0)) N init_step (cycles N 6 2 0 0 init_I) + exact hsafe N (Nat.le_refl N) cfg hrun + +end + +end BusyBeaver.M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB diff --git a/BusyBeaver/BB6/NonHalt/M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD.lean b/BusyBeaver/BB6/NonHalt/M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD.lean new file mode 100644 index 00000000..47cd70c4 --- /dev/null +++ b/BusyBeaver/BB6/NonHalt/M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD.lean @@ -0,0 +1,46 @@ +/- +Copyright (c) 2026 Google LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +-/ +module + +import BusyBeaver.Basic +public import BusyBeaver.Bridge +import BusyBeaver.Calculi.Counter +import BusyBeaver.BB6.NonHalt.M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA + +open Mathlib Relation Nat Turing BusyBeaver SixState + +namespace BusyBeaver.M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD + +@[expose] public section + +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD" + +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB + +end + +def stateMap_m0221 : Fin 6 → Fin 6 + | 0 => 3 + | 1 => 4 + | 2 => 0 + | 3 => 1 + | 4 => 2 + | 5 => 5 + +public section + +theorem is_not_halt : IsNotHalt target := by + exact Counter.does_not_halt_of_conj_stem + (M_tgt := target) + (M_src := BusyBeaver.M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA.target) + (σ := stateMap_m0221) (f := false) + (c₁ := (default : ListBlank (Fin 2)) {{2}}> default) + (by decide) (Counter.init_reaches_conjCfg_default rfl) + BusyBeaver.M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA.is_not_halt_from_0221 + +end + +end BusyBeaver.M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD diff --git a/BusyBeaver/BB6/NonHalt/M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH.lean b/BusyBeaver/BB6/NonHalt/M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH.lean new file mode 100644 index 00000000..c6bc9e9f --- /dev/null +++ b/BusyBeaver/BB6/NonHalt/M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH.lean @@ -0,0 +1,5118 @@ +/- +Copyright (c) 2026 Google LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +-/ +module + +import BusyBeaver.Basic +public import BusyBeaver.Bridge +import BusyBeaver.Calculi.Counter +import BusyBeaver.Calculi.Longitudinal + +open Mathlib Relation Nat Turing BusyBeaver SixState + +namespace BusyBeaver.M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH + +@[expose] public section + +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH" + +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB + +end + +section + +set_option maxRecDepth 2000000 + +open BusyBeaver.Longitudinal + +local notation "A" => (0 : Fin 6) +local notation "B" => (1 : Fin 6) +local notation "C" => (2 : Fin 6) +local notation "D" => (3 : Fin 6) +local notation "E" => (4 : Fin 6) +local notation "F" => (5 : Fin 6) + +abbrev Cfg6 := Cfg (Fin 2) (Fin 6) +abbrev Side6 := ListBlank (Fin 2) +abbrev Sym2 := Fin 2 + +-- ============================================================================ +-- 1. Machine Definitions (`Sk1Class2_v3.v:TM6, TM5, TM7` / #372, #557, #638) +-- ============================================================================ + +def tm372 : Machine (Fin 2) (Fin 6) + | 0, 0 => some (some 1, Stmt.write 1 .right) + | 0, 1 => some (some 5, Stmt.write 0 .right) + | 1, 0 => some (some 2, Stmt.write 1 .right) + | 1, 1 => some (some 1, Stmt.write 0 .right) + | 2, 0 => some (some 3, Stmt.write 1 .left) + | 2, 1 => some (some 0, Stmt.write 0 .right) + | 3, 0 => some (some 4, Stmt.write 1 .left) + | 3, 1 => some (some 3, Stmt.write 0 .left) + | 4, 0 => some (some 1, Stmt.write 1 .right) + | 4, 1 => some (some 2, Stmt.write 0 .left) + | 5, 0 => some (some 0, Stmt.write 1 .left) + | 5, 1 => none + +theorem target_eq_tm372 : target = tm372 := by + funext q a; fin_cases q <;> fin_cases a <;> rfl + +-- ============================================================================ +-- 2. Symbolic Run-Length Simulator (`Sk1Class2_v3.v:29-208, 539-656`) +-- ============================================================================ + +def sneg (s : Sym2) : Sym2 := if s = 0 then 1 else 0 +def seqb (a b : Sym2) : Bool := a == b + +structure lf where + lc : Nat + lv : List Nat + deriving DecidableEq + +def dot : List Nat → List Nat → Nat + | v :: vs', x :: nu' => v * x + dot vs' nu' + | _, _ => 0 + +def ev (nu : List Nat) (a : lf) : Nat := a.lc + dot a.lv nu + +def zadd : List Nat → List Nat → List Nat + | x :: a', y :: b' => (x + y) :: zadd a' b' + | [], b => b + | a, [] => a + +def lf_add (a b : lf) : lf := ⟨a.lc + b.lc, zadd a.lv b.lv⟩ +def lf_S (a : lf) : lf := ⟨a.lc + 1, a.lv⟩ +def lf_one : lf := ⟨1, []⟩ +def cn (n : Nat) : lf := ⟨n, []⟩ + +def allz (vs : List Nat) : Bool := vs.all (fun v => v == 0) +def all4 (vs : List Nat) : Bool := vs.all (fun v => v % 4 == 0) +def is_zero (a : lf) : Bool := (a.lc == 0) && allz a.lv +def is_one (a : lf) : Bool := (a.lc == 1) && allz a.lv +def posb (a : lf) : Bool := !(a.lc == 0) + +inductive tl_ where + | T0 + | TV (k : Nat) + deriving DecidableEq + +abbrev run := Sym2 × lf +abbrev sd := List run × tl_ + +def alt (b : Sym2) : Nat → List Sym2 + | 0 => [] + | n + 1 => b :: alt (sneg b) n + +def ev_tl (sg : Nat → Side6) : tl_ → Side6 + | .T0 => default + | .TV k => sg k + +def ev_runs (nu : List Nat) : List run → Side6 → Side6 + | [], s => s + | (b, n) :: rs', s => alt b (ev nu n) +> ev_runs nu rs' s + +def ev_sd (nu : List Nat) (sg : Nat → Side6) (s : sd) : Side6 := + ev_runs nu s.1 (ev_tl sg s.2) + +def pop_runs : List run → tl_ → Option (Sym2 × sd) + | (b, n) :: rs', t => + if is_zero n then pop_runs rs' t + else if posb n then + some (b, ((if is_one n then rs' else (sneg b, ⟨n.lc - 1, n.lv⟩) :: rs'), t)) + else none + | [], .T0 => some (0, ([], .T0)) + | [], .TV _ => none + +def pop (s : sd) : Option (Sym2 × sd) := pop_runs s.1 s.2 + +def push (w : Sym2) : sd → sd + | ((b0, n0) :: rs, t) => + if seqb w b0 then ((w, lf_one) :: (b0, n0) :: rs, t) + else ((w, lf_S n0) :: rs, t) + | ([], t) => ([(w, lf_one)], t) + +def afterb (c : Sym2) (n : lf) : Sym2 := + if n.lc % 2 == 0 then c else sneg c + +def push_run (c : Sym2) (n : lf) : sd → sd + | ((b0, n0) :: rs, t) => + if seqb (afterb c n) b0 then ((c, lf_add n n0) :: rs, t) + else ((c, n) :: (b0, n0) :: rs, t) + | ([], t) => ([(c, n)], t) + +def cR_st (i : Nat) : Fin 6 := + match i % 4 with + | 0 => B | 1 => C | 2 => A | _ => B + +def cR_bt (i : Nat) : Sym2 := + match i % 4 with + | 0 => 0 | 1 => 1 | 2 => 0 | _ => 1 + +def cR_idx (q : Fin 6) (b : Sym2) : Option Nat := + match q, b with + | 1, 0 => some 0 | 2, 1 => some 1 | 0, 0 => some 2 | 1, 1 => some 3 + | _, _ => none + +def cL_st (i : Nat) : Fin 6 := + match i % 4 with + | 0 => D | 1 => D | 2 => E | _ => C + +def cL_bt (i : Nat) : Sym2 := + match i % 4 with + | 0 => 1 | 1 => 0 | 2 => 1 | _ => 0 + +def cL_idx (q : Fin 6) (b : Sym2) : Option Nat := + match q, b with + | 3, 1 => some 0 | 3, 0 => some 1 | 4, 1 => some 2 | 2, 0 => some 3 + | _, _ => none + +def lastb (c : Sym2) (n : lf) : Sym2 := + if n.lc % 2 == 0 then sneg c else c + +inductive cfg where + | Rc (q : Fin 6) (l r : sd) + | Lc (q : Fin 6) (l r : sd) + deriving DecidableEq + +def ev_cfg (nu : List Nat) (sg : Nat → Side6) : cfg → Cfg6 + | .Rc q l r => (ev_sd nu sg l) {{q}}> (ev_sd nu sg r) + | .Lc q l r => (ev_sd nu sg l) <{{q}} (ev_sd nu sg r) + +def single : cfg → Option cfg + | .Rc q l r => + match pop r with + | some (s, r') => + match tm372 q s with + | some (some q', ⟨w, .right⟩) => some (.Rc q' (push w l) r') + | some (some q', ⟨w, .left⟩) => some (.Lc q' l (push w r')) + | _ => none + | none => none + | .Lc q l r => + match pop l with + | some (s, l') => + match tm372 q s with + | some (some q', ⟨w, .right⟩) => some (.Rc q' (push w l') r) + | some (some q', ⟨w, .left⟩) => some (.Lc q' l' (push w r)) + | _ => none + | none => none + +def tag (o : Option cfg) : Option (cfg × Bool) := + o.map (fun c => (c, true)) + +def sstep (c : cfg) : Option (cfg × Bool) := + match c with + | .Rc q l ((b, n) :: rs, t) => + if is_zero n then some (.Rc q l (rs, t), false) + else match cR_idx q b with + | some i => + if all4 n.lv then + some (.Rc (cR_st (i + n.lc % 4)) (push_run (sneg (lastb b n)) n l) (rs, t), posb n) + else tag (single c) + | none => tag (single c) + | .Lc q ((b, n) :: ls, t) r => + if is_zero n then some (.Lc q (ls, t) r, false) + else match cL_idx q b with + | some i => + if all4 n.lv then + some (.Lc (cL_st (i + n.lc % 4)) (ls, t) (push_run (sneg (lastb b n)) n r), posb n) + else tag (single c) + | none => tag (single c) + | _ => tag (single c) + +def strip0 : List Nat → List Nat + | [] => [] + | v :: vs' => + match strip0 vs' with + | [] => if v == 0 then [] else [v] + | w => v :: w + +def listN_eqb : List Nat → List Nat → Bool + | [], [] => true + | x :: a', y :: b' => (x == y) && listN_eqb a' b' + | _, _ => false + +def lf_eqb (a b : lf) : Bool := + (a.lc == b.lc) && listN_eqb (strip0 a.lv) (strip0 b.lv) + +def runs_eqb : List run → List run → Bool + | [], [] => true + | (x, n) :: a', (y, m) :: b' => (seqb x y && lf_eqb n m) && runs_eqb a' b' + | _, _ => false + +def tl_eqb : tl_ → tl_ → Bool + | .T0, .T0 => true + | .TV i, .TV j => i == j + | _, _ => false + +def sd_eqb (a b : sd) : Bool := + runs_eqb a.1 b.1 && tl_eqb a.2 b.2 + +def cfg_eqb : cfg → cfg → Bool + | .Rc q l r, .Rc q' l' r' => (q == q') && sd_eqb l l' && sd_eqb r r' + | .Lc q l r, .Lc q' l' r' => (q == q') && sd_eqb l l' && sd_eqb r r' + | _, _ => false + +def reachAux (tgt : cfg) : Nat → cfg → Bool → Bool + | 0, _, _ => false + | fuel + 1, c, pr => + match sstep c with + | some (c', b) => + let pr' := pr || b + if cfg_eqb c' tgt then pr' + else reachAux tgt fuel c' pr' + | none => false + +def reach (fuel : Nat) (c tgt : cfg) : Bool := + reachAux tgt fuel c false + +def urun : Nat → cfg → cfg + | 0, c => c + | k + 1, c => + match sstep c with + | some (c', _) => urun k c' + | none => c + +-- ============================================================================ +-- 3. Layer 1 Soundness (`Sk1Class2_v3.v:213-654, 1380-1398`) +-- ============================================================================ + +theorem default_unfold : (default : Side6) = 0 >> default := + (ListBlank.cons_head_tail (default : Side6)).symm + +theorem step_right_R {q q' : Fin 6} {s w : Sym2} (l r : Side6) + (h : tm372 q s = some (some q', ⟨w, .right⟩)) : + (l {{q}}> (s >> r)) [tm372]⊢ ((w >> l) {{q'}}> r) := by + simp [step, h, Tape.write, Tape.move] + +theorem step_left_R {q q' : Fin 6} {s w : Sym2} (l r : Side6) + (h : tm372 q s = some (some q', ⟨w, .left⟩)) : + (l {{q}}> (s >> r)) [tm372]⊢ (l <{{q'}} (w >> r)) := by + simp [step, h, Tape.write, Tape.move] + +theorem step_right_L {q q' : Fin 6} {s w : Sym2} (l r : Side6) + (h : tm372 q s = some (some q', ⟨w, .right⟩)) : + ((s >> l) <{{q}} r) [tm372]⊢ ((w >> l) {{q'}}> r) := by + simp [step, h, Tape.write, Tape.move] + +theorem step_left_L {q q' : Fin 6} {s w : Sym2} (l r : Side6) + (h : tm372 q s = some (some q', ⟨w, .left⟩)) : + ((s >> l) <{{q}} r) [tm372]⊢ (l <{{q'}} (w >> r)) := by + simp [step, h, Tape.write, Tape.move] + +theorem step_to_stepPlus {c₁ c₂ : Cfg6} (h : c₁ [tm372]⊢ c₂) : c₁ [tm372]⊢⁺ c₂ := + ⟨1, Nat.one_pos, h⟩ + +theorem step_stepStar_to_stepPlus {c₁ c₂ c₃ : Cfg6} + (h₁ : c₁ [tm372]⊢ c₂) (h₂ : c₂ [tm372]⊢* c₃) : c₁ [tm372]⊢⁺ c₃ := + stepPlus_stepStar_trans (step_to_stepPlus h₁) h₂ + +theorem step_stepStar_to_stepStar {c₁ c₂ c₃ : Cfg6} + (h₁ : c₁ [tm372]⊢ c₂) (h₂ : c₂ [tm372]⊢* c₃) : c₁ [tm372]⊢* c₃ := + stepPlus_to_stepStar (step_stepStar_to_stepPlus h₁ h₂) + +theorem sneg_neq (a b : Sym2) (h : seqb a b = false) : b = sneg a := by + rcases a with ⟨_ | _ | a, ha⟩ <;> rcases b with ⟨_ | _ | b, hb⟩ <;> + first | omega | rfl | contradiction + +theorem seqb_eq (a b : Sym2) (h : seqb a b = true) : a = b := + beq_iff_eq.mp h + +theorem sneg_sneg (a : Sym2) : sneg (sneg a) = a := by + rcases a with ⟨_ | _ | a, ha⟩ <;> first | rfl | omega + +theorem dot_zadd (a b nu : List Nat) : dot (zadd a b) nu = dot a nu + dot b nu := by + induction a generalizing b nu with + | nil => simp [zadd, dot] + | cons x a ih => + cases b with + | nil => simp [zadd, dot] + | cons y b => + cases nu with + | nil => simp [zadd, dot] + | cons z nu => + simp only [zadd, dot, ih, Nat.add_mul] + omega + +theorem ev_add (nu : List Nat) (a b : lf) : ev nu (lf_add a b) = ev nu a + ev nu b := by + simp only [ev, lf_add, dot_zadd] + omega + +theorem ev_S (nu : List Nat) (a : lf) : ev nu (lf_S a) = ev nu a + 1 := by + simp only [ev, lf_S] + omega + +theorem allz_dot (vs nu : List Nat) (h : allz vs = true) : dot vs nu = 0 := by + induction vs generalizing nu with + | nil => cases nu <;> rfl + | cons v vs ih => + simp only [allz, List.all_cons, Bool.and_eq_true, beq_iff_eq] at h + rcases h with ⟨rfl, h2⟩ + cases nu with + | nil => rfl + | cons x nu => simp [dot, ih nu h2] + +theorem all4_dot (vs nu : List Nat) (h : all4 vs = true) : ∃ k, dot vs nu = 4 * k := by + induction vs generalizing nu with + | nil => + refine ⟨0, ?_⟩ + cases nu <;> rfl + | cons v vs ih => + simp only [all4, List.all_cons, Bool.and_eq_true, beq_iff_eq] at h + rcases h with ⟨h1, h2⟩ + cases nu with + | nil => exact ⟨0, rfl⟩ + | cons x nu => + rcases ih nu h2 with ⟨k, hk⟩ + refine ⟨(v / 4) * x + k, ?_⟩ + simp only [dot, hk] + have hv : v = 4 * (v / 4) := by omega + calc v * x + 4 * k = 4 * (v / 4) * x + 4 * k := by rw [← hv] + _ = 4 * (v / 4 * x + k) := by ring + +theorem ev_zero (nu : List Nat) (a : lf) (h : is_zero a = true) : ev nu a = 0 := by + simp only [is_zero, Bool.and_eq_true, beq_iff_eq] at h + simp [ev, h.1, allz_dot a.lv nu h.2] + +theorem ev_one (nu : List Nat) (a : lf) (h : is_one a = true) : ev nu a = 1 := by + simp only [is_one, Bool.and_eq_true, beq_iff_eq] at h + simp [ev, h.1, allz_dot a.lv nu h.2] + +theorem ev_pos (nu : List Nat) (a : lf) (h : posb a = true) : + ev nu a = ev nu ⟨a.lc - 1, a.lv⟩ + 1 := by + simp only [posb, Bool.not_eq_true', beq_eq_false_iff_ne] at h + simp only [ev] + omega + +theorem ev_mod4 (nu : List Nat) (a : lf) (h : all4 a.lv = true) : + ∃ k, ev nu a = a.lc + 4 * k := by + rcases all4_dot a.lv nu h with ⟨k, hk⟩ + exact ⟨k, by simp [ev, hk]⟩ + +theorem ev_runs_app (nu : List Nat) (rs1 rs2 : List run) (s : Side6) : + ev_runs nu (rs1 ++ rs2) s = ev_runs nu rs1 (ev_runs nu rs2 s) := by + induction rs1 with + | nil => rfl + | cons r rs1 ih => + rcases r with ⟨b, n⟩ + simp [ev_runs, ih] + +theorem pop_runs_spec (nu : List Nat) (sg : Nat → + Side6) (rs : List run) (t : tl_) (b : Sym2) (s' : sd) + (h : pop_runs rs t = some (b, s')) : + ev_runs nu rs (ev_tl sg t) = b >> ev_sd nu sg s' := by + induction rs generalizing b s' with + | nil => + cases t with + | T0 => + simp only [pop_runs, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + exact default_unfold + | TV k => simp [pop_runs] at h + | cons r rs ih => + rcases r with ⟨b0, n⟩ + simp only [pop_runs] at h + rcases hz : is_zero n + · simp only [hz, Bool.false_eq_true, ↓reduceIte] at h + rcases hp : posb n + · simp [hp] at h + · simp only [hp, ↓reduceIte, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + rcases ho : is_one n + · simp [ev_sd, ev_runs, ev_pos nu n hp, alt] + · simp [ev_sd, ev_runs, ev_one nu n ho, alt] + · simp only [hz, ↓reduceIte] at h + simp only [ev_runs, ev_zero nu n hz, alt, append_nil] + exact ih b s' h + +theorem pop_spec (nu : List Nat) (sg : Nat → Side6) (s : sd) (b : Sym2) (s' : sd) + (h : pop s = some (b, s')) : ev_sd nu sg s = b >> ev_sd nu sg s' := + pop_runs_spec nu sg s.1 s.2 b s' h + +theorem push_spec (nu : List Nat) (sg : Nat → Side6) (w : Sym2) (s : sd) : + ev_sd nu sg (push w s) = w >> ev_sd nu sg s := by + rcases s with ⟨_ | ⟨⟨b0, n0⟩, rs⟩, t⟩ + · rfl + · simp only [push] + rcases h : seqb w b0 + · simp only [Bool.false_eq_true, ↓reduceIte, ev_sd, ev_runs, ev_S, alt, append_cons, + ← sneg_neq w b0 h] + · rfl + +def afterb_nat (c : Sym2) (n : Nat) : Sym2 := + if n % 2 == 0 then c else sneg c + +theorem afterb_nat_S (c : Sym2) (m : Nat) : + afterb_nat c (m + 1) = afterb_nat (sneg c) m := by + simp only [afterb_nat] + rcases Nat.mod_two_eq_zero_or_one m with hm | hm + · have hm1 : (m + 1) % 2 = 1 := by omega + simp [hm, hm1] + · have hm1 : (m + 1) % 2 = 0 := by omega + simp [hm, hm1, sneg_sneg] + +theorem alt_add (c : Sym2) (m k : Nat) : + alt c (m + k) = alt c m ++ alt (afterb_nat c m) k := by + induction m generalizing c with + | zero => simp [alt, afterb_nat] + | succ m ih => + rw [Nat.succ_add, alt, alt, List.cons_append, ih, afterb_nat_S] + +theorem afterb_ev (nu : List Nat) (c : Sym2) (n : lf) (h : all4 n.lv = true) : + afterb c n = afterb_nat c (ev nu n) := by + rcases ev_mod4 nu n h with ⟨k, hk⟩ + simp only [afterb, afterb_nat, hk] + have hmod : (n.lc + 4 * k) % 2 = n.lc % 2 := by omega + rw [hmod] + +theorem push_run_spec (nu : List Nat) (sg : Nat → Side6) (c : Sym2) (n : lf) (s : sd) + (h4 : all4 n.lv = true) : + ev_sd nu sg (push_run c n s) = alt c (ev nu n) +> ev_sd nu sg s := by + rcases s with ⟨_ | ⟨⟨b0, n0⟩, rs⟩, t⟩ + · rfl + · simp only [push_run] + rcases h : seqb (afterb c n) b0 + · rfl + · simp only [↓reduceIte, ev_sd, ev_runs, ev_add, alt_add, append_assoc] + rw [← afterb_ev nu c n h4, seqb_eq _ _ h] + +def lastb_nat (c : Sym2) (m : Nat) : Sym2 := + if m % 2 == 0 then sneg c else c + +theorem lastb_ev (nu : List Nat) (c : Sym2) (n : lf) (h : all4 n.lv = true) : + lastb c n = lastb_nat c (ev nu n) := by + rcases ev_mod4 nu n h with ⟨k, hk⟩ + simp only [lastb, lastb_nat, hk] + have hmod : (n.lc + 4 * k) % 2 = n.lc % 2 := by omega + rw [hmod] + +theorem rev_alt (b : Sym2) (m : Nat) (l : Side6) : + alt (sneg (lastb_nat b (m + 1))) (m + 1) +> l = + alt (sneg (lastb_nat (sneg b) m)) m +> (sneg b >> l) := by + rw [alt_add, append_assoc] + simp only [alt, append_cons, append_nil, lastb_nat, afterb_nat] + rcases Nat.mod_two_eq_zero_or_one m with hm | hm + · have hm1 : (m + 1) % 2 = 1 := by omega + simp [hm, hm1, sneg_sneg] + · have hm1 : (m + 1) % 2 = 0 := by omega + simp [hm, hm1, sneg_sneg] + +theorem cR_cases (i : Nat) : + (i % 4 = 0 ∧ (i + 1) % 4 = 1) ∨ + (i % 4 = 1 ∧ (i + 1) % 4 = 2) ∨ + (i % 4 = 2 ∧ (i + 1) % 4 = 3) ∨ + (i % 4 = 3 ∧ (i + 1) % 4 = 0) := by + omega + +theorem cR_tm (i : Nat) : + tm372 (cR_st i) (cR_bt i) = some (some (cR_st (i + 1)), ⟨sneg (cR_bt i), .right⟩) := by + unfold cR_st cR_bt + rcases cR_cases i with ⟨h1, h2⟩ | ⟨h1, h2⟩ | ⟨h1, h2⟩ | ⟨h1, h2⟩ <;> rw [h1, h2] <;> rfl + +theorem cR_bt_S (i : Nat) : cR_bt (i + 1) = sneg (cR_bt i) := by + unfold cR_bt + rcases cR_cases i with ⟨h1, h2⟩ | ⟨h1, h2⟩ | ⟨h1, h2⟩ | ⟨h1, h2⟩ <;> rw [h1, h2] <;> rfl + +theorem cL_tm (i : Nat) : + tm372 (cL_st i) (cL_bt i) = some (some (cL_st (i + 1)), ⟨sneg (cL_bt i), .left⟩) := by + unfold cL_st cL_bt + rcases cR_cases i with ⟨h1, h2⟩ | ⟨h1, h2⟩ | ⟨h1, h2⟩ | ⟨h1, h2⟩ <;> rw [h1, h2] <;> rfl + +theorem cL_bt_S (i : Nat) : cL_bt (i + 1) = sneg (cL_bt i) := by + unfold cL_bt + rcases cR_cases i with ⟨h1, h2⟩ | ⟨h1, h2⟩ | ⟨h1, h2⟩ | ⟨h1, h2⟩ <;> rw [h1, h2] <;> rfl + +theorem accR_step (i : Nat) (l X : Side6) : + (l {{cR_st i}}> (cR_bt i >> X)) [tm372]⊢ ((sneg (cR_bt i) >> l) {{cR_st (i + 1)}}> X) := + step_right_R l X (cR_tm i) + +theorem accL_step (i : Nat) (r X : Side6) : + ((cL_bt i >> X) <{{cL_st i}} r) [tm372]⊢ (X <{{cL_st (i + 1)}} (sneg (cL_bt i) >> r)) := + step_left_L X r (cL_tm i) + +theorem accR (m : Nat) (i : Nat) (l r : Side6) : + (l {{cR_st i}}> (alt (cR_bt i) m +> r)) [tm372]⊢* + ((alt (sneg (lastb_nat (cR_bt i) m)) m +> l) {{cR_st (i + m)}}> r) := by + induction m generalizing i l r with + | zero => + rw [Nat.add_zero] + exact stepStar_refl tm372 _ + | succ m ih => + have hadd : i + (m + 1) = i + 1 + m := by omega + rw [rev_alt, hadd] + refine step_stepStar_to_stepStar (accR_step i l (alt (sneg (cR_bt i)) m +> r)) ?_ + have h := ih (i + 1) (sneg (cR_bt i) >> l) r + rwa [cR_bt_S] at h + +theorem accR_S (m i : Nat) (l r : Side6) : + (l {{cR_st i}}> (alt (cR_bt i) (m + 1) +> r)) [tm372]⊢⁺ + ((alt (sneg (lastb_nat (cR_bt i) (m + 1))) (m + 1) +> l) {{cR_st (i + (m + 1))}}> r) := by + have hadd : i + (m + 1) = i + 1 + m := by omega + rw [rev_alt, hadd] + refine step_stepStar_to_stepPlus (accR_step i l (alt (sneg (cR_bt i)) m +> r)) ?_ + have h := accR m (i + 1) (sneg (cR_bt i) >> l) r + rwa [cR_bt_S] at h + +theorem accL (m : Nat) (i : Nat) (l r : Side6) : + ((alt (cL_bt i) m +> l) <{{cL_st i}} r) [tm372]⊢* + (l <{{cL_st (i + m)}} (alt (sneg (lastb_nat (cL_bt i) m)) m +> r)) := by + induction m generalizing i l r with + | zero => + rw [Nat.add_zero] + exact stepStar_refl tm372 _ + | succ m ih => + have hadd : i + (m + 1) = i + 1 + m := by omega + rw [rev_alt, hadd] + refine step_stepStar_to_stepStar (accL_step i r (alt (sneg (cL_bt i)) m +> l)) ?_ + have h := ih (i + 1) l (sneg (cL_bt i) >> r) + rwa [cL_bt_S] at h + +theorem accL_S (m i : Nat) (l r : Side6) : + ((alt (cL_bt i) (m + 1) +> l) <{{cL_st i}} r) [tm372]⊢⁺ + (l <{{cL_st (i + (m + 1))}} (alt (sneg (lastb_nat (cL_bt i) (m + 1))) (m + 1) +> r)) := by + have hadd : i + (m + 1) = i + 1 + m := by omega + rw [rev_alt, hadd] + refine step_stepStar_to_stepPlus (accL_step i r (alt (sneg (cL_bt i)) m +> l)) ?_ + have h := accL m (i + 1) l (sneg (cL_bt i) >> r) + rwa [cL_bt_S] at h + +theorem single_spec (nu : List Nat) (sg : Nat → Side6) {c c' : cfg} + (h : single c = some c') : (ev_cfg nu sg c) [tm372]⊢ (ev_cfg nu sg c') := by + cases c with + | Rc q l r => + simp only [single] at h + rcases hp : pop r with _ | ⟨s, r'⟩ + · simp [hp] at h + · simp only [hp] at h + have hr := pop_spec nu sg r s r' hp + rcases ht : tm372 q s with _ | ⟨_ | q', ⟨w, _ | _⟩⟩ <;> simp only [ht] at h + · contradiction + · contradiction + · contradiction + · simp only [Option.some.injEq] at h + subst h + simp only [ev_cfg, hr, push_spec] + exact step_left_R _ _ ht + · simp only [Option.some.injEq] at h + subst h + simp only [ev_cfg, hr, push_spec] + exact step_right_R _ _ ht + | Lc q l r => + simp only [single] at h + rcases hp : pop l with _ | ⟨s, l'⟩ + · simp [hp] at h + · simp only [hp] at h + have hl := pop_spec nu sg l s l' hp + rcases ht : tm372 q s with _ | ⟨_ | q', ⟨w, _ | _⟩⟩ <;> simp only [ht] at h + · contradiction + · contradiction + · contradiction + · simp only [Option.some.injEq] at h + subst h + simp only [ev_cfg, hl, push_spec] + exact step_left_L _ _ ht + · simp only [Option.some.injEq] at h + subst h + simp only [ev_cfg, hl, push_spec] + exact step_right_L _ _ ht + +def Rel (b : Bool) (c c' : Cfg6) : Prop := + if b then (c [tm372]⊢⁺ c') else (c [tm372]⊢* c') + +theorem Rel_trans (b1 b2 : Bool) {c c' c'' : Cfg6} + (h1 : Rel b1 c c') (h2 : Rel b2 c' c'') : Rel (b1 || b2) c c'' := by + cases b1 <;> cases b2 <;> simp only [Rel, Bool.or_false, Bool.or_true, ↓reduceIte, + Bool.false_eq_true] at * + · exact stepStar_trans h1 h2 + · exact stepStar_stepPlus_trans h1 h2 + · exact stepPlus_stepStar_trans h1 h2 + · exact stepPlus_trans h1 h2 + +theorem tag_spec (nu : List Nat) (sg : Nat → Side6) {c c' : cfg} {b : Bool} + (h : tag (single c) = some (c', b)) : Rel b (ev_cfg nu sg c) (ev_cfg nu sg c') := by + simp only [tag, Option.map_eq_some_iff, Prod.mk.injEq] at h + rcases h with ⟨c1, hs, rfl, rfl⟩ + exact step_to_stepPlus (single_spec nu sg hs) + +theorem cR_idx_spec (q : Fin 6) (b : Sym2) (i : Nat) (h : cR_idx q b = some i) : + q = cR_st i ∧ b = cR_bt i := by + rcases q with ⟨_ | _ | _ | _ | _ | _ | q, hq⟩ <;> + rcases b with ⟨_ | _ | b, hb⟩ <;> + (try omega) <;> + dsimp [cR_idx] at h <;> + (try contradiction) <;> + (injection h with h; subst h; exact ⟨rfl, rfl⟩) + +theorem cL_idx_spec (q : Fin 6) (b : Sym2) (i : Nat) (h : cL_idx q b = some i) : + q = cL_st i ∧ b = cL_bt i := by + rcases q with ⟨_ | _ | _ | _ | _ | _ | q, hq⟩ <;> + rcases b with ⟨_ | _ | b, hb⟩ <;> + (try omega) <;> + dsimp [cL_idx] at h <;> + (try contradiction) <;> + (injection h with h; subst h; exact ⟨rfl, rfl⟩) + +theorem cR_st_mod (i k : Nat) : cR_st (i + k % 4) = cR_st (i + k) := by + unfold cR_st + have h : (i + k % 4) % 4 = (i + k) % 4 := by omega + rw [h] + +theorem cL_st_mod (i k : Nat) : cL_st (i + k % 4) = cL_st (i + k) := by + unfold cL_st + have h : (i + k % 4) % 4 = (i + k) % 4 := by omega + rw [h] + +theorem cR_st_add4 (i a k : Nat) : cR_st (i + (a + 4 * k)) = cR_st (i + a) := by + unfold cR_st + have h : (i + (a + 4 * k)) % 4 = (i + a) % 4 := by omega + rw [h] + +theorem cL_st_add4 (i a k : Nat) : cL_st (i + (a + 4 * k)) = cL_st (i + a) := by + unfold cL_st + have h : (i + (a + 4 * k)) % 4 = (i + a) % 4 := by omega + rw [h] + +theorem sstep_spec (nu : List Nat) (sg : Nat → Side6) {c c' : cfg} {b : Bool} + (h : sstep c = some (c', b)) : Rel b (ev_cfg nu sg c) (ev_cfg nu sg c') := by + rcases c with ⟨q, l, ⟨_ | ⟨⟨b0, n⟩, rs⟩, t⟩⟩ | ⟨q, ⟨_ | ⟨⟨b0, n⟩, ls⟩, t⟩, r⟩ + · exact tag_spec nu sg h + · simp only [sstep] at h + rcases hz : is_zero n + · simp only [hz, Bool.false_eq_true, ↓reduceIte] at h + rcases hi : cR_idx q b0 with _ | i + · simp only [hi] at h + exact tag_spec nu sg h + · simp only [hi] at h + rcases h4 : all4 n.lv + · simp only [h4, Bool.false_eq_true, ↓reduceIte] at h + exact tag_spec nu sg h + · simp only [h4, ↓reduceIte, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + rcases cR_idx_spec q b0 i hi with ⟨rfl, rfl⟩ + simp only [ev_cfg, push_run_spec nu sg _ n l h4, lastb_ev nu _ n h4, cR_st_mod] + change Rel (posb n) (ev_sd nu sg l {{cR_st i}}> (alt (cR_bt i) (ev nu n) +> + ev_sd nu sg (rs, t))) _ + rcases ev_mod4 nu n h4 with ⟨k, hk⟩ + have hst : cR_st (i + n.lc) = cR_st (i + ev nu n) := by + rw [hk, cR_st_add4] + rw [hst] + rcases hpos : posb n + · simp only [Rel, Bool.false_eq_true, ↓reduceIte] + exact accR (ev nu n) i _ _ + · simp only [Rel, ↓reduceIte] + simp only [posb, Bool.not_eq_true', beq_eq_false_iff_ne] at hpos + have hev : ∃ m, ev nu n = m + 1 := ⟨ev nu n - 1, by omega⟩ + rcases hev with ⟨m, hm⟩ + rw [hm] + exact accR_S m i _ _ + · simp only [hz, ↓reduceIte, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + simp only [Rel, Bool.false_eq_true, ↓reduceIte, ev_cfg, ev_sd, ev_runs, ev_zero nu n hz, alt, + append_nil] + exact stepStar_refl tm372 _ + · exact tag_spec nu sg h + · simp only [sstep] at h + rcases hz : is_zero n + · simp only [hz, Bool.false_eq_true, ↓reduceIte] at h + rcases hi : cL_idx q b0 with _ | i + · simp only [hi] at h + exact tag_spec nu sg h + · simp only [hi] at h + rcases h4 : all4 n.lv + · simp only [h4, Bool.false_eq_true, ↓reduceIte] at h + exact tag_spec nu sg h + · simp only [h4, ↓reduceIte, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + rcases cL_idx_spec q b0 i hi with ⟨rfl, rfl⟩ + simp only [ev_cfg, push_run_spec nu sg _ n r h4, lastb_ev nu _ n h4, cL_st_mod] + change Rel (posb n) ((alt (cL_bt i) (ev nu n) +> ev_sd nu sg (ls, + t)) <{{cL_st i}} ev_sd nu sg r) _ + rcases ev_mod4 nu n h4 with ⟨k, hk⟩ + have hst : cL_st (i + n.lc) = cL_st (i + ev nu n) := by + rw [hk, cL_st_add4] + rw [hst] + rcases hpos : posb n + · simp only [Rel, Bool.false_eq_true, ↓reduceIte] + exact accL (ev nu n) i _ _ + · simp only [Rel, ↓reduceIte] + simp only [posb, Bool.not_eq_true', beq_eq_false_iff_ne] at hpos + have hev : ∃ m, ev nu n = m + 1 := ⟨ev nu n - 1, by omega⟩ + rcases hev with ⟨m, hm⟩ + rw [hm] + exact accL_S m i _ _ + · simp only [hz, ↓reduceIte, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + simp only [Rel, Bool.false_eq_true, ↓reduceIte, ev_cfg, ev_sd, ev_runs, ev_zero nu n hz, alt, + append_nil] + exact stepStar_refl tm372 _ + +theorem dot_strip0 (vs nu : List Nat) : dot (strip0 vs) nu = dot vs nu := by + induction vs generalizing nu with + | nil => rfl + | cons v vs ih => + simp only [strip0] + rcases hs : strip0 vs with _ | ⟨w, ws⟩ + · split_ifs with hv + · simp only [beq_iff_eq] at hv + subst hv + cases nu with + | nil => rfl + | cons x nu => + simp only [dot, Nat.zero_mul, Nat.zero_add, ← ih nu, hs] + · cases nu with + | nil => rfl + | cons x nu => + simp only [dot, ← ih nu, hs] + · cases nu with + | nil => rfl + | cons x nu => + simp only [dot, ← ih nu, hs] + +theorem listN_eqb_eq {a b : List Nat} (h : listN_eqb a b = true) : a = b := by + induction a generalizing b with + | nil => + cases b with + | nil => rfl + | cons y b => contradiction + | cons x a ih => + cases b with + | nil => contradiction + | cons y b => + simp only [listN_eqb, Bool.and_eq_true, beq_iff_eq] at h + rw [h.1, ih h.2] + +theorem lf_eqb_ev (nu : List Nat) {a b : lf} (h : lf_eqb a b = true) : ev nu a = ev nu b := by + simp only [lf_eqb, Bool.and_eq_true, beq_iff_eq] at h + have h2 := listN_eqb_eq h.2 + simp only [ev, h.1, ← dot_strip0 a.lv nu, ← dot_strip0 b.lv nu, h2] + +theorem runs_eqb_ev (nu : List Nat) {a b : List run} (s : Side6) (h : runs_eqb a b = true) : + ev_runs nu a s = ev_runs nu b s := by + induction a generalizing b with + | nil => + cases b with + | nil => rfl + | cons r b => contradiction + | cons r a ih => + rcases r with ⟨x, n⟩ + cases b with + | nil => contradiction + | cons r' b => + rcases r' with ⟨y, m⟩ + simp only [runs_eqb, Bool.and_eq_true] at h + rcases h with ⟨⟨h1, h2⟩, h3⟩ + rw [seqb_eq x y h1] + simp only [ev_runs, lf_eqb_ev nu h2, ih h3] + +theorem sd_eqb_ev (nu : List Nat) (sg : Nat → Side6) {a b : sd} (h : sd_eqb a b = true) : + ev_sd nu sg a = ev_sd nu sg b := by + rcases a with ⟨ra, ta⟩ + rcases b with ⟨rb, tb⟩ + simp only [sd_eqb, Bool.and_eq_true] at h + have htb : ta = tb := by + cases ta <;> cases tb <;> simp only [tl_eqb, beq_iff_eq] at h + · rfl + · exact absurd h.2 Bool.false_ne_true + · exact absurd h.2 Bool.false_ne_true + · rw [h.2] + subst htb + exact runs_eqb_ev nu _ h.1 + +theorem cfg_eqb_ev (nu : List Nat) (sg : Nat → Side6) {a b : cfg} (h : cfg_eqb a b = true) : + ev_cfg nu sg a = ev_cfg nu sg b := by + cases a <;> cases b <;> simp only [cfg_eqb, Bool.and_eq_true, + beq_iff_eq] at h <;> try contradiction + · rcases h with ⟨⟨rfl, h2⟩, h3⟩ + simp only [ev_cfg, sd_eqb_ev nu sg h2, sd_eqb_ev nu sg h3] + · rcases h with ⟨⟨rfl, h2⟩, h3⟩ + simp only [ev_cfg, sd_eqb_ev nu sg h2, sd_eqb_ev nu sg h3] + +theorem reachAux_spec (tgt : cfg) (fuel : Nat) (c : cfg) (pr : Bool) (nu : List Nat) (sg : Nat → + Side6) + {c0 : Cfg6} (hRel : Rel pr c0 (ev_cfg nu sg c)) + (h : reachAux tgt fuel c pr = true) : c0 [tm372]⊢⁺ (ev_cfg nu sg tgt) := by + induction fuel generalizing c pr with + | zero => contradiction + | succ fuel ih => + simp only [reachAux] at h + rcases hs : sstep c with _ | ⟨c', b⟩ + · simp [hs] at h + · simp only [hs] at h + have hStep := sstep_spec nu sg hs + have hRel' := Rel_trans pr b hRel hStep + split_ifs at h with heq + · rw [← cfg_eqb_ev nu sg heq] + rw [h] at hRel' + exact hRel' + · exact ih c' (pr || b) hRel' h + +theorem reach_spec {fuel : Nat} {c tgt : cfg} (h : reach fuel c tgt = true) + (nu : List Nat) (sg : Nat → Side6) : (ev_cfg nu sg c) [tm372]⊢⁺ (ev_cfg nu sg tgt) := + reachAux_spec tgt fuel c false nu sg (stepStar_refl tm372 _) h + +theorem sstep_ev (nu : List Nat) (sg : Nat → Side6) {c c' : cfg} {b : Bool} + (h : sstep c = some (c', b)) : (ev_cfg nu sg c) [tm372]⊢* (ev_cfg nu sg c') := by + have h1 := sstep_spec nu sg h + cases b + · exact h1 + · exact stepPlus_to_stepStar h1 + +theorem urun_spec (k : Nat) (c : cfg) (nu : List Nat) (sg : Nat → Side6) : + (ev_cfg nu sg c) [tm372]⊢* (ev_cfg nu sg (urun k c)) := by + induction k generalizing c with + | zero => exact stepStar_refl tm372 _ + | succ k ih => + simp only [urun] + rcases hs : sstep c with _ | ⟨c', b⟩ + · exact stepStar_refl tm372 _ + · exact stepStar_trans (sstep_ev nu sg hs) (ih c') + +abbrev rep {α : Type*} (x : α) (n : Nat) : List α := List.replicate n x + +theorem rep_add {α : Type*} (x : α) (n m : Nat) : rep x (n + m) = rep x n ++ rep x m := + List.replicate_add n m x + +theorem rep_app {α : Type*} (x : α) (n m : Nat) : rep x n ++ rep x m = rep x (n + m) := + (List.replicate_add n m x).symm + +theorem rep_snoc {α : Type*} (x : α) (n : Nat) (l : List α) : + rep x n ++ x :: l = rep x (n + 1) ++ l := by + induction n with + | zero => rfl + | succ n ih => + change x :: (rep x n ++ x :: l) = x :: (rep x (n + 1) ++ l) + rw [ih] + +theorem rep_app_cons {α : Type*} (x : α) (a b : Nat) (l : List α) : + rep x a ++ (rep x b ++ l) = rep x (a + b) ++ l := by + rw [← List.append_assoc, rep_app] + +-- ============================================================================ +-- 4. Chain Blocks & Left-Word Counter (`Sk1Class2_v3.v:662-812`) +-- ============================================================================ + +def mkruns (b : Sym2) : List lf → List run + | [] => [] + | n :: ns' => (b, n) :: mkruns (lastb b n) ns' + +def vt (c : Nat) : lf := ⟨c, [4, 0, 0, 0]⟩ +def vs (c : Nat) : lf := ⟨c, [0, 4, 0, 0]⟩ +def va (c : Nat) : lf := ⟨c, [0, 0, 4, 0]⟩ +def vl (c : Nat) : lf := ⟨c, [0, 0, 0, 4]⟩ + +inductive lab where + | U0 | U1 | U2 | W0 | W1 | D0 | D1 | D2 + deriving DecidableEq + +def lens : lab → List lf + | .U0 => [cn 3, vt 4, vs 4, va 1, vl 2] + | .U1 => [cn 3, vt 4, vs 4, va 2, vl 1] + | .U2 => [cn 3, vt 4, vs 4, va 3, vl 0] + | .W0 => [cn 3, vt 1, vs 6, va 4, vl 0] + | .W1 => [cn 3, vt 2, vs 5, va 4, vl 0] + | .D0 => [cn 3, vt 3, vs 4, va 4, vl 0] + | .D1 => [cn 2, vt 4, vs 4, va 4, vl 0] + | .D2 => [cn 1, vt 5, vs 4, va 4, vl 0] + +def blk (s : lab) : List run := mkruns 0 (lens s) + +def rlens : lab → List lf + | .D0 => [vl 0, va 4, vs 4, vt 3, cn 3] + | _ => [vl 0, va 3, vs 4, vt 4, cn 3] + +def rblk (s : lab) : List run := mkruns 0 (rlens s) + +inductive lab1 where + | P0 | P1 | PD0 | PD1 | PD2 + deriving DecidableEq + +def lens1 : lab1 → List lf + | .P0 => [cn 3, cn 1, cn 3] + | .P1 => [cn 3, cn 2, cn 2] + | .PD0 => [cn 3, cn 3, cn 1] + | .PD1 => [cn 2, cn 4, cn 1] + | .PD2 => [cn 1, cn 5, cn 1] + +def blk1 (s : lab1) : List run := mkruns 0 (lens1 s) +def rblk1 : List run := mkruns 1 [cn 1, cn 3, cn 3] + +def stp (p : Bool) : Fin 6 := if p then A else B + +def turn : lab → Option (lab × Bool) + | .U0 => some (.U1, true) + | .U1 => some (.U2, true) + | .W0 => some (.W1, true) + | .W1 => some (.D0, true) + | .D1 => some (.D0, false) + | .D2 => some (.D1, false) + | _ => none + +def reset : lab → Bool → Option (lab × Bool) + | .U2, true => some (.U0, true) + | .U2, false => some (.W0, true) + | .D0, false => some (.D2, false) + | _, _ => none + +def turn1 : lab1 → Option (lab1 × Bool) + | .P0 => some (.P1, true) + | .P1 => some (.PD0, true) + | .PD1 => some (.PD0, false) + | .PD2 => some (.PD1, false) + | .PD0 => none + +def sg2 (L R : Side6) : Nat → Side6 + | 0 => L + | _ => R + +theorem reach_LR (fuel : Nat) (q q' : Fin 6) (l l' : List run) (nu : List Nat) (L R : Side6) + (h : reach fuel (.Lc q (l, .TV 0) ([], .TV 1)) (.Rc q' (l', .TV 0) ([], .TV 1)) = true) : + ((ev_runs nu l L) <{{q}} R) [tm372]⊢⁺ ((ev_runs nu l' L) {{q'}}> R) := + reach_spec h nu (sg2 L R) + +theorem reach_LL (fuel : Nat) (q q' : Fin 6) (l r' : List run) (nu : List Nat) (L R : Side6) + (h : reach fuel (.Lc q (l, .TV 0) ([], .TV 1)) (.Lc q' ([], .TV 0) (r', .TV 1)) = true) : + ((ev_runs nu l L) <{{q}} R) [tm372]⊢⁺ (L <{{q'}} (ev_runs nu r' R)) := + reach_spec h nu (sg2 L R) + +theorem reach_RR (fuel : Nat) (q q' : Fin 6) (r l' : List run) (nu : List Nat) (L R : Side6) + (h : reach fuel (.Rc q ([], .TV 0) (r, .TV 1)) (.Rc q' (l', .TV 0) ([], .TV 1)) = true) : + (L {{q}}> (ev_runs nu r R)) [tm372]⊢⁺ ((ev_runs nu l' L) {{q'}}> R) := + reach_spec h nu (sg2 L R) + +theorem blk_turn_U0 : reach 100 (.Lc D (blk .U0, .TV 0) ([], .TV 1)) (.Rc A (blk .U1, .TV 0) ([], + .TV 1)) = true := by decide +kernel +theorem blk_turn_U1 : reach 100 (.Lc D (blk .U1, .TV 0) ([], .TV 1)) (.Rc A (blk .U2, .TV 0) ([], + .TV 1)) = true := by decide +kernel +theorem blk_turn_W0 : reach 100 (.Lc D (blk .W0, .TV 0) ([], .TV 1)) (.Rc A (blk .W1, .TV 0) ([], + .TV 1)) = true := by decide +kernel +theorem blk_turn_W1 : reach 100 (.Lc D (blk .W1, .TV 0) ([], .TV 1)) (.Rc A (blk .D0, .TV 0) ([], + .TV 1)) = true := by decide +kernel +theorem blk_turn_D1 : reach 100 (.Lc D (blk .D1, .TV 0) ([], .TV 1)) (.Rc B (blk .D0, .TV 0) ([], + .TV 1)) = true := by decide +kernel +theorem blk_turn_D2 : reach 100 (.Lc D (blk .D2, .TV 0) ([], .TV 1)) (.Rc B (blk .D1, .TV 0) ([], + .TV 1)) = true := by decide +kernel + +theorem blk_turn {s s' : lab} {p : Bool} (nu : List Nat) (L R : Side6) + (h : turn s = some (s', p)) : + ((ev_runs nu (blk s) L) <{{D}} R) [tm372]⊢⁺ ((ev_runs nu (blk s') L) {{stp p}}> R) := by + cases s <;> simp only [turn, Option.some.injEq, Prod.mk.injEq] at h <;> try contradiction + · rcases h with ⟨rfl, rfl⟩; exact reach_LR 100 D A _ _ nu L R blk_turn_U0 + · rcases h with ⟨rfl, rfl⟩; exact reach_LR 100 D A _ _ nu L R blk_turn_U1 + · rcases h with ⟨rfl, rfl⟩; exact reach_LR 100 D A _ _ nu L R blk_turn_W0 + · rcases h with ⟨rfl, rfl⟩; exact reach_LR 100 D A _ _ nu L R blk_turn_W1 + · rcases h with ⟨rfl, rfl⟩; exact reach_LR 100 D B _ _ nu L R blk_turn_D1 + · rcases h with ⟨rfl, rfl⟩; exact reach_LR 100 D B _ _ nu L R blk_turn_D2 + +theorem blk_pass_U2 : reach 100 (.Lc D (blk .U2, .TV 0) ([], .TV 1)) (.Lc D ([], .TV 0) (rblk .U2, + .TV 1)) = true := by decide +kernel +theorem blk_pass_D0 : reach 100 (.Lc D (blk .D0, .TV 0) ([], .TV 1)) (.Lc D ([], .TV 0) (rblk .D0, + .TV 1)) = true := by decide +kernel + +theorem blk_pass {s : lab} (nu : List Nat) (L R : Side6) (h : turn s = none) : + ((ev_runs nu (blk s) L) <{{D}} R) [tm372]⊢⁺ (L <{{D}} (ev_runs nu (rblk s) R)) := by + cases s <;> simp only [turn] at h <;> try contradiction + · exact reach_LL 100 D D _ _ nu L R blk_pass_U2 + · exact reach_LL 100 D D _ _ nu L R blk_pass_D0 + +theorem blk_reset_U2_t : reach 100 (.Rc A ([], .TV 0) (rblk .U2, .TV 1)) (.Rc A (blk .U0, + .TV 0) ([], .TV 1)) = true := by decide +kernel +theorem blk_reset_U2_f : reach 100 (.Rc B ([], .TV 0) (rblk .U2, .TV 1)) (.Rc A (blk .W0, + .TV 0) ([], .TV 1)) = true := by decide +kernel +theorem blk_reset_D0_f : reach 100 (.Rc B ([], .TV 0) (rblk .D0, .TV 1)) (.Rc B (blk .D2, + .TV 0) ([], .TV 1)) = true := by decide +kernel + +theorem blk_reset {s s' : lab} {p p' : Bool} (nu : List Nat) (L R : Side6) + (h : reset s p = some (s', p')) : + (L {{stp p}}> (ev_runs nu (rblk s) R)) [tm372]⊢⁺ ((ev_runs nu (blk s') L) {{stp p'}}> R) := by + cases s <;> cases p <;> simp only [reset, Option.some.injEq, + Prod.mk.injEq] at h <;> try contradiction + · rcases h with ⟨rfl, rfl⟩; exact reach_RR 100 B A _ _ nu L R blk_reset_U2_f + · rcases h with ⟨rfl, rfl⟩; exact reach_RR 100 A A _ _ nu L R blk_reset_U2_t + · rcases h with ⟨rfl, rfl⟩; exact reach_RR 100 B B _ _ nu L R blk_reset_D0_f + +theorem blk1_turn_P0 : reach 100 (.Lc D (blk1 .P0, .TV 0) ([], .TV 1)) (.Rc A (blk1 .P1, .TV 0) ([], + .TV 1)) = true := by decide +kernel +theorem blk1_turn_P1 : reach 100 (.Lc D (blk1 .P1, .TV 0) ([], .TV 1)) (.Rc A (blk1 .PD0, + .TV 0) ([], .TV 1)) = true := by decide +kernel +theorem blk1_turn_PD1 : reach 100 (.Lc D (blk1 .PD1, .TV 0) ([], .TV 1)) (.Rc B (blk1 .PD0, + .TV 0) ([], .TV 1)) = true := by decide +kernel +theorem blk1_turn_PD2 : reach 100 (.Lc D (blk1 .PD2, .TV 0) ([], .TV 1)) (.Rc B (blk1 .PD1, + .TV 0) ([], .TV 1)) = true := by decide +kernel + +theorem blk1_turn {s s' : lab1} {p : Bool} (L R : Side6) (h : turn1 s = some (s', p)) : + ((ev_runs [] (blk1 s) L) <{{D}} R) [tm372]⊢⁺ ((ev_runs [] (blk1 s') L) {{stp p}}> R) := by + cases s <;> simp only [turn1, Option.some.injEq, Prod.mk.injEq] at h <;> try contradiction + · rcases h with ⟨rfl, rfl⟩; exact reach_LR 100 D A _ _ [] L R blk1_turn_P0 + · rcases h with ⟨rfl, rfl⟩; exact reach_LR 100 D A _ _ [] L R blk1_turn_P1 + · rcases h with ⟨rfl, rfl⟩; exact reach_LR 100 D B _ _ [] L R blk1_turn_PD1 + · rcases h with ⟨rfl, rfl⟩; exact reach_LR 100 D B _ _ [] L R blk1_turn_PD2 + +theorem blk1_pass_ok : + reach 100 (.Lc D (blk1 .PD0, .TV 0) ([], .TV 1)) (.Lc E ([], .TV 0) (rblk1, .TV 1)) = true := by + decide +kernel + +theorem blk1_pass (L R : Side6) : + ((ev_runs [] (blk1 .PD0) L) <{{D}} R) [tm372]⊢⁺ (L <{{E}} (ev_runs [] rblk1 R)) := + reach_LL 100 D E _ _ [] L R blk1_pass_ok + +theorem blk1_back_ok : + reach 100 (.Rc B ([], .TV 0) (rblk1, .TV 1)) (.Rc B (blk1 .PD2, .TV 0) ([], .TV 1)) = true := by + decide +kernel + +theorem blk1_back (L R : Side6) : + (L {{B}}> (ev_runs [] rblk1 R)) [tm372]⊢⁺ ((ev_runs [] (blk1 .PD2) L) {{B}}> R) := + reach_RR 100 B B _ _ [] L R blk1_back_ok + +def dgr : Nat → List run + | 0 => [(0, cn 1), (0, cn 5)] + | 1 => [(0, cn 2), (1, cn 4)] + | _ => [(0, cn 3), (0, cn 3)] + +def lw (i : Nat) : List run := + if i < 81 then + [(1, cn 3), (1, + cn 4)] ++ dgr (i % 3) ++ dgr (i / 3 % 3) ++ dgr (i / 9 % 3) ++ dgr (i / 27 % 3) ++ [(0, + cn 2)] + else + [(0, cn 6), (1, cn 4)] ++ dgr 0 ++ dgr 0 ++ dgr 0 ++ dgr 0 ++ [(0, cn 2)] + +def LWs (i : Nat) : Side6 := ev_runs [] (lw i) default + +theorem reach_T0 (fuel : Nat) (q q' : Fin 6) (l l' : List run) (Y : Side6) + (h : reach fuel (.Lc q (l, .T0) ([], .TV 0)) (.Rc q' (l', .T0) ([], .TV 0)) = true) : + ((ev_runs [] l default) <{{q}} Y) [tm372]⊢⁺ ((ev_runs [] l' default) {{q'}}> Y) := + reach_spec h [] (fun _ => Y) + +def lw_ok (i : Nat) : Bool := + reach 300 (.Lc E (lw i, .T0) ([], .TV 0)) (.Rc B (lw (i + 1), .T0) ([], .TV 0)) + +theorem lw_all : (List.range 81).all lw_ok = true := by + decide +kernel + +theorem lw_ok_lt {i : Nat} (hi : i < 81) : lw_ok i = true := by + have h := List.all_eq_true.mp lw_all i (List.mem_range.mpr hi) + exact h + +theorem lw_ep {i : Nat} (Y : Side6) (hi : i < 81) : + (LWs i <{{E}} Y) [tm372]⊢⁺ (LWs (i + 1) {{B}}> Y) := + reach_T0 300 E B (lw i) (lw (i + 1)) Y (lw_ok_lt hi) + +-- ============================================================================ +-- 5. Chain Visits & Lemma T (`Sk1Class2_v3.v:818-1362`) +-- ============================================================================ + +def chs : List lab → List (List Nat) → Side6 → Side6 + | s :: ls', nu :: nus', L => ev_runs nu (blk s) (chs ls' nus' L) + | _, _, L => L + +def rchs : List lab → List (List Nat) → Side6 → Side6 + | s :: ls', nu :: nus', R => rchs ls' nus' (ev_runs nu (rblk s) R) + | _, _, R => R + +def visit3 : List lab → Option (List lab × Bool) + | [] => none + | s :: ls' => + match turn s with + | some (s', p) => some (s' :: ls', p) + | none => + match visit3 ls' with + | some (ls'', p') => + match reset s p' with + | some (s'', p'') => some (s'' :: ls'', p'') + | none => none + | none => none + +def cb : List lab → Bool → Option (List lab × Bool) + | [], p => some ([], p) + | s :: ls', p => + match cb ls' p with + | some (ls'', p') => + match reset s p' with + | some (s'', p'') => some (s'' :: ls'', p'') + | none => none + | none => none + +def fullb (s : lab) : Bool := (turn s).isNone + +theorem visit3_spec (ls : List lab) : ∀ (ls' : List lab) (p : Bool) (nus : List (List Nat)) (L R : + Side6), + visit3 ls = some (ls', p) → ls.length = nus.length → + ((chs ls nus L) <{{D}} R) [tm372]⊢⁺ ((chs ls' nus L) {{stp p}}> R) := by + induction ls with + | nil => intros; contradiction + | cons s ls ih => + intro ls' p nus L R h hl + cases nus with + | nil => contradiction + | cons nu nus => + simp only [List.length_cons, Nat.add_right_cancel_iff] at hl + simp only [visit3] at h + rcases ht : turn s with _ | ⟨s1, p1⟩ + · simp only [ht] at h + rcases hv : visit3 ls with _ | ⟨ls1, p1⟩ + · simp [hv] at h + · simp only [hv] at h + rcases hr : reset s p1 with _ | ⟨s2, p2⟩ + · simp [hr] at h + · simp only [hr, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + simp only [chs] + exact stepPlus_trans (blk_pass nu _ R ht) + (stepPlus_trans (ih ls1 p1 nus L _ hv hl) (blk_reset nu _ R hr)) + · simp only [ht, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + exact blk_turn nu _ R ht + +theorem pass_spec (ls : List lab) : ∀ (nus : List (List Nat)) (L R : Side6), + ls.all fullb = true → ls.length = nus.length → + ((chs ls nus L) <{{D}} R) [tm372]⊢* (L <{{D}} (rchs ls nus R)) := by + induction ls with + | nil => + intro nus L R _ hl + cases nus with + | nil => exact stepStar_refl tm372 _ + | cons _ _ => contradiction + | cons s ls ih => + intro nus L R h hl + cases nus with + | nil => contradiction + | cons nu nus => + simp only [List.length_cons, Nat.add_right_cancel_iff] at hl + simp only [List.all_cons, Bool.and_eq_true] at h + rcases h with ⟨h1, h2⟩ + have ht : turn s = none := Option.isNone_iff_eq_none.mp h1 + exact stepStar_trans (stepPlus_to_stepStar (blk_pass nu _ R ht)) (ih nus L _ h2 hl) + +theorem cb_spec (ls : List lab) : ∀ (p : Bool) (ls' : List lab) (p' : Bool) (nus : List (List Nat)) + (L R : Side6), + cb ls p = some (ls', p') → ls.length = nus.length → + (L {{stp p}}> (rchs ls nus R)) [tm372]⊢* ((chs ls' nus L) {{stp p'}}> R) := by + induction ls with + | nil => + intro p ls' p' nus L R h hl + cases nus with + | nil => + simp only [cb, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + exact stepStar_refl tm372 _ + | cons _ _ => contradiction + | cons s ls ih => + intro p ls' p' nus L R h hl + cases nus with + | nil => contradiction + | cons nu nus => + simp only [List.length_cons, Nat.add_right_cancel_iff] at hl + simp only [cb] at h + rcases hc : cb ls p with _ | ⟨ls1, p1⟩ + · simp [hc] at h + · simp only [hc] at h + rcases hr : reset s p1 with _ | ⟨s2, p2⟩ + · simp [hr] at h + · simp only [hr, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + exact stepStar_trans (ih p ls1 p1 nus L _ hc hl) + (stepPlus_to_stepStar (blk_reset nu _ R hr)) + +theorem visit3_len (ls : List lab) : ∀ (ls' : List lab) (p : Bool), + visit3 ls = some (ls', p) → ls'.length = ls.length := by + induction ls with + | nil => intros; contradiction + | cons s ls ih => + intro ls' p h + simp only [visit3] at h + rcases ht : turn s with _ | ⟨s1, p1⟩ + · simp only [ht] at h + rcases hv : visit3 ls with _ | ⟨ls1, p1⟩ + · simp [hv] at h + · simp only [hv] at h + rcases hr : reset s p1 with _ | ⟨s2, p2⟩ + · simp [hr] at h + · simp only [hr, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + simp [ih ls1 p1 hv] + · simp only [ht, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + rfl + +theorem cb_len (ls : List lab) : ∀ (p : Bool) (ls' : List lab) (p' : Bool), + cb ls p = some (ls', p') → ls'.length = ls.length := by + induction ls with + | nil => + intro p ls' p' h + simp only [cb, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + rfl + | cons s ls ih => + intro p ls' p' h + simp only [cb] at h + rcases hc : cb ls p with _ | ⟨ls1, p1⟩ + · simp [hc] at h + · simp only [hc] at h + rcases hr : reset s p1 with _ | ⟨s2, p2⟩ + · simp [hr] at h + · simp only [hr, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + simp [ih p ls1 p1 hc] + +abbrev vst := List lab × lab1 × Nat + +def vis : vst → Option (vst × Bool) + | (ls, b, i) => + match visit3 ls with + | some (ls', p) => some ((ls', b, i), p) + | none => + if ls.all fullb then + match turn1 b with + | some (b', p1) => + match cb ls p1 with + | some (ls', p) => some ((ls', b', i), p) + | none => none + | none => + if b == .PD0 && i < 80 then + match cb ls false with + | some (ls', p) => some ((ls', .PD2, i + 1), p) + | none => none + else none + else none + +def b1s (b : lab1) (X : Side6) : Side6 := ev_runs [] (blk1 b) X + +def Gc (st : vst) (nus : List (List Nat)) (R : Side6) : Cfg6 := + let (ls, b, i) := st + (chs ls nus (b1s b (LWs i))) <{{D}} R + +def Gx (st : vst) (nus : List (List Nat)) (p : Bool) (R : Side6) : Cfg6 := + let (ls, b, i) := st + (chs ls nus (b1s b (LWs i))) {{stp p}}> R + +def vlen (st : vst) : Nat := st.1.length + +theorem vis_spec {st st' : vst} {p : Bool} (nus : List (List Nat)) (R : Side6) + (h : vis st = some (st', p)) (hl : vlen st = nus.length) : + ((Gc st nus R) [tm372]⊢⁺ (Gx st' nus p R)) ∧ vlen st' = vlen st := by + rcases st with ⟨ls, b, i⟩ + simp only [vis, vlen] at h hl ⊢ + rcases hv : visit3 ls with _ | ⟨ls1, p1⟩ + · simp only [hv] at h + rcases hf : ls.all fullb + · simp [hf] at h + · simp only [hf, ↓reduceIte] at h + rcases ht : turn1 b with _ | ⟨b1, p1⟩ + · simp only [ht] at h + rcases hb : (b == .PD0 && decide (i < 80)) + · simp [hb] at h + · simp only [hb, ↓reduceIte] at h + simp only [Bool.and_eq_true, beq_iff_eq, decide_eq_true_eq] at hb + rcases hb with ⟨rfl, hi⟩ + rcases hc : cb ls false with _ | ⟨ls1, p2⟩ + · simp [hc] at h + · simp only [hc, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + refine ⟨?_, cb_len ls false ls1 _ hc⟩ + have hpass := pass_spec ls nus (b1s .PD0 (LWs i)) R hf hl + have h1 := blk1_pass (LWs i) (rchs ls nus R) + have h2 := lw_ep (ev_runs [] rblk1 (rchs ls nus R)) (by omega : i < 81) + have h3 := blk1_back (LWs (i + 1)) (rchs ls nus R) + have h4 := cb_spec ls false ls1 _ nus (b1s .PD2 (LWs (i + 1))) R hc hl + exact stepStar_stepPlus_trans hpass + (stepPlus_trans h1 (stepPlus_trans h2 (stepPlus_stepStar_trans h3 h4))) + · simp only [ht] at h + rcases hc : cb ls p1 with _ | ⟨ls1, p2⟩ + · simp [hc] at h + · simp only [hc, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + refine ⟨?_, cb_len ls p1 ls1 _ hc⟩ + have hpass := pass_spec ls nus (b1s b (LWs i)) R hf hl + have h1 := blk1_turn (LWs i) (rchs ls nus R) ht + have h2 := cb_spec ls p1 ls1 _ nus (b1s b1 (LWs i)) R hc hl + exact stepStar_stepPlus_trans hpass (stepPlus_stepStar_trans h1 h2) + · simp only [hv, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + exact ⟨visit3_spec ls ls1 _ nus _ R hv hl, visit3_len ls ls1 _ hv⟩ + +def Ep (p : Bool) (R R' : Side6) : Prop := + ∀ l, (l {{stp p}}> R) [tm372]⊢* (l <{{D}} R') + +def EpSeq : List Bool → Side6 → Side6 → Prop + | [], R, R' => R = R' + | p :: ps', R, R' => ∃ R1, Ep p R R1 ∧ EpSeq ps' R1 R' + +def runv : Nat → vst → Option (vst × List Bool) + | 0, st => some (st, []) + | n' + 1, st => + match vis st with + | some (st1, p) => + match runv n' st1 with + | some (st2, ps) => some (st2, p :: ps) + | none => none + | none => none + +theorem runv_spec (n : Nat) : ∀ (st st' : vst) (ps : List Bool) (nus : List (List Nat)) (R R' : + Side6), + runv n st = some (st', ps) → vlen st = nus.length → EpSeq ps R R' → + (Gc st nus R) [tm372]⊢* (Gc st' nus R') := by + induction n with + | zero => + intro st st' ps nus R R' h _ he + simp only [runv, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + simp only [EpSeq] at he + subst he + exact stepStar_refl tm372 _ + | succ n ih => + intro st st' ps nus R R' h hl he + simp only [runv] at h + rcases hv : vis st with _ | ⟨st1, p⟩ + · simp [hv] at h + · simp only [hv] at h + rcases hr : runv n st1 with _ | ⟨st2, ps2⟩ + · simp [hr] at h + · simp only [hr, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + rcases he with ⟨R1, he1, he2⟩ + rcases vis_spec nus R hv hl with ⟨h1, h2⟩ + have hGx : (Gx st1 nus p R) [tm372]⊢* (Gc st1 nus R1) := by + rcases st1 with ⟨ls1, b1, i1⟩ + exact he1 _ + exact stepStar_trans (stepPlus_to_stepStar h1) + (stepStar_trans hGx (ih st1 _ ps2 nus R1 R' hr (h2.trans hl) he2)) + +theorem runv_add (a : Nat) : ∀ (b : Nat) (st st1 : vst) (ps1 : List Bool) (st2 : vst) (ps2 : List + Bool), + runv a st = some (st1, ps1) → runv b st1 = some (st2, ps2) → + runv (a + b) st = some (st2, ps1 ++ ps2) := by + induction a with + | zero => + intro b st st1 ps1 st2 ps2 h1 h2 + simp only [runv, Option.some.injEq, Prod.mk.injEq] at h1 + rcases h1 with ⟨rfl, rfl⟩ + simpa using h2 + | succ a ih => + intro b st st1 ps1 st2 ps2 h1 h2 + rw [Nat.succ_add] + simp only [runv] at h1 ⊢ + rcases hv : vis st with _ | ⟨st0, p⟩ + · simp [hv] at h1 + · simp only [hv] at h1 ⊢ + rcases hr : runv a st0 with _ | ⟨st3, ps3⟩ + · simp [hr] at h1 + · simp only [hr, Option.some.injEq, Prod.mk.injEq] at h1 + rcases h1 with ⟨rfl, rfl⟩ + rw [ih b st0 _ ps3 st2 ps2 hr h2] + rfl + +theorem runv_one {st st' : vst} {p : Bool} (h : vis st = some (st', p)) : + runv 1 st = some (st', [p]) := by + simp [runv, h] + +theorem vis3 {ls ls' : List lab} {p : Bool} (b : lab1) (i : Nat) (h : visit3 ls = some (ls', p)) : + vis (ls, b, i) = some ((ls', b, i), p) := by + simp [vis, h] + +theorem pow3_pos (j : Nat) : 1 ≤ 3 ^ j := + Nat.one_le_pow j 3 (by omega) + +theorem visit3_U2 (j : Nat) {X X' : List lab} (h : visit3 X = some (X', true)) : + visit3 (rep .U2 j ++ X) = some (rep .U0 j ++ X', true) := by + induction j with + | zero => exact h + | succ j ih => + change visit3 (.U2 :: (rep .U2 j ++ X)) = some (.U0 :: (rep .U0 j ++ X'), true) + simp [visit3, turn, ih, reset] + +theorem cb_U2 (j : Nat) {X : List lab} {p : Bool} {X' : List lab} (h : cb X p = some (X', true)) : + cb (rep .U2 j ++ X) p = some (rep .U0 j ++ X', true) := by + induction j with + | zero => exact h + | succ j ih => + change cb (.U2 :: (rep .U2 j ++ X)) p = some (.U0 :: (rep .U0 j ++ X'), true) + simp [cb, ih, reset] + +theorem visit3_full (ls : List lab) (h : ls.all fullb = true) : visit3 ls = none := by + induction ls with + | nil => rfl + | cons s ls ih => + simp only [List.all_cons, Bool.and_eq_true] at h + have ht : turn s = none := Option.isNone_iff_eq_none.mp h.1 + simp [visit3, ht, ih h.2] + +theorem fullb_U2 (j : Nat) : (rep .U2 j).all fullb = true := by + induction j with + | zero => rfl + | succ j ih => simp [rep, List.replicate_succ, fullb, turn, ih] + +theorem fullb_D0 (j : Nat) : (rep .D0 j).all fullb = true := by + induction j with + | zero => rfl + | succ j ih => simp [rep, List.replicate_succ, fullb, turn, ih] + +theorem fullb_app {a b : List lab} (ha : a.all fullb = true) (hb : b.all fullb = true) : + (a ++ b).all fullb = true := by + simp [List.all_append, ha, hb] + +theorem CU (j : Nat) : ∀ (rest : List lab) (b : lab1) (i : Nat), + runv (3 ^ j - 1) (rep .U0 j ++ rest, b, i) = + some ((rep .U2 j ++ rest, b, i), rep true (3 ^ j - 1)) := by + induction j with + | zero => intros; rfl + | succ j ih => + intro rest b i + have hp := pow3_pos j + rw [← rep_snoc .U0 j rest, ← rep_snoc .U2 j rest] + have h1 := ih (.U0 :: rest) b i + have h2 : runv 1 (rep .U2 j ++ .U0 :: rest, b, i) = some ((rep .U0 j ++ .U1 :: rest, b, i), + rep true 1) := + runv_one (vis3 b i (visit3_U2 j rfl)) + have h3 := ih (.U1 :: rest) b i + have h4 : runv 1 (rep .U2 j ++ .U1 :: rest, b, i) = some ((rep .U0 j ++ .U2 :: rest, b, i), + rep true 1) := + runv_one (vis3 b i (visit3_U2 j rfl)) + have h5 := ih (.U2 :: rest) b i + have h45 := runv_add _ _ _ _ _ _ _ h4 h5 + have h35 := runv_add _ _ _ _ _ _ _ h3 h45 + have h25 := runv_add _ _ _ _ _ _ _ h2 h35 + have h := runv_add _ _ _ _ _ _ _ h1 h25 + rw [rep_app, rep_app, rep_app, rep_app] at h + have heq : 3 ^ (j + 1) - 1 = (3 ^ j - 1) + (1 + ((3 ^ j - 1) + (1 + (3 ^ j - 1)))) := by + rw [Nat.pow_succ]; omega + rwa [heq] + +theorem CW (j : Nat) (rest : List lab) (b : lab1) (i : Nat) : + runv (3 ^ (j + 1) - 1) (rep .U0 j ++ .W0 :: rest, b, i) = + some ((rep .U2 j ++ .D0 :: rest, b, i), rep true (3 ^ (j + 1) - 1)) := by + have hp := pow3_pos j + have h1 := CU j (.W0 :: rest) b i + have h2 : runv 1 (rep .U2 j ++ .W0 :: rest, b, i) = some ((rep .U0 j ++ .W1 :: rest, b, i), + rep true 1) := + runv_one (vis3 b i (visit3_U2 j rfl)) + have h3 := CU j (.W1 :: rest) b i + have h4 : runv 1 (rep .U2 j ++ .W1 :: rest, b, i) = some ((rep .U0 j ++ .D0 :: rest, b, i), + rep true 1) := + runv_one (vis3 b i (visit3_U2 j rfl)) + have h5 := CU j (.D0 :: rest) b i + have h45 := runv_add _ _ _ _ _ _ _ h4 h5 + have h35 := runv_add _ _ _ _ _ _ _ h3 h45 + have h25 := runv_add _ _ _ _ _ _ _ h2 h35 + have h := runv_add _ _ _ _ _ _ _ h1 h25 + rw [rep_app, rep_app, rep_app, rep_app] at h + have heq : 3 ^ (j + 1) - 1 = (3 ^ j - 1) + (1 + ((3 ^ j - 1) + (1 + (3 ^ j - 1)))) := by + rw [Nat.pow_succ]; omega + rwa [heq] + +def tc : Nat → Nat + | 0 => 0 + | 1 => 2 + | j' + 2 => 3 ^ (j' + 2) + tc (j' + 1) + +theorem tc_closed (j : Nat) : 2 * tc (j + 1) + 5 = 3 ^ (j + 2) := by + induction j with + | zero => rfl + | succ j ih => + change 2 * (3 ^ (j + 2) + tc (j + 1)) + 5 = 3 ^ (j + 2) * 3 + omega + +theorem S3 (j : Nat) : ∀ (d d' : lab) (rest : List lab) (b : lab1) (i : Nat), + turn d = some (d', false) → + runv (tc (j + 1) + 1) (rep .U0 j ++ .W0 :: d :: rest, b, i) = + some ((.D2 :: (rep .D1 j ++ d' :: rest), b, i), rep true (tc (j + 1)) ++ [false]) := by + induction j with + | zero => + intro d d' rest b i hd + have h1 := CW 0 (d :: rest) b i + have h2 : runv 1 (rep .U2 0 ++ .D0 :: d :: rest, b, i) = some ((.D2 :: d' :: rest, b, i), + [false]) := by + apply runv_one + apply vis3 + have ht0 : turn .D0 = none := rfl + simp only [rep, List.replicate_zero, List.nil_append, visit3, ht0, hd, reset] + exact runv_add _ _ _ _ _ _ _ h1 h2 + | succ j ih => + intro d d' rest b i hd + have hp := pow3_pos (j + 2) + have h1 := CW (j + 1) (d :: rest) b i + have h2 : runv 1 (rep .U2 (j + 1) ++ .D0 :: d :: rest, b, i) = + some ((rep .U0 j ++ .W0 :: .D2 :: d' :: rest, b, i), rep true 1) := by + apply runv_one + apply vis3 + rw [← rep_snoc] + refine visit3_U2 j ?_ + have ht0 : turn .D0 = none := rfl + have htu2 : turn .U2 = none := rfl + simp only [visit3, ht0, htu2, hd, reset] + have h3 := ih .D2 .D1 (d' :: rest) b i rfl + have h23 := runv_add _ _ _ _ _ _ _ h2 h3 + have h := runv_add _ _ _ _ _ _ _ h1 h23 + rw [rep_snoc, ← List.append_assoc, rep_app, ← List.append_assoc, rep_app] at h + change runv (3 ^ (j + 2) + tc (j + 1) + 1) _ = + some ((.D2 :: (rep .D1 (j + 1) ++ d' :: rest), b, i), + rep true (3 ^ (j + 2) + tc (j + 1)) ++ [false]) + have heq1 : 3 ^ (j + 2) + tc (j + 1) + 1 = (3 ^ (j + 2) - 1) + (1 + (tc (j + 1) + 1)) := by + omega + have heq2 : 3 ^ (j + 2) + tc (j + 1) = 3 ^ (j + 2) - 1 + 1 + tc (j + 1) := by omega + rw [heq1, heq2] + exact h + +def isD : lab → Bool + | .D0 | .D1 | .D2 => true + | _ => false + +def dv : lab → Nat + | .D1 => 1 + | .D0 => 2 + | _ => 0 + +def dval : List lab → Nat + | [] => 0 + | s :: ls' => dv s + 3 * dval ls' + +def dv1 : lab1 → Nat + | .PD1 => 1 + | .PD0 => 2 + | _ => 0 + +def isD1 : lab1 → Bool + | .PD0 | .PD1 | .PD2 => true + | _ => false + +theorem dval_lt (ls : List lab) (h : ls.all isD = true) : dval ls < 3 ^ ls.length := by + induction ls with + | nil => decide + | cons s ls ih => + simp only [List.all_cons, Bool.and_eq_true] at h + have hlt := ih h.2 + cases s <;> simp only [isD, dval, dv, List.length_cons, Nat.pow_succ, Bool.false_eq_true, + false_and, true_and] at h ⊢ <;> try contradiction + all_goals omega + +theorem dval_max (ls : List lab) (h : ls.all isD = true) (he : dval ls + 1 = 3 ^ ls.length) : + ls = rep .D0 ls.length := by + induction ls with + | nil => rfl + | cons s ls ih => + simp only [List.all_cons, Bool.and_eq_true] at h + have hlt := dval_lt ls h.2 + cases s <;> simp only [isD, dval, dv, List.length_cons, Nat.pow_succ, Bool.false_eq_true, + false_and, true_and] at h he ⊢ <;> try contradiction + · change .D0 :: ls = .D0 :: rep .D0 ls.length + congr 1 + exact ih h (by omega) + · omega + · omega + +theorem visit3_D (ls : List lab) (h : ls.all isD = true) (he : dval ls + 1 < 3 ^ ls.length) : + ∃ ls', visit3 ls = some (ls', false) ∧ ls'.all isD = true ∧ dval ls' = dval ls + 1 ∧ + ls'.length = ls.length := by + induction ls with + | nil => simp [dval] at he + | cons s ls ih => + simp only [List.all_cons, Bool.and_eq_true] at h + have hlt := dval_lt ls h.2 + cases s <;> simp only [isD, dval, dv, List.length_cons, Nat.pow_succ, Bool.false_eq_true, + false_and, true_and] at h he ⊢ <;> try contradiction + · rcases ih h (by omega) with ⟨ls', e1, e2, e3, e4⟩ + refine ⟨.D2 :: ls', ?_, ?_, ?_, ?_⟩ + · have ht0 : turn .D0 = none := rfl + simp [visit3, ht0, e1, reset] + · simp [isD, e2] + · simp only [dval, dv, e3]; omega + · simp [e4] + · refine ⟨.D0 :: ls, rfl, ?_, ?_, rfl⟩ + · simp [isD, h] + · simp only [dval, dv]; omega + · refine ⟨.D1 :: ls, rfl, ?_, ?_, rfl⟩ + · simp [isD, h] + · simp only [dval, dv]; omega + +theorem cb_D0 (j : Nat) : cb (rep .D0 j) false = some (rep .D2 j, false) := by + induction j with + | zero => rfl + | succ j ih => + change cb (.D0 :: rep .D0 j) false = some (.D2 :: rep .D2 j, false) + simp [cb, ih, reset] + +theorem isD_D2 (j : Nat) : (rep .D2 j).all isD = true := by + induction j with + | zero => rfl + | succ j ih => simp [rep, List.replicate_succ, isD, ih] + +theorem dval_D2 (j : Nat) : dval (rep .D2 j) = 0 := by + induction j with + | zero => rfl + | succ j ih => + change dv .D2 + 3 * dval (rep .D2 j) = 0 + simp [dv, ih] + +theorem dval_D1 (j : Nat) : 2 * dval (rep .D1 j) + 1 = 3 ^ j := by + induction j with + | zero => rfl + | succ j ih => + change 2 * (dv .D1 + 3 * dval (rep .D1 j)) + 1 = 3 ^ (j + 1) + rw [Nat.pow_succ] + simp only [dv] + omega + +theorem vis_b1 {ls : List lab} {b b' : lab1} {p1 : Bool} {ls' : List lab} {p : Bool} (i : Nat) + (h1 : ls.all fullb = true) (h2 : turn1 b = some (b', p1)) (h3 : cb ls p1 = some (ls', p)) : + vis (ls, b, i) = some ((ls', b', i), p) := by + simp [vis, visit3_full ls h1, h1, h2, h3] + +theorem vis_co {ls ls' : List lab} {p : Bool} {i : Nat} + (h1 : ls.all fullb = true) (h2 : i < 80) (h3 : cb ls false = some (ls', p)) : + vis (ls, .PD0, i) = some ((ls', .PD2, i + 1), p) := by + simp [vis, visit3_full ls h1, h1, turn1, h2, h3] + +theorem allD (n : Nat) : ∀ (ls : List lab) (b : lab1) (i : Nat), + ls.all isD = true → isD1 b = true → + dval ls + 3 ^ ls.length * dv1 b + n + 1 = 3 ^ (ls.length + 1) → + runv n (ls, b, i) = some ((rep .D0 ls.length, .PD0, i), rep false n) := by + induction n with + | zero => + intro ls b i h1 h2 he + have hl := dval_lt ls h1 + rw [Nat.pow_succ] at he + cases b <;> simp only [isD1, dv1] at h2 he <;> try contradiction + · rw [← dval_max ls h1 (by omega)] + rfl + · omega + · omega + | succ n ih => + intro ls b i h1 h2 he + have hl := dval_lt ls h1 + rw [Nat.pow_succ] at he + by_cases hlt : dval ls + 1 < 3 ^ ls.length + · rcases visit3_D ls h1 hlt with ⟨ls', e1, e2, e3, e4⟩ + simp only [runv, vis3 b i e1] + have hih := ih ls' b i e2 h2 (by rw [e3, e4, Nat.pow_succ]; omega) + rw [hih, e4] + rfl + · have hd : dval ls + 1 = 3 ^ ls.length := by omega + have hmax := dval_max ls h1 hd + set m := ls.length + cases b <;> simp only [isD1, dv1] at h2 he <;> try contradiction + · omega + · have hv : vis (ls, .PD1, i) = some ((rep .D2 m, .PD0, i), false) := by + rw [hmax] + exact vis_b1 i (fullb_D0 m) rfl (cb_D0 m) + simp only [runv, hv] + have hih := ih (rep .D2 m) .PD0 i (isD_D2 m) rfl + (by rw [dval_D2, List.length_replicate, Nat.pow_succ]; simp [dv1]; omega) + rw [hih, List.length_replicate] + rfl + · have hv : vis (ls, .PD2, i) = some ((rep .D2 m, .PD1, i), false) := by + rw [hmax] + exact vis_b1 i (fullb_D0 m) rfl (cb_D0 m) + simp only [runv, hv] + have hih := ih (rep .D2 m) .PD1 i (isD_D2 m) rfl + (by rw [dval_D2, List.length_replicate, Nat.pow_succ]; simp [dv1]; omega) + rw [hih, List.length_replicate] + rfl + +theorem cyc (m i : Nat) (hi : i < 80) : + runv (3 ^ (m + 1)) (rep .D0 m, .PD0, i) = + some ((rep .D0 m, .PD0, i + 1), rep false (3 ^ (m + 1))) := by + have hp := pow3_pos (m + 1) + have heq : 3 ^ (m + 1) = 1 + (3 ^ (m + 1) - 1) := by omega + rw [heq, rep_add] + have h1 := runv_one (vis_co (fullb_D0 m) hi (cb_D0 m)) + have hA := allD (3 ^ (m + 1) - 1) (rep .D2 m) .PD2 (i + 1) (isD_D2 m) rfl + rw [dval_D2, List.length_replicate] at hA + have h2 := hA (by simp [dv1]; omega) + exact runv_add _ _ _ _ _ _ _ h1 h2 + +theorem cycs (c : Nat) : ∀ (m i : Nat), i + c ≤ 80 → + runv (c * 3 ^ (m + 1)) (rep .D0 m, .PD0, i) = + some ((rep .D0 m, .PD0, i + c), rep false (c * 3 ^ (m + 1))) := by + induction c with + | zero => + intro m i _ + simp [runv] + | succ c ih => + intro m i hi + have hmul : (c + 1) * 3 ^ (m + 1) = 3 ^ (m + 1) + c * 3 ^ (m + 1) := by ring + rw [hmul, rep_add] + refine runv_add _ _ _ _ _ _ _ (cyc m i (by omega)) ?_ + have hadd : i + (c + 1) = (i + 1) + c := by omega + rw [hadd] + exact ih m (i + 1) (by omega) + +theorem odd_pow3 (j : Nat) : ∃ k, 3 ^ j = 2 * k + 1 := by + induction j with + | zero => exact ⟨0, rfl⟩ + | succ j ih => + rcases ih with ⟨k, hk⟩ + refine ⟨3 * k + 1, ?_⟩ + rw [Nat.pow_succ, hk] + ring + +theorem half9 (j : Nat) : 2 * ((9 * 3 ^ j + 1) / 2) = 9 * 3 ^ j + 1 := by + rcases odd_pow3 j with ⟨k, hk⟩ + rw [hk] + omega + +theorem interval (m : Nat) (hm : 2 ≤ m) : + ∃ T, 2 * T + 5 = 3 ^ (m + 2) ∧ + runv (81 * 3 ^ (m + 1) - 1) (rep .U0 m, .P0, 0) = + some ((rep .D0 m, .PD0, 80), rep true T ++ rep false (81 * 3 ^ (m + 1) - 1 - T)) := by + rcases m with _ | _ | m + · omega + · omega + · have hh := half9 (m + 1) + set y := 3 ^ (m + 1) + have hy : 1 ≤ y := pow3_pos (m + 1) + have e3 : 3 ^ (m + 2) = 3 * y := by change 3 ^ (m + 1) * 3 = 3 * y; ring + have e9 : 3 ^ (m + 3) = 9 * y := by change 3 ^ (m + 1) * 3 * 3 = 9 * y; ring + have etc := tc_closed m + rw [e3] at etc + have h1 : runv (3 ^ (m + 3) - 1) (rep .U0 (m + 2), .P0, 0) = + some ((rep .U2 (m + 2), .PD0, 0), rep true (3 ^ (m + 3) - 1)) := by + have a1 := CU (m + 2) [] .P0 0 + rw [List.append_nil, List.append_nil] at a1 + have a2 : runv 1 (rep .U2 (m + 2), .P0, 0) = some ((rep .U0 (m + 2), .P1, 0), rep true 1) := + by + refine runv_one (vis_b1 0 (fullb_U2 (m + 2)) rfl ?_) + have c := cb_U2 (m + 2) (X := []) (p := true) (X' := []) rfl + rwa [List.append_nil, List.append_nil] at c + have a3 := CU (m + 2) [] .P1 0 + rw [List.append_nil, List.append_nil] at a3 + have a4 : runv 1 (rep .U2 (m + 2), .P1, 0) = some ((rep .U0 (m + 2), .PD0, 0), rep true 1) := + by + refine runv_one (vis_b1 0 (fullb_U2 (m + 2)) rfl ?_) + have c := cb_U2 (m + 2) (X := []) (p := true) (X' := []) rfl + rwa [List.append_nil, List.append_nil] at c + have a5 := CU (m + 2) [] .PD0 0 + rw [List.append_nil, List.append_nil] at a5 + have a45 := runv_add _ _ _ _ _ _ _ a4 a5 + have a35 := runv_add _ _ _ _ _ _ _ a3 a45 + have a25 := runv_add _ _ _ _ _ _ _ a2 a35 + have a := runv_add _ _ _ _ _ _ _ a1 a25 + rw [rep_app, rep_app, rep_app, rep_app, e3] at a + rw [e9] + have heq : 9 * y - 1 = 3 * y - 1 + (1 + (3 * y - 1 + (1 + (3 * y - 1)))) := by omega + rwa [heq] + have h2 : runv 1 (rep .U2 (m + 2), .PD0, 0) = + some ((rep .U0 (m + 1) ++ [.W0], .PD2, 1), rep true 1) := by + refine runv_one (vis_co (fullb_U2 (m + 2)) (by omega) ?_) + have hrep : rep lab.U2 (m + 2) = rep lab.U2 (m + 1) ++ [lab.U2] := by + have h0 := (rep_snoc lab.U2 (m + 1) []).symm + rwa [List.append_nil] at h0 + rw [hrep] + exact cb_U2 (m + 1) rfl + have h3 := CW (m + 1) [] .PD2 1 + have h4 : runv 1 (rep .U2 (m + 1) ++ [.D0], .PD2, 1) = + some ((rep .U0 m ++ [.W0, .D2], .PD1, 1), rep true 1) := by + refine runv_one (vis_b1 1 (fullb_app (fullb_U2 (m + 1)) rfl) rfl ?_) + have hrep : rep lab.U2 (m + 1) ++ [lab.D0] = rep lab.U2 m ++ [lab.U2, lab.D0] := by + exact (rep_snoc lab.U2 m [lab.D0]).symm + rw [hrep] + exact cb_U2 m rfl + have h5 := S3 m .D2 .D1 [] .PD1 1 rfl + rw [rep_snoc, List.append_nil] at h5 + have h6 : runv ((9 * y + 1) / 2) (.D2 :: rep .D1 (m + 1), .PD1, 1) = + some ((rep .D0 (m + 2), .PD0, 1), rep false ((9 * y + 1) / 2)) := by + have ed := dval_D1 (m + 1) + have ha := allD ((9 * y + 1) / 2) (.D2 :: rep .D1 (m + 1)) .PD1 1 + (by simp [isD]) rfl + simp only [List.length_cons, List.length_replicate, dval, dv, dv1] at ha + apply ha + rw [e3, e9] + omega + have h7 := cycs 79 (m + 2) 1 (by omega) + rw [e9] at h7 + have h67 := runv_add _ _ _ _ _ _ _ h6 h7 + have h57 := runv_add _ _ _ _ _ _ _ h5 h67 + have h47 := runv_add _ _ _ _ _ _ _ h4 h57 + have h37 := runv_add _ _ _ _ _ _ _ h3 h47 + have h27 := runv_add _ _ _ _ _ _ _ h2 h37 + have h := runv_add _ _ _ _ _ _ _ h1 h27 + change _ = some (_, + rep true _ ++ (rep true 1 ++ (rep true _ ++ (rep true 1 ++ ((rep true (tc (m + 1)) ++ + rep false 1) ++ (rep false ((9 * y + 1) / 2) ++ rep false (79 * (9 * y)))))))) at h + rw [rep_app, List.append_assoc, rep_app_cons, rep_app_cons, rep_app_cons, rep_app_cons, + rep_app] at h + rw [e3, e9] at h + have e27 : 3 ^ (m + 4) = 27 * y := by change 3 ^ (m + 1) * 3 * 3 * 3 = 27 * y; ring + refine ⟨9 * y - 1 + 1 + (3 * y - 1) + 1 + tc (m + 1), ?_, ?_⟩ + · rw [e27]; omega + · rw [e9] + have heq1 : 81 * (9 * y) - 1 = + 9 * y - 1 + (1 + (3 * y - 1 + (1 + (tc (m + 1) + 1 + ((9 * y + 1) / 2 + 79 * (9 * + y)))))) := by omega + have heq2 : 81 * (9 * y) - 1 - (9 * y - 1 + 1 + (3 * y - 1) + 1 + tc (m + 1)) = + 1 + ((9 * y + 1) / 2 + 79 * (9 * y)) := by omega + rw [heq2, heq1] + exact h + +theorem interval_tm (m : Nat) (nus : List (List Nat)) (R R' : Side6) + (hm : 2 ≤ m) (hl : nus.length = m) + (he : ∀ T, 2 * T + 5 = 3 ^ (m + 2) → + EpSeq (rep true T ++ rep false (81 * 3 ^ (m + 1) - 1 - T)) R R') : + (Gc (rep .U0 m, .P0, 0) nus R) [tm372]⊢* (Gc (rep .D0 m, .PD0, 80) nus R') := by + rcases interval m hm with ⟨T, hT, hr⟩ + exact runv_spec _ _ _ _ nus R R' hr (by simp [vlen, hl]) (he T hT) + +theorem record_visit (m : Nat) (nus : List (List Nat)) (R : Side6) (hl : nus.length = m) : + (Gc (rep .D0 m, .PD0, 80) nus R) [tm372]⊢⁺ + ((chs (rep .D2 m) nus (b1s .PD2 (LWs 81))) {{B}}> R) := by + have hpass := pass_spec (rep .D0 m) nus (b1s .PD0 (LWs 80)) R (fullb_D0 m) (by simp [hl]) + have h1 := blk1_pass (LWs 80) (rchs (rep .D0 m) nus R) + have h2 := lw_ep (ev_runs [] rblk1 (rchs (rep .D0 m) nus R)) (by omega : 80 < 81) + have h3 := blk1_back (LWs 81) (rchs (rep .D0 m) nus R) + have h4 := + cb_spec (rep .D0 m) false (rep .D2 m) false nus (b1s .PD2 (LWs 81)) R (cb_D0 m) (by simp [hl]) + exact stepStar_stepPlus_trans hpass + (stepPlus_trans h1 (stepPlus_trans h2 (stepPlus_stepStar_trans h3 h4))) + +-- ============================================================================ +-- 6. Right-Region Executor & Regrouping (`Sk1Class2_v3.v:1400-1832`) +-- ============================================================================ + +def tgtD : cfg → Option (List run) + | .Lc 3 ([], .TV 0) (rr, .T0) => some rr + | _ => none + +theorem tgtD_spec {c : cfg} {rr : List run} (h : tgtD c = some rr) : + c = .Lc D ([], .TV 0) (rr, .T0) := by + unfold tgtD at h + split at h + · simp only [Option.some.injEq] at h + subst h + rfl + · contradiction + +def evR (nu : List Nat) (rr : List run) : Side6 := ev_runs nu rr default + +def ep_run (p : Bool) (rr : List run) : Option (List run) := + tgtD (urun 500 (.Rc (stp p) ([], .TV 0) (rr, .T0))) + +theorem ep_run_spec {p : Bool} {rr rr' : List run} (h : ep_run p rr = some rr') (nu : List Nat) : + Ep p (evR nu rr) (evR nu rr') := by + intro l + have u := urun_spec 500 (.Rc (stp p) ([], .TV 0) (rr, .T0)) nu (fun _ => l) + rw [tgtD_spec h] at u + exact u + +def eps : List Bool → List run → Option (List run) + | [], rr => some rr + | p :: ps', rr => + match ep_run p rr with + | some rr' => eps ps' rr' + | none => none + +theorem eps_spec (ps : List Bool) : ∀ {rr rr' : List run}, + eps ps rr = some rr' → ∀ (nu : List Nat), EpSeq ps (evR nu rr) (evR nu rr') := by + induction ps with + | nil => + intro rr rr' h nu + simp only [eps, Option.some.injEq] at h + subst h; rfl + | cons p ps ih => + intro rr rr' h nu + simp only [eps] at h + rcases he : ep_run p rr with _ | r1 + · simp [he] at h + · simp only [he] at h + exact ⟨evR nu r1, ep_run_spec he nu, ih h nu⟩ + +theorem EpSeq_app (a : List Bool) : ∀ (b : List Bool) (R R1 R2 : Side6), + EpSeq a R R1 → EpSeq b R1 R2 → EpSeq (a ++ b) R R2 := by + induction a with + | nil => + intro b R R1 R2 h1 h2 + simp only [EpSeq] at h1 + subst h1; exact h2 + | cons p a ih => + intro b R R1 R2 h1 h2 + rcases h1 with ⟨R3, h3, h4⟩ + exact ⟨R3, h3, ih b R3 R1 R2 h4 h2⟩ + +def evN (nu : List Nat) (a : lf) : Nat := a.lc + dot a.lv nu + +theorem dot_zadd2 (v : List Nat) : ∀ (a b : List Nat), dot v (zadd a b) = dot v a + dot v b := by + induction v with + | nil => intros; rfl + | cons x v ih => + intro a b + cases a with + | nil => simp [zadd, dot] + | cons y a => + cases b with + | nil => simp [zadd, dot] + | cons z b => + simp only [zadd, dot, ih, Nat.mul_add] + omega + +def vscale (k : Nat) (w : List Nat) : List Nat := w.map (k * ·) + +theorem dot_vscale (v : List Nat) : ∀ (k : Nat) (w : List Nat), dot v (vscale k w) = k * dot v w := + by + induction v with + | nil => intros; simp [dot] + | cons x v ih => + intro k w + cases w with + | nil => simp [vscale, dot] + | cons y w => + rw [vscale, List.map_cons, dot, dot, ← vscale, ih k w] + ring + +theorem ev_runs_dot (nu nu' : List Nat) (T : List run) (X : Side6) + (h : ∀ v, dot v nu = dot v nu') : ev_runs nu T X = ev_runs nu' T X := by + induction T with + | nil => rfl + | cons r T ih => + rcases r with ⟨b, a⟩ + simp only [ev_runs, ev, h, ih] + +def subst_lf (w : List Nat) (a : lf) : lf := ⟨a.lc + dot a.lv w, a.lv⟩ +def subst_runs (w : List Nat) (T : List run) : List run := T.map (fun r => (r.1, subst_lf w r.2)) + +theorem ev_runs_subst (nu w : List Nat) (T : List run) (X : Side6) : + ev_runs nu (subst_runs w T) X = ev_runs (zadd nu w) T X := by + induction T with + | nil => rfl + | cons r T ih => + rcases r with ⟨b, a⟩ + rw [subst_runs, List.map_cons, ← subst_runs, ev_runs, ev_runs, ih] + congr 1 + simp only [ev, subst_lf, dot_zadd2] + congr 1 + omega + +def lf_scale (k : Nat) (a : lf) : lf := ⟨k * a.lc, a.lv.map (k * ·)⟩ + +theorem dot_scale_l (vs : List Nat) : ∀ (k : Nat) (nu : List Nat), + dot (vs.map (k * ·)) nu = k * dot vs nu := by + induction vs with + | nil => intros; simp [dot] + | cons x vs ih => + intro k nu + cases nu with + | nil => simp [dot] + | cons y nu => + simp only [List.map_cons, dot, ih] + ring + +theorem evN_add (nu : List Nat) (a b : lf) : evN nu (lf_add a b) = evN nu a + evN nu b := + ev_add nu a b + +theorem evN_scale (nu : List Nat) (k : Nat) (a : lf) : evN nu (lf_scale k a) = k * evN nu a := by + simp only [evN, lf_scale, dot_scale_l] + ring + +def comp_aux : List Nat → List lf → lf + | v :: vs', s :: sg' => lf_add (lf_scale v s) (comp_aux vs' sg') + | _, _ => ⟨0, []⟩ + +def compose_lf (sg : List lf) (a : lf) : lf := lf_add ⟨a.lc, []⟩ (comp_aux a.lv sg) +def comp_runs (sg : List lf) (T : List run) : List run := T.map (fun r => (r.1, compose_lf sg r.2)) + +theorem evN_comp_aux (nu : List Nat) (vs : List Nat) : ∀ (sg : List lf), + evN nu (comp_aux vs sg) = dot vs (sg.map (evN nu)) := by + induction vs with + | nil => intro sg; cases sg <;> rfl + | cons v vs ih => + intro sg + cases sg with + | nil => rfl + | cons s sg => + simp only [comp_aux, List.map_cons, dot, evN_add, evN_scale, ih] + +theorem evN_compose (nu : List Nat) (sg : List lf) (a : lf) : + evN nu (compose_lf sg a) = evN (sg.map (evN nu)) a := by + rw [compose_lf, evN_add, evN_comp_aux] + simp [evN, dot] + +theorem ev_runs_comp (nu : List Nat) (sg : List lf) (T : List run) (X : Side6) : + ev_runs nu (comp_runs sg T) X = ev_runs (sg.map (evN nu)) T X := by + induction T with + | nil => rfl + | cons r T ih => + rcases r with ⟨b, a⟩ + rw [comp_runs, List.map_cons, ← comp_runs, ev_runs, ev_runs, ih] + congr 1 + exact congrArg (alt b) (evN_compose nu sg a) + +theorem jump_lemma (T : List run) (p : Bool) (dec inc : List Nat) + (hc : ∀ nu, EpSeq [p, p, p, p] (evR nu (subst_runs dec T)) (evR nu (subst_runs inc T))) + (k : Nat) : ∀ (nu : List Nat), + EpSeq (rep p (4 * k)) (evR (zadd nu (vscale k dec)) T) (evR (zadd nu (vscale k inc)) T) := by + induction k with + | zero => + intro nu + simp only [Nat.mul_zero, rep, List.replicate_zero, EpSeq, evR] + apply ev_runs_dot + intro v + simp [dot_zadd2, dot_vscale] + | succ k ih => + intro nu + have hmul : 4 * (k + 1) = 4 + 4 * k := by omega + rw [hmul, rep_add] + refine EpSeq_app (rep p 4) (rep p (4 * k)) _ (evR (zadd (zadd nu inc) (vscale k dec)) T) _ ?_ ?_ + · have h1 := hc (zadd nu (vscale k dec)) + simp only [evR, ev_runs_subst] at h1 ⊢ + have he1 : ev_runs (zadd nu (vscale (k + 1) dec)) T default = + ev_runs (zadd (zadd nu (vscale k dec)) dec) T default := by + apply ev_runs_dot; intro v; simp only [dot_zadd2, dot_vscale]; ring + have he2 : ev_runs (zadd (zadd nu inc) (vscale k dec)) T default = + ev_runs (zadd (zadd nu (vscale k dec)) inc) T default := by + apply ev_runs_dot; intro v; simp only [dot_zadd2]; omega + rw [he1, he2] + exact h1 + · have h2 := ih (zadd nu inc) + simp only [evR] at h2 ⊢ + have he3 : ev_runs (zadd nu (vscale (k + 1) inc)) T default = + ev_runs (zadd (zadd nu inc) (vscale k inc)) T default := by + apply ev_runs_dot; intro v; simp only [dot_zadd2, dot_vscale]; ring + rw [he3] + exact h2 + +def uvar (i : Nat) (c : Nat) : lf := ⟨c, List.replicate i 0 ++ [4]⟩ + +def zsub : List Nat → List Nat → List Nat + | x :: a', y :: b' => (x - y) :: zsub a' b' + | a, [] => a + | [], _ => [] + +def mk_jump (i : Nat) : List run → List run → lf → Option (List run × List Nat × List Nat × List lf) + | [], [], _ => some ([], [], [], []) + | (b, a) :: rr', (b4, a4) :: rr4', c => + if !seqb b b4 then none + else if !listN_eqb (strip0 a.lv) (strip0 a4.lv) then none + else match mk_jump (i + 1) rr' rr4' c with + | none => none + | some (T, dec, inc, sg) => + if a4.lc < a.lc then + let diff := a.lc - a4.lc + if diff % 4 != 0 then none + else + let dn := diff / 4 + let M := a.lc - 4 * dn * c.lc + let s : lf := ⟨0, (zsub a.lv (c.lv.map ((4 * dn) * ·))).map (· / 4)⟩ + some ((b, uvar i M) :: T, dn :: dec, 0 :: inc, s :: sg) + else + let diff := a4.lc - a.lc + if diff % 4 != 0 then none + else + let q := diff / 4 + if allz a.lv && q == 0 then + some ((b, a) :: T, 0 :: dec, 0 :: inc, ⟨0, []⟩ :: sg) + else + let s : lf := ⟨0, a.lv.map (· / 4)⟩ + some ((b, uvar i a.lc) :: T, 0 :: dec, q :: inc, s :: sg) + | _, _, _ => none + +def mapadd (c : lf) : List lf → List Nat → List lf + | s :: sg', x :: w' => lf_add s (lf_scale x c) :: mapadd c sg' w' + | _, _ => [] + +theorem mapadd_ev (nu : List Nat) (c : lf) (sg : List lf) : ∀ (w : List Nat), + sg.length = w.length → + (mapadd c sg w).map (evN nu) = zadd (sg.map (evN nu)) (vscale (evN nu c) w) := by + induction sg with + | nil => + intro w hl + cases w with + | nil => rfl + | cons _ _ => contradiction + | cons s sg ih => + intro w hl + cases w with + | nil => contradiction + | cons x w => + simp only [List.length_cons, Nat.add_right_cancel_iff] at hl + simp only [mapadd, List.map_cons, vscale, zadd, ih w hl, evN_add, evN_scale] + congr 1 + ring + +def cyc4 (p : Bool) : List Bool := [p, p, p, p] + +def jump_run (p : Bool) (c : lf) (rr : List run) : Option (List run) := + match eps (cyc4 p) rr with + | none => none + | some rr4 => + match mk_jump 0 rr rr4 c with + | none => none + | some (T, dec, inc, sg) => + if sg.length == dec.length && sg.length == inc.length then + match eps (cyc4 p) (subst_runs dec T) with + | none => none + | some X => + if runs_eqb X (subst_runs inc T) && runs_eqb rr (comp_runs (mapadd c sg dec) T) then + some (comp_runs (mapadd c sg inc) T) + else none + else none + +theorem jump_run_spec {p : Bool} {c : lf} {rr rr' : List run} + (h : jump_run p c rr = some rr') (nu : List Nat) : + EpSeq (rep p (4 * ev nu c)) (evR nu rr) (evR nu rr') := by + simp only [jump_run] at h + rcases h1 : eps (cyc4 p) rr with _ | rr4 + · simp [h1] at h + · simp only [h1] at h + rcases h2 : mk_jump 0 rr rr4 c with _ | ⟨T, dec, inc, sg⟩ + · simp [h2] at h + · simp only [h2] at h + rcases hl : (sg.length == dec.length && sg.length == inc.length) + · simp [hl] at h + · simp only [hl, ↓reduceIte] at h + simp only [Bool.and_eq_true, beq_iff_eq] at hl + rcases hl with ⟨hl1, hl2⟩ + rcases hx : eps (cyc4 p) (subst_runs dec T) with _ | X + · simp [hx] at h + · simp only [hx] at h + rcases hc : (runs_eqb X (subst_runs inc T) && runs_eqb rr (comp_runs (mapadd c sg dec) T)) + · simp [hc] at h + · simp only [hc, ↓reduceIte, Option.some.injEq] at h + subst h + simp only [Bool.and_eq_true] at hc + rcases hc with ⟨hc1, hc2⟩ + have hcyc : ∀ nu', EpSeq [p, p, p, + p] (evR nu' (subst_runs dec T)) (evR nu' (subst_runs inc T)) := by + intro nu' + have hx' := eps_spec (cyc4 p) hx nu' + simp only [evR, ← runs_eqb_ev nu' default hc1] + exact hx' + have hj := jump_lemma T p dec inc hcyc (ev nu c) (sg.map (evN nu)) + simp only [evR, runs_eqb_ev nu default hc2, ev_runs_comp, mapadd_ev nu c sg dec hl1, + mapadd_ev nu c sg inc hl2] + exact hj + +inductive instr where + | ISingle (p : Bool) + | IJump (p : Bool) (c : lf) + deriving DecidableEq + +abbrev seg := Bool × lf + +def segs_ev (nu : List Nat) : List seg → List Bool + | [] => [] + | (p, n) :: ss' => rep p (ev nu n) ++ segs_ev nu ss' + +def exec : List instr → List run → Option (List run × List seg) + | [], rr => some (rr, []) + | .ISingle p :: prog', rr => + match ep_run p rr with + | some rr1 => + match exec prog' rr1 with + | some (rr2, ss) => some (rr2, (p, cn 1) :: ss) + | none => none + | none => none + | .IJump p c :: prog', rr => + match jump_run p c rr with + | some rr1 => + match exec prog' rr1 with + | some (rr2, ss) => some (rr2, (p, lf_scale 4 c) :: ss) + | none => none + | none => none + +theorem ev_scale4 (nu : List Nat) (c : lf) : ev nu (lf_scale 4 c) = 4 * ev nu c := + evN_scale nu 4 c + +theorem exec_spec (prog : List instr) : ∀ {rr rr' : List run} {ss : List seg}, + exec prog rr = some (rr', ss) → ∀ (nu : List Nat), + EpSeq (segs_ev nu ss) (evR nu rr) (evR nu rr') := by + induction prog with + | nil => + intro rr rr' ss h nu + simp only [exec, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + rfl + | cons ins prog ih => + intro rr rr' ss h nu + cases ins with + | ISingle p => + simp only [exec] at h + rcases e1 : ep_run p rr with _ | rr1 + · simp [e1] at h + · simp only [e1] at h + rcases e2 : exec prog rr1 with _ | ⟨rr2, ss2⟩ + · simp [e2] at h + · simp only [e2, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + exact ⟨evR nu rr1, ep_run_spec e1 nu, ih e2 nu⟩ + | IJump p c => + simp only [exec] at h + rcases e1 : jump_run p c rr with _ | rr1 + · simp [e1] at h + · simp only [e1] at h + rcases e2 : exec prog rr1 with _ | ⟨rr2, ss2⟩ + · simp [e2] at h + · simp only [e2, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl⟩ + simp only [segs_ev, ev_scale4] + exact EpSeq_app _ _ _ (evR nu rr1) _ (jump_run_spec e1 nu) (ih e2 nu) + +def sum_ph (p : Bool) : List seg → lf + | [] => ⟨0, []⟩ + | (q, n) :: ss' => if p == q then lf_add n (sum_ph p ss') else sum_ph p ss' + +def split_ok : Bool → List seg → Bool + | _, [] => true + | seen_false, (true, _) :: ss' => (!seen_false) && split_ok false ss' + | _, (false, _) :: ss' => split_ok true ss' + +theorem split_false (ss : List seg) (nu : List Nat) (h : split_ok true ss = true) : + segs_ev nu ss = rep false (ev nu (sum_ph false ss)) := by + induction ss with + | nil => rfl + | cons s ss ih => + rcases s with ⟨_ | _, n⟩ + · simp only [split_ok] at h + simp only [segs_ev, sum_ph, beq_self_eq_true, ↓reduceIte, ev_add, rep_add, ih h] + · contradiction + +theorem sum_true_of_split_true (ss : List seg) (nu : List Nat) (h : split_ok true ss = true) : + ev nu (sum_ph true ss) = 0 := by + induction ss with + | nil => rfl + | cons s ss ih => + rcases s with ⟨_ | _, n⟩ + · simp only [split_ok] at h + exact ih h + · contradiction + +theorem split_spec (ss : List seg) (nu : List Nat) (h : split_ok false ss = true) : + segs_ev nu ss = rep true (ev nu (sum_ph true ss)) ++ rep false (ev nu (sum_ph false ss)) := by + induction ss with + | nil => rfl + | cons s ss ih => + rcases s with ⟨_ | _, n⟩ + · simp only [split_ok] at h + have htf : (true == false) = false := rfl + simp only [segs_ev, sum_ph, htf, beq_self_eq_true, Bool.false_eq_true, ↓reduceIte, ev_add, + rep_add, + split_false ss nu h, sum_true_of_split_true ss nu h, rep, List.replicate_zero, + List.nil_append] + · simp only [split_ok, Bool.not_false, Bool.true_and] at h + have hft : (false == true) = false := rfl + simp only [segs_ev, sum_ph, hft, beq_self_eq_true, Bool.false_eq_true, ↓reduceIte, ev_add, + rep_add, ih h, List.append_assoc] + +def prog_check (prog : List instr) (rs re : List run) (t_lf f_lf : lf) : Bool := + match exec prog rs with + | some (re', ss) => + (runs_eqb re' re && split_ok false ss) && (lf_eqb (sum_ph true ss) t_lf && lf_eqb (sum_ph false + ss) f_lf) + | none => false + +theorem prog_check_spec {prog : List instr} {rs re : List run} {t_lf f_lf : lf} + (h : prog_check prog rs re t_lf f_lf = true) (nu : List Nat) : + EpSeq (rep true (ev nu t_lf) ++ rep false (ev nu f_lf)) (evR nu rs) (evR nu re) := by + simp only [prog_check] at h + rcases he : exec prog rs with _ | ⟨re', ss⟩ + · simp [he] at h + · simp only [he, Bool.and_eq_true] at h + rcases h with ⟨⟨h1, h3⟩, ⟨h2, h4⟩⟩ + have hex := exec_spec prog he nu + rw [split_spec ss nu h3, lf_eqb_ev nu h2, lf_eqb_ev nu h4] at hex + simp only [evR, ← runs_eqb_ev nu default h1] + exact hex + +def rtop (qs : List (List Nat)) (z : Nat) : Nat := + match qs with + | [] => z + | q :: _ => q.getD 0 0 + +def rshift : List (List Nat) → Nat → List (List Nat) + | [], _ => [] + | q :: qs', z => [q.getD 1 0, q.getD 2 0, q.getD 3 0, rtop qs' z] :: rshift qs' z + +theorem shift_len (qs : List (List Nat)) (z : Nat) : (rshift qs z).length = qs.length := by + induction qs with + | nil => rfl + | cons q qs ih => simp [rshift, ih] + +theorem dot4 (a b c d : Nat) (q : List Nat) : + dot [a, b, c, d] q = a * q.getD 0 0 + b * q.getD 1 0 + c * q.getD 2 0 + d * q.getD 3 0 := by + rcases q with _ | ⟨x0, _ | ⟨x1, _ | ⟨x2, _ | ⟨x3, q⟩⟩⟩⟩ <;> simp [dot, List.getD] <;> ring + +theorem alt_split (b : Sym2) (m k : Nat) (h : m % 2 = 0) : + alt b (m + k) = alt b m ++ alt b k := by + rw [alt_add] + simp [afterb_nat, h] + +theorem regroup (qs : List (List Nat)) : ∀ (z : Nat) (X X' : Side6), + X = alt 0 1 +> (alt 0 (2 + 4 * z) +> X') → + chs (rep .D2 qs.length) qs X = + alt 0 1 +> (alt 0 (2 + 4 * rtop qs z) +> chs (rep .U0 qs.length) (rshift qs z) X') := by + induction qs with + | nil => + intro z X X' hx + exact hx + | cons q qs ih => + intro z X X' hx + simp only [List.length_cons, rep, List.replicate_succ, chs, rshift, rtop] + rw [ih z X X' hx] + set Y := chs (List.replicate qs.length .U0) (rshift qs z) X' + change ev_runs q [(0, cn 1), (0, vt 5), (0, vs 4), (1, va 4), (0, vl 0)] + (alt 0 1 +> (alt 0 (2 + 4 * rtop qs z) +> Y)) = + alt 0 1 +> (alt 0 (2 + 4 * q.getD 0 0) +> + ev_runs [q.getD 1 0, q.getD 2 0, q.getD 3 0, rtop qs z] + [(0, cn 3), (0, vt 4), (1, vs 4), (0, va 1), (0, vl 2)] Y) + simp only [ev_runs, ev, vt, vs, va, vl, cn, dot4, dot, List.getD, + List.getElem?_cons_zero, List.getElem?_cons_succ, Option.getD_some] + set xt := q[0]?.getD 0 + set xs := q[1]?.getD 0 + set xa := q[2]?.getD 0 + set xI := q[3]?.getD 0 + set tz := rtop qs z + have e1 : alt 0 (5 + (4 * xt + 0 * xs + 0 * xa + 0 * xI)) = alt 0 (2 + 4 * xt) ++ alt 0 3 := by + have hadd : 5 + (4 * xt + 0 * xs + 0 * xa + 0 * xI) = (2 + 4 * xt) + 3 := by omega + rw [hadd] + exact alt_split 0 (2 + 4 * xt) 3 (by omega) + have e2 : alt 0 (1 + (0 * xs + 0 * xa + 4 * xI + 0 * tz)) = + alt 0 (0 + (0 * xt + 0 * xs + 0 * xa + 4 * xI)) ++ alt 0 1 := by + have hadd : 1 + (0 * xs + 0 * xa + 4 * xI + 0 * tz) = + (0 + (0 * xt + 0 * xs + 0 * xa + 4 * xI)) + 1 := by omega + rw [hadd] + exact alt_split 0 _ 1 (by omega) + have e3 : 2 + (0 * xs + 0 * xa + 0 * xI + 4 * tz) = 2 + 4 * tz := by omega + have e4 : 4 + (4 * xs + 0 * xa + 0 * xI + 0 * tz) = 4 + (0 * xt + 4 * xs + 0 * xa + 0 * xI) := + by omega + have e5 : 4 + (0 * xs + 4 * xa + 0 * xI + 0 * tz) = 4 + (0 * xt + 0 * xs + 4 * xa + 0 * xI) := + by omega + have e0 : 3 + 0 = 3 := rfl + rw [e1, e2, e3, e4, e5, append_assoc, append_assoc] + +theorem regroup_b1 : b1s .PD2 (LWs 81) = alt 0 1 +> (alt 0 (2 + 4 * 0) +> b1s .P0 (LWs 0)) := rfl + +@[simp] theorem dot_nil (nu : List Nat) : dot [] nu = 0 := by cases nu <;> rfl +@[simp] theorem ev_cn (nu : List Nat) (c : Nat) : ev nu (cn c) = c := by simp [ev, cn] + +theorem drop_step (L Re Rs : List run) (nu : List Nat) (X' : Side6) + (h : reach 500 (.Rc B (L, .TV 0) (Re, .T0)) (.Lc D ([], .TV 0) (Rs, .T0)) = true) : + ((ev_runs nu L X') {{B}}> (evR nu Re)) [tm372]⊢⁺ (X' <{{D}} (evR nu Rs)) := + reach_spec h nu (fun _ => X') + +def tl1 (c a : Nat) : lf := ⟨c, [a]⟩ + +def Rs_r5 : List run := + mkruns 0 [tl1 224492 1796256, tl1 673559 5388768, cn 8, tl1 9836 78732, tl1 1942069 15536448] +def prog_r5 : List instr := + List.replicate 4 (.ISingle true) ++ [.IJump true (tl1 817 6561)] ++ + List.replicate 6 (.ISingle true) ++ List.replicate 13 (.ISingle false) ++ + [.IJump false (tl1 43462 347733)] ++ List.replicate 7 (.ISingle false) +def Rs_r0 : List run := + mkruns 0 [tl1 74804 598752, tl1 224495 1796256, tl1 673560 5388768, tl1 2020752 16166304, cn 4, + tl1 521610 4172796, cn 1] +def prog_r0 : List instr := + List.replicate 4 (.ISingle true) ++ [.IJump true (tl1 817 6561)] ++ + List.replicate 6 (.ISingle true) ++ List.replicate 9 (.ISingle false) ++ + [.IJump false (tl1 43463 347733)] ++ List.replicate 7 (.ISingle false) +def Rs_r1 : List run := + mkruns 0 [tl1 2020748 16166304, cn 7, tl1 551120 4408992, tl1 1564809 12518388, cn 2] +def prog_r1 : List instr := + List.replicate 4 (.ISingle true) ++ [.IJump true (tl1 2457 19683)] ++ + List.replicate 7 (.ISingle true) ++ List.replicate 5 (.ISingle false) ++ + [.IJump false (tl1 130398 1043199)] ++ List.replicate 4 (.ISingle false) +def Rs_r2 : List run := + mkruns 0 [tl1 8276 66528, tl1 24911 199584, tl1 74808 598752, tl1 224496 1796256, + tl1 673559 5388768, tl1 2020751 16166304, cn 8, tl1 29514 236196, tl1 5826224 46609344, cn 2] +def prog_r2 : List instr := + List.replicate 4 (.ISingle true) ++ [.IJump true (tl1 817 6561)] ++ + List.replicate 6 (.ISingle true) ++ List.replicate 8 (.ISingle false) ++ + [.IJump false (tl1 43464 347733)] ++ List.replicate 4 (.ISingle false) +def Rs_r3 : List run := + mkruns 0 [tl1 224492 1796256, tl1 673559 5388768, tl1 2020752 16166304, tl1 6062328 48498912, + cn 4, tl1 1564810 12518388] +def prog_r3 : List instr := + List.replicate 4 (.ISingle true) ++ [.IJump true (tl1 2457 19683)] ++ + List.replicate 7 (.ISingle true) ++ List.replicate 9 (.ISingle false) ++ + [.IJump false (tl1 130397 1043199)] ++ List.replicate 4 (.ISingle false) +def Rs_r4 : List run := + mkruns 0 [tl1 74804 598752, tl1 224495 1796256, tl1 673560 5388768, tl1 2020752 16166304, + tl1 6062327 48498912, cn 7, tl1 1653368 13226976, tl1 4694422 37555164, cn 1] +def prog_r4 : List instr := + List.replicate 4 (.ISingle true) ++ [.IJump true (tl1 2457 19683)] ++ + List.replicate 7 (.ISingle true) ++ List.replicate 6 (.ISingle false) ++ + [.IJump false (tl1 130397 1043199)] ++ List.replicate 7 (.ISingle false) + +def Re_r5 : List run := + [(0, tl1 224492 1796256), (1, tl1 673560 5388768), (0, tl1 2020752 16166304), (1, cn 4), (0, + tl1 521602 4172796)] +def Re_r0 : List run := + [(0, tl1 74804 598752), (1, tl1 224496 1796256), (0, tl1 673560 5388768), (1, + tl1 2020751 16166304), (1, cn 7), (1, tl1 551120 4408992), (0, tl1 1564798 12518388), (1, cn 1)] +def Re_r1 : List run := + [(0, tl1 2020748 16166304), (1, cn 8), (0, tl1 29521 236196), (0, tl1 5826161 46609344), (0, + cn 2)] +def Re_r2 : List run := + [(0, tl1 8276 66528), (1, tl1 24912 199584), (0, tl1 74808 598752), (1, tl1 224495 1796256), (1, + tl1 673559 5388768), (1, tl1 2020752 16166304), (0, tl1 6062328 48498912), (1, cn 3), (1, + tl1 1564801 12518388), (1, cn 1)] +def Re_r3 : List run := + [(0, tl1 224492 1796256), (1, tl1 673560 5388768), (0, tl1 2020752 16166304), (1, + tl1 6062327 48498912), (1, cn 7), (1, tl1 1653368 13226976), (0, tl1 4694397 37555164), (0, + cn 2)] +def Re_r4 : List run := + [(0, tl1 74804 598752), (1, tl1 224496 1796256), (0, tl1 673560 5388768), (1, + tl1 2020751 16166304), (1, tl1 6062327 48498912), (1, cn 7), (1, tl1 88573 708588), (1, + tl1 17478488 139828032), (0, cn 2)] + +theorem int_r5 : prog_check prog_r5 Rs_r5 Re_r5 (tl1 3278 26244) (tl1 173868 1390932) = true := by + decide +kernel +theorem int_r0 : prog_check prog_r0 Rs_r0 Re_r0 (tl1 3278 26244) (tl1 173868 1390932) = true := by + decide +kernel +theorem int_r1 : prog_check prog_r1 Rs_r1 Re_r1 (tl1 9839 78732) (tl1 521601 4172796) = true := by + decide +kernel +theorem int_r2 : prog_check prog_r2 Rs_r2 Re_r2 (tl1 3278 26244) (tl1 173868 1390932) = true := by + decide +kernel +theorem int_r3 : prog_check prog_r3 Rs_r3 Re_r3 (tl1 9839 78732) (tl1 521601 4172796) = true := by + decide +kernel +theorem int_r4 : prog_check prog_r4 Rs_r4 Re_r4 (tl1 9839 78732) (tl1 521601 4172796) = true := by + decide +kernel + +def W5t (t : Nat) : Nat := 18701 + 149688 * t +def W5s (t : Nat) : Nat := 6227 + 49896 * t +def W5a (t : Nat) : Nat := 2069 + 16632 * t +def wv (c a t : Nat) : Nat := c + a * t +def W0t := wv 6227 49896 +def W0s := wv 2069 16632 +def W1t := wv 168389 1347192 +def W1s := wv 56123 449064 +def W1a := wv 18701 149688 +def W1I := wv 6227 49896 +def W1u := wv 2069 16632 +def W3t := wv 18701 149688 + +def sig01 : List lf := [tl1 168389 1347192, tl1 56123 449064, tl1 18701 149688, tl1 6227 49896] +def f4_r0 : List run := + [(0, tl1 74804 598752), (1, tl1 224496 1796256), (0, tl1 673560 5388768), (1, cn 3)] +def Rp_r0 : List run := + [(0, tl1 2020748 16166304), (1, cn 7), (1, tl1 551120 4408992), (0, tl1 1564798 12518388), (1, + cn 1)] +def sig12 : List lf := [tl1 56123 449064, tl1 18701 149688, tl1 6227 49896, tl1 2069 16632] +def xv : lf := ⟨2, [0, 4]⟩ +def sig23 : List lf := [tl1 18701 149688, tl1 6227 49896, tl1 2069 16632, ⟨0, [0, 1]⟩] +def f4_r2 : List run := + [(0, tl1 8276 66528), (1, tl1 24912 199584), (0, tl1 74808 598752), (1, cn 3)] +def Rp_r2 : List run := + [(0, tl1 224492 1796256), (1, tl1 673559 5388768), (1, tl1 2020752 16166304), (0, + tl1 6062328 48498912), (1, cn 3), (1, tl1 1564801 12518388), (1, cn 1)] + +def sub9_lf (l : lf) : lf := + match l.lv with + | [a] => ⟨l.lc + a, [9 * a]⟩ + | _ => l +def sub9 (rs : List run) : List run := rs.map (fun r => (r.1, sub9_lf r.2)) + +def sig45 : List lf := [tl1 168389 1347192, tl1 56123 449064, tl1 18701 149688, ⟨0, [0, 1]⟩] +def f4_r4 : List run := + [(0, tl1 74804 598752), (1, tl1 224496 1796256), (0, tl1 673560 5388768), (1, cn 3)] +def Rp_r4 : List run := + [(0, tl1 2020748 16166304), (1, tl1 6062327 48498912), (1, cn 7), (1, tl1 88573 708588), (1, + tl1 17478488 139828032), (0, cn 2)] + +theorem rec_r5_ok : + reach 500 (.Rc B ([(0, cn 1), (0, tl1 74806 598752)], .TV 0) (Re_r5, .T0)) (.Lc D ([], + .TV 0) (Rs_r0, .T0)) = true := by + decide +kernel + +theorem rec_r0a : + reach 500 (.Rc B ([(0, cn 1), (0, tl1 24910 199584)], .TV 0) (f4_r0, .TV 1)) + (.Rc A (comp_runs sig01 (blk .U0), .TV 0) ([], .TV 1)) = true := by + decide +kernel + +theorem rec_r0b : ep_run true Rp_r0 = some Rs_r1 := by decide +kernel + +theorem rec_r3_ok : + reach 500 (.Rc B ([(0, cn 1), (0, tl1 74806 598752)], .TV 0) (Re_r3, .T0)) (.Lc D ([], + .TV 0) (Rs_r4, .T0)) = true := by + decide +kernel + +theorem rec_r1_ok : + reach 500 (.Rc B ([(0, cn 1), (0, tl1 673558 5388768)] ++ comp_runs sig12 (blk .U0), + .TV 0) (Re_r1, .T0)) + (.Lc D ([], .TV 0) (Rs_r2, .T0)) = true := by + decide +kernel + +theorem rec_r2a : + reach 500 (.Rc B ([(0, cn 1), (0, xv)], .TV 0) (f4_r2, .TV 1)) + (.Rc A (comp_runs sig23 (blk .U0), .TV 0) ([], .TV 1)) = true := by + decide +kernel + +theorem rec_r2b : ep_run true Rp_r2 = some Rs_r3 := by decide +kernel + +theorem rec_r4a : + reach 500 (.Rc B ([(0, cn 1), (0, xv)], .TV 0) (f4_r4, .TV 1)) + (.Rc A (comp_runs sig45 (blk .U0), .TV 0) ([], .TV 1)) = true := by + decide +kernel + +theorem rec_r4b : ep_run true Rp_r4 = some (sub9 Rs_r5) := by decide +kernel + +theorem step_r5 (t f1 : Nat) (deep : List (List Nat)) : + ((chs (rep .D2 (deep.length + 1)) ([W5t t, W5s t, W5a t, + f1] :: deep) (b1s .PD2 (LWs 81))) {{B}}> (evR [t] Re_r5)) [tm372]⊢⁺ + Gc (rep .U0 (deep.length + 1), .P0, 0) ([W5s t, W5a t, f1, + rtop deep 0] :: rshift deep 0) (evR [t] Rs_r0) := by + have hreg := + regroup ([W5t t, W5s t, W5a t, f1] :: deep) 0 (b1s .PD2 (LWs 81)) (b1s .P0 (LWs 0)) regroup_b1 + simp only [List.length_cons, rtop, rshift, List.getD, List.getElem?_cons_zero, + List.getElem?_cons_succ, Option.getD_some] at hreg + rw [hreg] + set X' := + chs (rep .U0 (deep.length + 1)) ([W5s t, W5a t, f1, + rtop deep 0] :: rshift deep 0) (b1s .P0 (LWs 0)) + have hev : 2 + 4 * W5t t = ev [t] (tl1 74806 598752) := by + simp only [ev, W5t, tl1, dot] + omega + rw [hev] + exact drop_step [(0, cn 1), (0, tl1 74806 598752)] Re_r5 Rs_r0 [t] X' rec_r5_ok + +theorem pow_K0 (k0 e : Nat) (he : 2 ≤ e) : 3 ^ (k0 + 2 * e) = 3 ^ (k0 + 4) * 9 ^ (e - 2) := by + have h1 : k0 + 2 * e = (k0 + 4) + 2 * (e - 2) := by omega + have h2 : (3 : Nat) ^ (2 * (e - 2)) = 9 ^ (e - 2) := by + rw [Nat.pow_mul] + rw [h1, Nat.pow_add, h2] + +theorem S_r5 (e t f1 : Nat) (deep : List (List Nat)) + (he : 2 ≤ e) (ht : 1 + 8 * t = 9 ^ (e - 2)) (hl : deep.length = 1 + 2 * e) : + (Gc (rep .U0 (deep.length + 1), .P0, 0) ([W5t t, W5s t, W5a t, + f1] :: deep) (evR [t] Rs_r5)) [tm372]⊢⁺ + Gc (rep .U0 (deep.length + 1), .P0, 0) ([W5s t, W5a t, f1, + rtop deep 0] :: rshift deep 0) (evR [t] Rs_r0) := by + refine stepStar_stepPlus_trans (interval_tm (deep.length + 1) ([W5t t, W5s t, W5a t, f1] :: deep) + (evR [t] Rs_r5) (evR [t] Re_r5) (by omega) rfl ?_) ?_ + · intro T eT + have hp := prog_check_spec int_r5 [t] + have e3 : 3 ^ (deep.length + 1 + 2) = 81 * 81 * (1 + 8 * t) := by + rw [hl, ht] + have hk : 1 + 2 * e + 1 + 2 = 4 + 2 * e := by omega + rw [hk, pow_K0 4 e he] + rfl + have e2 : 3 ^ (deep.length + 1 + 1) = 27 * 81 * (1 + 8 * t) := by + rw [hl, ht] + have hk : 1 + 2 * e + 1 + 1 = 3 + 2 * e := by omega + rw [hk, pow_K0 3 e he] + rfl + rw [e3] at eT + rw [e2] + have hT : T = ev [t] (tl1 3278 26244) := by simp only [ev, tl1, dot]; omega + have hF : 81 * (27 * 81 * (1 + 8 * t)) - 1 - ev [t] (tl1 3278 26244) = + ev [t] (tl1 173868 1390932) := by + simp only [ev, tl1, dot]; omega + rw [hT, hF] + exact hp + · exact stepPlus_trans (record_visit (deep.length + 1) ([W5t t, W5s t, W5a t, + f1] :: deep) (evR [t] Re_r5) rfl) + (step_r5 t f1 deep) + +theorem evN_tl1 (c a t : Nat) : evN [t] (tl1 c a) = wv c a t := by + simp only [evN, tl1, wv, dot] + omega + +theorem take_step (L first4 Re' Rs : List run) (nu : List Nat) (sg : List lf) (X' : Side6) + (h1 : reach 500 (.Rc B (L, .TV 0) (first4, .TV 1)) (.Rc A (comp_runs sg (blk .U0), .TV 0) ([], + .TV 1)) = true) + (h2 : ep_run true Re' = some Rs) : + ((ev_runs nu L X') {{B}}> (ev_runs nu first4 (evR nu Re'))) [tm372]⊢⁺ + ((ev_runs (sg.map (evN nu)) (blk .U0) X') <{{D}} (evR nu Rs)) := by + refine stepPlus_stepStar_trans (reach_spec h1 nu (sg2 X' (evR nu Re'))) ?_ + change ((ev_runs nu (comp_runs sg (blk .U0)) X') {{A}}> (evR nu Re')) [tm372]⊢* + ((ev_runs (sg.map (evN nu)) (blk .U0) X') <{{D}} (evR nu Rs)) + rw [ev_runs_comp] + exact ep_run_spec h2 nu _ + +theorem split4 (nu : List Nat) (r1 r2 r3 : run) (b : Sym2) (c : Nat) (v : List Nat) (rest : List + run) (X : Side6) : + ev_runs nu (r1 :: r2 :: r3 :: (b, ⟨3 + c, v⟩) :: rest) X = + ev_runs nu [r1, r2, r3, (b, cn 3)] (ev_runs nu ((sneg b, ⟨c, v⟩) :: rest) X) := by + rcases r1 with ⟨b1, n1⟩ + rcases r2 with ⟨b2, n2⟩ + rcases r3 with ⟨b3, n3⟩ + simp only [ev_runs, ev_cn] + have hreg : alt b (ev nu ⟨3 + c, v⟩) = alt b 3 ++ alt (sneg b) (ev nu ⟨c, v⟩) := by + simp only [ev] + have hadd : 3 + c + dot v nu = 3 + (c + dot v nu) := by omega + rw [hadd, alt_add] + rfl + rw [hreg, append_assoc] + +theorem split_r0 (t : Nat) : evR [t] Re_r0 = ev_runs [t] f4_r0 (evR [t] Rp_r0) := by + unfold evR Re_r0 f4_r0 Rp_r0 tl1 + change ev_runs [t] ((0, ⟨74804, [598752]⟩) :: (1, ⟨224496, [1796256]⟩) :: (0, ⟨673560, + [5388768]⟩) :: + (1, ⟨3 + 2020748, [16166304]⟩) :: _) default = _ + exact split4 [t] _ _ _ 1 2020748 [16166304] _ default + +theorem step_r0 (t f1 f2 : Nat) (deep : List (List Nat)) : + ((chs (rep .D2 (deep.length + 1)) ([W0t t, W0s t, f1, + f2] :: deep) (b1s .PD2 (LWs 81))) {{B}}> (evR [t] Re_r0)) [tm372]⊢⁺ + Gc (rep .U0 (deep.length + 2), .P0, 0) + ([W1t t, W1s t, W1a t, W1I t] :: [W0s t, f1, f2, + rtop deep 0] :: rshift deep 0) (evR [t] Rs_r1) := by + have hreg := + regroup ([W0t t, W0s t, f1, f2] :: deep) 0 (b1s .PD2 (LWs 81)) (b1s .P0 (LWs 0)) regroup_b1 + have hrtop : rtop ([W0t t, W0s t, f1, f2] :: deep) 0 = W0t t := rfl + have hrshift : rshift ([W0t t, W0s t, f1, f2] :: deep) 0 = [W0s t, f1, f2, + rtop deep 0] :: rshift deep 0 := rfl + rw [List.length_cons, hrtop, hrshift] at hreg + rw [hreg] + set X' := + chs (rep .U0 (deep.length + 1)) ([W0s t, f1, f2, + rtop deep 0] :: rshift deep 0) (b1s .P0 (LWs 0)) + have hev : 2 + 4 * W0t t = ev [t] (tl1 24910 199584) := by + simp only [ev, W0t, wv, tl1, dot]; omega + rw [hev, split_r0] + have hsig : [W1t t, W1s t, W1a t, W1I t] = sig01.map (evN [t]) := by + simp only [sig01, List.map, evN_tl1, W1t, W1s, W1a, W1I] + rw [hsig] + exact take_step [(0, cn 1), (0, tl1 24910 199584)] f4_r0 Rp_r0 Rs_r1 [t] sig01 X' rec_r0a rec_r0b + +theorem step_r3 (t f1 f2 f3 : Nat) (deep : List (List Nat)) : + ((chs (rep .D2 (deep.length + 1)) ([W3t t, f1, f2, + f3] :: deep) (b1s .PD2 (LWs 81))) {{B}}> (evR [t] Re_r3)) [tm372]⊢⁺ + Gc (rep .U0 (deep.length + 1), .P0, 0) ([f1, f2, f3, + rtop deep 0] :: rshift deep 0) (evR [t] Rs_r4) := by + have hreg := + regroup ([W3t t, f1, f2, f3] :: deep) 0 (b1s .PD2 (LWs 81)) (b1s .P0 (LWs 0)) regroup_b1 + simp only [List.length_cons, rtop, rshift, List.getD, List.getElem?_cons_zero, + List.getElem?_cons_succ, Option.getD_some] at hreg + rw [hreg] + set X' := + chs (rep .U0 (deep.length + 1)) ([f1, f2, f3, rtop deep 0] :: rshift deep 0) (b1s .P0 (LWs 0)) + have hev : 2 + 4 * W3t t = ev [t] (tl1 74806 598752) := by + simp only [ev, W3t, wv, tl1, dot]; omega + rw [hev] + exact drop_step [(0, cn 1), (0, tl1 74806 598752)] Re_r3 Rs_r4 [t] X' rec_r3_ok + +theorem step_r1 (t f1 f2 f3 : Nat) (deep : List (List Nat)) : + ((chs (rep .D2 (deep.length + 2)) ([W1t t, W1s t, W1a t, W1I t] :: [W1u t, f1, f2, + f3] :: deep) (b1s .PD2 (LWs 81))) + {{B}}> (evR [t] Re_r1)) [tm372]⊢⁺ + Gc (rep .U0 (deep.length + 1), .P0, 0) ([f1, f2, f3, + rtop deep 0] :: rshift deep 0) (evR [t] Rs_r2) := by + have hreg := + regroup ([W1t t, W1s t, W1a t, W1I t] :: [W1u t, f1, f2, + f3] :: deep) 0 (b1s .PD2 (LWs 81)) (b1s .P0 (LWs 0)) regroup_b1 + simp only [List.length_cons, rtop, rshift, List.getD, List.getElem?_cons_zero, + List.getElem?_cons_succ, Option.getD_some] at hreg + rw [hreg] + set X' := + chs (rep .U0 (deep.length + 1)) ([f1, f2, f3, rtop deep 0] :: rshift deep 0) (b1s .P0 (LWs 0)) + change ((alt 0 1 +> (alt 0 (2 + 4 * W1t t) +> ev_runs [W1s t, W1a t, W1I t, + W1u t] (blk .U0) X')) {{B}}> (evR [t] Re_r1)) [tm372]⊢⁺ _ + have hsig : [W1s t, W1a t, W1I t, W1u t] = sig12.map (evN [t]) := by + simp only [sig12, List.map, evN_tl1, W1s, W1a, W1I, W1u] + rw [hsig, ← ev_runs_comp] + have hev : 2 + 4 * W1t t = ev [t] (tl1 673558 5388768) := by + simp only [ev, W1t, wv, tl1, dot]; omega + rw [hev] + exact drop_step ([(0, cn 1), (0, + tl1 673558 5388768)] ++ comp_runs sig12 (blk .U0)) Re_r1 Rs_r2 [t] X' rec_r1_ok + +theorem split_r2 (nu : List Nat) : evR nu Re_r2 = ev_runs nu f4_r2 (evR nu Rp_r2) := by + unfold evR Re_r2 f4_r2 Rp_r2 tl1 + change ev_runs nu ((0, ⟨8276, [66528]⟩) :: (1, ⟨24912, [199584]⟩) :: (0, ⟨74808, [598752]⟩) :: + (1, ⟨3 + 224492, [1796256]⟩) :: _) default = _ + exact split4 nu _ _ _ 1 224492 [1796256] _ default + +theorem step_r2 (t : Nat) (q : List Nat) (deep : List (List Nat)) : + ((chs (rep .D2 (deep.length + 1)) (q :: deep) (b1s .PD2 (LWs 81))) {{B}}> (evR [t] Re_r2)) + [tm372]⊢⁺ + Gc (rep .U0 (deep.length + 2), .P0, 0) + ([W3t t, wv 6227 49896 t, wv 2069 16632 t, + q.getD 0 0] :: rshift (q :: deep) 0) (evR [t] Rs_r3) := by + have hreg := regroup (q :: deep) 0 (b1s .PD2 (LWs 81)) (b1s .P0 (LWs 0)) regroup_b1 + simp only [List.length_cons, rtop] at hreg + rw [hreg] + set xK := q.getD 0 0 + set X' := chs (rep .U0 (deep.length + 1)) (rshift (q :: deep) 0) (b1s .P0 (LWs 0)) + have hr1 : evR [t] Re_r2 = evR [t, xK] Re_r2 := rfl + have hr2 : evR [t] Rs_r3 = evR [t, xK] Rs_r3 := rfl + have hev : 2 + 4 * xK = ev [t, xK] xv := by + simp only [ev, xv, dot]; omega + have hsig : [W3t t, wv 6227 49896 t, wv 2069 16632 t, xK] = sig23.map (evN [t, xK]) := by + simp only [sig23, W3t, wv, tl1, evN, List.map, dot] + refine congrArg₂ List.cons (by omega) (congrArg₂ List.cons (by omega) (congrArg₂ List.cons (by + omega) (congrArg₂ List.cons (by omega) rfl))) + rw [hr1, hr2, hev, hsig, split_r2] + exact take_step [(0, cn 1), (0, xv)] f4_r2 Rp_r2 Rs_r3 [t, xK] sig23 X' rec_r2a rec_r2b + +theorem ev_runs_sub9 (t : Nat) (rs : List run) (X : Side6) + (h : rs.all (fun r => decide (r.2.lv.length ≤ 1)) = true) : + ev_runs [t] (sub9 rs) X = ev_runs [1 + 9 * t] rs X := by + induction rs with + | nil => rfl + | cons r rs ih => + rcases r with ⟨b, c, _ | ⟨a, _ | ⟨a', v⟩⟩⟩ + · simp only [List.all_cons, Bool.and_eq_true, decide_eq_true_eq] at h + change alt b (ev [t] (sub9_lf ⟨c, []⟩)) +> ev_runs [t] (sub9 rs) X = + alt b (ev [1 + 9 * t] ⟨c, []⟩) +> ev_runs [1 + 9 * t] rs X + rw [ih h.2] + rfl + · simp only [List.all_cons, Bool.and_eq_true, decide_eq_true_eq] at h + change alt b (ev [t] (sub9_lf ⟨c, [a]⟩)) +> ev_runs [t] (sub9 rs) X = + alt b (ev [1 + 9 * t] ⟨c, [a]⟩) +> ev_runs [1 + 9 * t] rs X + rw [ih h.2] + congr 2 + simp only [sub9_lf, ev, dot] + ring + · simp [List.all_cons] at h + +theorem evR_sub9_r5 (t : Nat) : evR [t] (sub9 Rs_r5) = evR [1 + 9 * t] Rs_r5 := + ev_runs_sub9 t Rs_r5 default rfl + +theorem split_r4 (nu : List Nat) : evR nu Re_r4 = ev_runs nu f4_r4 (evR nu Rp_r4) := by + unfold evR Re_r4 f4_r4 Rp_r4 tl1 + change ev_runs nu ((0, ⟨74804, [598752]⟩) :: (1, ⟨224496, [1796256]⟩) :: (0, ⟨673560, + [5388768]⟩) :: + (1, ⟨3 + 2020748, [16166304]⟩) :: _) default = _ + exact split4 nu _ _ _ 1 2020748 [16166304] _ default + +theorem step_r4 (t : Nat) (q : List Nat) (deep : List (List Nat)) : + ((chs (rep .D2 (deep.length + 1)) (q :: deep) (b1s .PD2 (LWs 81))) {{B}}> (evR [t] Re_r4)) + [tm372]⊢⁺ + Gc (rep .U0 (deep.length + 2), .P0, 0) + ([W5t (1 + 9 * t), W5s (1 + 9 * t), W5a (1 + 9 * t), q.getD 0 0] :: rshift (q :: deep) 0) + (evR [1 + 9 * t] Rs_r5) := by + have hreg := regroup (q :: deep) 0 (b1s .PD2 (LWs 81)) (b1s .P0 (LWs 0)) regroup_b1 + simp only [List.length_cons, rtop] at hreg + rw [hreg] + set xK := q.getD 0 0 + set X' := chs (rep .U0 (deep.length + 1)) (rshift (q :: deep) 0) (b1s .P0 (LWs 0)) + have hr1 : evR [t] Re_r4 = evR [t, xK] Re_r4 := rfl + rw [← evR_sub9_r5] + have hr2 : evR [t] (sub9 Rs_r5) = evR [t, xK] (sub9 Rs_r5) := rfl + have hev : 2 + 4 * xK = ev [t, xK] xv := by + simp only [ev, xv, dot]; omega + have hsig : [W5t (1 + 9 * t), W5s (1 + 9 * t), W5a (1 + 9 * t), xK] = sig45.map (evN [t, xK]) := + by + simp only [sig45, W5t, W5s, W5a, tl1, evN, List.map, dot] + refine congrArg₂ List.cons (by omega) (congrArg₂ List.cons (by omega) (congrArg₂ List.cons (by + omega) (congrArg₂ List.cons (by omega) rfl))) + rw [hr1, hr2, hev, hsig, split_r4] + exact take_step [(0, cn 1), (0, xv)] f4_r4 Rp_r4 (sub9 Rs_r5) [t, xK] sig45 X' rec_r4a rec_r4b + +theorem S_r0 (e t f1 f2 : Nat) (deep : List (List Nat)) + (he : 2 ≤ e) (ht : 1 + 8 * t = 9 ^ (e - 2)) (hl : deep.length = 1 + 2 * e) : + (Gc (rep .U0 (deep.length + 1), .P0, 0) ([W0t t, W0s t, f1, + f2] :: deep) (evR [t] Rs_r0)) [tm372]⊢⁺ + Gc (rep .U0 (deep.length + 2), .P0, 0) + ([W1t t, W1s t, W1a t, W1I t] :: [W0s t, f1, f2, + rtop deep 0] :: rshift deep 0) (evR [t] Rs_r1) := by + refine stepStar_stepPlus_trans (interval_tm (deep.length + 1) ([W0t t, W0s t, f1, f2] :: deep) + (evR [t] Rs_r0) (evR [t] Re_r0) (by omega) rfl ?_) ?_ + · intro T eT + have hp := prog_check_spec int_r0 [t] + have e3 : 3 ^ (deep.length + 1 + 2) = 81 * 81 * (1 + 8 * t) := by + rw [hl, ht] + have hk : 1 + 2 * e + 1 + 2 = 4 + 2 * e := by omega + rw [hk, pow_K0 4 e he]; rfl + have e2 : 3 ^ (deep.length + 1 + 1) = 27 * 81 * (1 + 8 * t) := by + rw [hl, ht] + have hk : 1 + 2 * e + 1 + 1 = 3 + 2 * e := by omega + rw [hk, pow_K0 3 e he]; rfl + rw [e3] at eT; rw [e2] + have hT : T = ev [t] (tl1 3278 26244) := by simp only [ev, tl1, dot]; omega + have hF : 81 * (27 * 81 * (1 + 8 * t)) - 1 - ev [t] (tl1 3278 26244) = + ev [t] (tl1 173868 1390932) := by + simp only [ev, tl1, dot]; omega + rw [hT, hF]; exact hp + · exact stepPlus_trans (record_visit (deep.length + 1) ([W0t t, W0s t, f1, + f2] :: deep) (evR [t] Re_r0) rfl) + (step_r0 t f1 f2 deep) + +theorem S_r1 (e t f1 f2 f3 : Nat) (deep : List (List Nat)) + (he : 2 ≤ e) (ht : 1 + 8 * t = 9 ^ (e - 2)) (hl : deep.length = 1 + 2 * e) : + (Gc (rep .U0 (deep.length + 2), .P0, 0) + ([W1t t, W1s t, W1a t, W1I t] :: [W1u t, f1, f2, f3] :: deep) (evR [t] Rs_r1)) [tm372]⊢⁺ + Gc (rep .U0 (deep.length + 1), .P0, 0) ([f1, f2, f3, + rtop deep 0] :: rshift deep 0) (evR [t] Rs_r2) := by + refine stepStar_stepPlus_trans (interval_tm (deep.length + 2) + ([W1t t, W1s t, W1a t, W1I t] :: [W1u t, f1, f2, f3] :: deep) + (evR [t] Rs_r1) (evR [t] Re_r1) (by omega) rfl ?_) ?_ + · intro T eT + have hp := prog_check_spec int_r1 [t] + have e3 : 3 ^ (deep.length + 2 + 2) = 243 * 81 * (1 + 8 * t) := by + rw [hl, ht] + have hk : 1 + 2 * e + 2 + 2 = 5 + 2 * e := by omega + rw [hk, pow_K0 5 e he]; rfl + have e2 : 3 ^ (deep.length + 2 + 1) = 81 * 81 * (1 + 8 * t) := by + rw [hl, ht] + have hk : 1 + 2 * e + 2 + 1 = 4 + 2 * e := by omega + rw [hk, pow_K0 4 e he]; rfl + rw [e3] at eT; rw [e2] + have hT : T = ev [t] (tl1 9839 78732) := by simp only [ev, tl1, dot]; omega + have hF : 81 * (81 * 81 * (1 + 8 * t)) - 1 - ev [t] (tl1 9839 78732) = + ev [t] (tl1 521601 4172796) := by + simp only [ev, tl1, dot]; omega + rw [hT, hF]; exact hp + · exact stepPlus_trans (record_visit (deep.length + 2) + ([W1t t, W1s t, W1a t, W1I t] :: [W1u t, f1, f2, f3] :: deep) (evR [t] Re_r1) rfl) + (step_r1 t f1 f2 f3 deep) + +theorem S_r2 (e t : Nat) (q : List Nat) (deep : List (List Nat)) + (he : 2 ≤ e) (ht : 1 + 8 * t = 9 ^ (e - 2)) (hl : deep.length = 1 + 2 * e) : + (Gc (rep .U0 (deep.length + 1), .P0, 0) (q :: deep) (evR [t] Rs_r2)) [tm372]⊢⁺ + Gc (rep .U0 (deep.length + 2), .P0, 0) + ([W3t t, wv 6227 49896 t, wv 2069 16632 t, + q.getD 0 0] :: rshift (q :: deep) 0) (evR [t] Rs_r3) := by + refine stepStar_stepPlus_trans (interval_tm (deep.length + 1) (q :: deep) + (evR [t] Rs_r2) (evR [t] Re_r2) (by omega) rfl ?_) ?_ + · intro T eT + have hp := prog_check_spec int_r2 [t] + have e3 : 3 ^ (deep.length + 1 + 2) = 81 * 81 * (1 + 8 * t) := by + rw [hl, ht] + have hk : 1 + 2 * e + 1 + 2 = 4 + 2 * e := by omega + rw [hk, pow_K0 4 e he]; rfl + have e2 : 3 ^ (deep.length + 1 + 1) = 27 * 81 * (1 + 8 * t) := by + rw [hl, ht] + have hk : 1 + 2 * e + 1 + 1 = 3 + 2 * e := by omega + rw [hk, pow_K0 3 e he]; rfl + rw [e3] at eT; rw [e2] + have hT : T = ev [t] (tl1 3278 26244) := by simp only [ev, tl1, dot]; omega + have hF : 81 * (27 * 81 * (1 + 8 * t)) - 1 - ev [t] (tl1 3278 26244) = + ev [t] (tl1 173868 1390932) := by + simp only [ev, tl1, dot]; omega + rw [hT, hF]; exact hp + · exact stepPlus_trans (record_visit (deep.length + 1) (q :: deep) (evR [t] Re_r2) rfl) + (step_r2 t q deep) + +theorem S_r3 (e t f1 f2 f3 : Nat) (deep : List (List Nat)) + (he : 2 ≤ e) (ht : 1 + 8 * t = 9 ^ (e - 2)) (hl : deep.length = 2 + 2 * e) : + (Gc (rep .U0 (deep.length + 1), .P0, 0) ([W3t t, f1, f2, f3] :: deep) (evR [t] Rs_r3)) [tm372]⊢⁺ + Gc (rep .U0 (deep.length + 1), .P0, 0) ([f1, f2, f3, + rtop deep 0] :: rshift deep 0) (evR [t] Rs_r4) := by + refine stepStar_stepPlus_trans (interval_tm (deep.length + 1) ([W3t t, f1, f2, f3] :: deep) + (evR [t] Rs_r3) (evR [t] Re_r3) (by omega) rfl ?_) ?_ + · intro T eT + have hp := prog_check_spec int_r3 [t] + have e3 : 3 ^ (deep.length + 1 + 2) = 243 * 81 * (1 + 8 * t) := by + rw [hl, ht] + have hk : 2 + 2 * e + 1 + 2 = 5 + 2 * e := by omega + rw [hk, pow_K0 5 e he]; rfl + have e2 : 3 ^ (deep.length + 1 + 1) = 81 * 81 * (1 + 8 * t) := by + rw [hl, ht] + have hk : 2 + 2 * e + 1 + 1 = 4 + 2 * e := by omega + rw [hk, pow_K0 4 e he]; rfl + rw [e3] at eT; rw [e2] + have hT : T = ev [t] (tl1 9839 78732) := by simp only [ev, tl1, dot]; omega + have hF : 81 * (81 * 81 * (1 + 8 * t)) - 1 - ev [t] (tl1 9839 78732) = + ev [t] (tl1 521601 4172796) := by + simp only [ev, tl1, dot]; omega + rw [hT, hF]; exact hp + · exact stepPlus_trans (record_visit (deep.length + 1) ([W3t t, f1, f2, + f3] :: deep) (evR [t] Re_r3) rfl) + (step_r3 t f1 f2 f3 deep) + +theorem S_r4 (e t : Nat) (q : List Nat) (deep : List (List Nat)) + (he : 2 ≤ e) (ht : 1 + 8 * t = 9 ^ (e - 2)) (hl : deep.length = 2 + 2 * e) : + (Gc (rep .U0 (deep.length + 1), .P0, 0) (q :: deep) (evR [t] Rs_r4)) [tm372]⊢⁺ + Gc (rep .U0 (deep.length + 2), .P0, 0) + ([W5t (1 + 9 * t), W5s (1 + 9 * t), W5a (1 + 9 * t), q.getD 0 0] :: rshift (q :: deep) 0) + (evR [1 + 9 * t] Rs_r5) := by + refine stepStar_stepPlus_trans (interval_tm (deep.length + 1) (q :: deep) + (evR [t] Rs_r4) (evR [t] Re_r4) (by omega) rfl ?_) ?_ + · intro T eT + have hp := prog_check_spec int_r4 [t] + have e3 : 3 ^ (deep.length + 1 + 2) = 243 * 81 * (1 + 8 * t) := by + rw [hl, ht] + have hk : 2 + 2 * e + 1 + 2 = 5 + 2 * e := by omega + rw [hk, pow_K0 5 e he]; rfl + have e2 : 3 ^ (deep.length + 1 + 1) = 81 * 81 * (1 + 8 * t) := by + rw [hl, ht] + have hk : 2 + 2 * e + 1 + 1 = 4 + 2 * e := by omega + rw [hk, pow_K0 4 e he]; rfl + rw [e3] at eT; rw [e2] + have hT : T = ev [t] (tl1 9839 78732) := by simp only [ev, tl1, dot]; omega + have hF : 81 * (81 * 81 * (1 + 8 * t)) - 1 - ev [t] (tl1 9839 78732) = + ev [t] (tl1 521601 4172796) := by + simp only [ev, tl1, dot]; omega + rw [hT, hF]; exact hp + · exact stepPlus_trans (record_visit (deep.length + 1) (q :: deep) (evR [t] Re_r4) rfl) + (step_r4 t q deep) + +inductive cls where + | C5 | C0 | C1 | C2 | C3 | C4 + deriving DecidableEq + +def Rs : cls → List run + | .C5 => Rs_r5 + | .C0 => Rs_r0 + | .C1 => Rs_r1 + | .C2 => Rs_r2 + | .C3 => Rs_r3 + | .C4 => Rs_r4 + +abbrev ist := cls × Nat × Nat × List (List Nat) + +def cfgI : ist → Cfg6 + | (r, _, t, nus) => Gc (rep .U0 nus.length, .P0, 0) nus (evR [t] (Rs r)) + +def win : cls → Nat → Nat → List (List Nat) → Prop + | .C5, e, t, nus => ∃ f1 deep, nus = [W5t t, W5s t, W5a t, f1] :: deep ∧ deep.length = 1 + 2 * e + | .C0, e, t, nus => ∃ f1 f2 deep, nus = [W0t t, W0s t, f1, f2] :: deep ∧ deep.length = 1 + 2 * e + | .C1, e, t, nus => + ∃ f1 f2 f3 deep, nus = [W1t t, W1s t, W1a t, W1I t] :: [W1u t, f1, f2, + f3] :: deep ∧ deep.length = 1 + 2 * e + | .C2, e, _, nus => ∃ q deep, nus = q :: deep ∧ deep.length = 1 + 2 * e + | .C3, e, t, nus => ∃ f1 f2 f3 deep, nus = [W3t t, f1, f2, f3] :: deep ∧ deep.length = 2 + 2 * e + | .C4, e, _, nus => ∃ q deep, nus = q :: deep ∧ deep.length = 2 + 2 * e + +def Inv : ist → Prop + | (r, e, t, nus) => 2 ≤ e ∧ 1 + 8 * t = 9 ^ (e - 2) ∧ win r e t nus + +theorem inv_step (s : ist) (h : Inv s) : ∃ s', ((cfgI s) [tm372]⊢⁺ (cfgI s')) ∧ Inv s' := by + rcases s with ⟨r, e, t, nus⟩ + rcases h with ⟨he, ht, hw⟩ + cases r + · rcases hw with ⟨f1, deep, rfl, hl⟩ + refine ⟨(.C0, e, t, [W5s t, W5a t, f1, rtop deep 0] :: rshift deep 0), ?_, ?_⟩ + · simp only [cfgI, List.length_cons, shift_len, Rs] + exact S_r5 e t f1 deep he ht hl + · refine ⟨he, ht, f1, rtop deep 0, rshift deep 0, rfl, ?_⟩ + rw [shift_len, hl] + · rcases hw with ⟨f1, f2, deep, rfl, hl⟩ + refine ⟨(.C1, e, t, [W1t t, W1s t, W1a t, W1I t] :: [W0s t, f1, f2, + rtop deep 0] :: rshift deep 0), ?_, ?_⟩ + · simp only [cfgI, List.length_cons, shift_len, Rs] + exact S_r0 e t f1 f2 deep he ht hl + · refine ⟨he, ht, f1, f2, rtop deep 0, rshift deep 0, rfl, ?_⟩ + rw [shift_len, hl] + · rcases hw with ⟨f1, f2, f3, deep, rfl, hl⟩ + refine ⟨(.C2, e, t, [f1, f2, f3, rtop deep 0] :: rshift deep 0), ?_, ?_⟩ + · simp only [cfgI, List.length_cons, shift_len, Rs] + exact S_r1 e t f1 f2 f3 deep he ht hl + · refine ⟨he, ht, [f1, f2, f3, rtop deep 0], rshift deep 0, rfl, ?_⟩ + rw [shift_len, hl] + · rcases hw with ⟨q, deep, rfl, hl⟩ + refine ⟨(.C3, e, t, [W3t t, wv 6227 49896 t, wv 2069 16632 t, + q.getD 0 0] :: rshift (q :: deep) 0), ?_, ?_⟩ + · simp only [cfgI, List.length_cons, shift_len, Rs] + exact S_r2 e t q deep he ht hl + · refine ⟨he, ht, wv 6227 49896 t, wv 2069 16632 t, q.getD 0 0, rshift (q :: deep) 0, rfl, ?_⟩ + rw [shift_len, List.length_cons, hl]; omega + · rcases hw with ⟨f1, f2, f3, deep, rfl, hl⟩ + refine ⟨(.C4, e, t, [f1, f2, f3, rtop deep 0] :: rshift deep 0), ?_, ?_⟩ + · simp only [cfgI, List.length_cons, shift_len, Rs] + exact S_r3 e t f1 f2 f3 deep he ht hl + · refine ⟨he, ht, [f1, f2, f3, rtop deep 0], rshift deep 0, rfl, ?_⟩ + rw [shift_len, hl] + · rcases hw with ⟨q, deep, rfl, hl⟩ + refine ⟨(.C5, e + 1, 1 + 9 * t, [W5t (1 + 9 * t), W5s (1 + 9 * t), W5a (1 + 9 * t), + q.getD 0 0] :: rshift (q :: deep) 0), ?_, ?_⟩ + · simp only [cfgI, List.length_cons, shift_len, Rs] + exact S_r4 e t q deep he ht hl + · refine ⟨by omega, ?_, q.getD 0 0, rshift (q :: deep) 0, rfl, ?_⟩ + · have hsub : e + 1 - 2 = (e - 2) + 1 := by omega + rw [hsub, Nat.pow_succ, ← ht] + ring + · rw [shift_len, List.length_cons, hl]; omega + +def nus28_372 : List (List Nat) := + [[18701, 6227, 2069, 683], [242, 8, 9, 8], [10, 5, 3, 1], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, + 0]] + +def nus28_557 : List (List Nat) := + [[18701, 6227, 2069, 683], [242, 8, 9, 8], [10, 5, 4, 1], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, + 0]] + +def nus28_638 : List (List Nat) := + [[18701, 6227, 2069, 683], [233, 8, 9, 8], [12, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, + 0]] + +def eval_runs (nu : List Nat) (rs : List run) : List run := + rs.map (fun r => (r.1, cn (evN nu r.2))) + +theorem eval_runs_spec (nu : List Nat) (rs : List run) (X : Side6) : + ev_runs [] (eval_runs nu rs) X = ev_runs nu rs X := by + induction rs with + | nil => rfl + | cons r rs ih => + rcases r with ⟨b, n⟩ + change alt b (ev [] (cn (evN nu n))) +> ev_runs [] (eval_runs nu rs) X = + alt b (ev nu n) +> ev_runs nu rs X + rw [ih, ev_cn] + rfl + +def chs_runs : List lab → List (List Nat) → List run → List run + | s :: ls', nu :: nus', rest => eval_runs nu (blk s) ++ chs_runs ls' nus' rest + | _, _, rest => rest + +theorem chs_runs_spec (ls : List lab) (nus : List (List Nat)) (rest : List run) (X : Side6) : + ev_runs [] (chs_runs ls nus rest) X = chs ls nus (ev_runs [] rest X) := by + induction ls generalizing nus with + | nil => cases nus <;> rfl + | cons s ls ih => + cases nus with + | nil => rfl + | cons nu nus => + simp only [chs_runs, chs, ev_runs_app, ih, eval_runs_spec] + +def norm_sd : List run → sd + | [] => ([], .T0) + | (b, n) :: rs => push_run b (cn (ev [] n)) (norm_sd rs) + +theorem norm_sd_spec (rs : List run) : + ev_sd [] (fun _ => default) (norm_sd rs) = ev_runs [] rs default := by + induction rs with + | nil => rfl + | cons r rs ih => + rcases r with ⟨b, n⟩ + simp only [norm_sd] + rw [push_run_spec [] (fun _ => default) b (cn (ev [] n)) (norm_sd rs) rfl, ih] + rfl + +theorem norm_runs_eq {rs1 rs2 : List run} (h : sd_eqb (norm_sd rs1) (norm_sd rs2) = true) : + ev_runs [] rs1 default = ev_runs [] rs2 default := by + rw [← norm_sd_spec rs1, ← norm_sd_spec rs2] + exact sd_eqb_ev [] (fun _ => default) h + +theorem inv28_372 : Inv (.C5, 2, 0, nus28_372) := + ⟨by decide, rfl, 683, nus28_372.tail, rfl, rfl⟩ + +theorem inv28_557 : Inv (.C5, 2, 0, nus28_557) := + ⟨by decide, rfl, 683, nus28_557.tail, rfl, rfl⟩ + +theorem inv28_638 : Inv (.C5, 2, 0, nus28_638) := + ⟨by decide, rfl, 683, nus28_638.tail, rfl, rfl⟩ + +theorem b1s_lws_eq (p : lab1) (i : Nat) : b1s p (LWs i) = ev_runs [] (blk1 p ++ lw i) default := by + simp [b1s, LWs, ev_runs_app] + +theorem b28_right : evR [] (Rs_r5.map (fun r => (r.1, cn (evN [0] r.2)))) = evR [0] Rs_r5 := + eval_runs_spec [0] Rs_r5 default + +inductive Bit where + | b0 | b1 + deriving DecidableEq + +inductive St6 where + | A | B | C | D | E | F + deriving DecidableEq + +inductive CRun where + | mk (b : Bit) (n : Nat) + deriving DecidableEq + +inductive CState where + | mk (dir : Bool) (q : St6) (l r : List CRun) + deriving DecidableEq + +def consB0 (n : Nat) (rest : List CRun) : List CRun := + match Nat.add n 1 with + | 0 => rest + | .succ m => .mk .b0 m :: rest + +def consB1 (n : Nat) (rest : List CRun) : List CRun := + match Nat.add n 1 with + | 0 => rest + | .succ m => .mk .b1 m :: rest + +def cpush0 : List CRun → List CRun + | [] => [.mk .b0 1] + | .mk .b0 n0 :: rest => .mk .b0 1 :: .mk .b0 n0 :: rest + | .mk .b1 n0 :: rest => consB0 (Nat.add n0 1) rest + +def cpush1 : List CRun → List CRun + | [] => [.mk .b1 1] + | .mk .b1 n0 :: rest => .mk .b1 1 :: .mk .b1 n0 :: rest + | .mk .b0 n0 :: rest => consB1 (Nat.add n0 1) rest + +def cpushRun00 (n : Nat) : List CRun → List CRun + | [] => [.mk .b0 n] + | .mk .b0 n0 :: rest => consB0 (Nat.add n n0) rest + | .mk .b1 n0 :: rest => .mk .b0 n :: .mk .b1 n0 :: rest + +def cpushRun01 (n : Nat) : List CRun → List CRun + | [] => [.mk .b0 n] + | .mk .b1 n0 :: rest => consB0 (Nat.add n n0) rest + | .mk .b0 n0 :: rest => .mk .b0 n :: .mk .b0 n0 :: rest + +def cpushRun10 (n : Nat) : List CRun → List CRun + | [] => [.mk .b1 n] + | .mk .b0 n0 :: rest => consB1 (Nat.add n n0) rest + | .mk .b1 n0 :: rest => .mk .b1 n :: .mk .b1 n0 :: rest + +def cpushRun11 (n : Nat) : List CRun → List CRun + | [] => [.mk .b1 n] + | .mk .b1 n0 :: rest => consB1 (Nat.add n n0) rest + | .mk .b0 n0 :: rest => .mk .b1 n :: .mk .b0 n0 :: rest + +def mkStR (q : St6) (l r : List CRun) : CState := + match l with + | [] => .mk true q [] r + | l0 :: ls => .mk true q (l0 :: ls) r + +def mkStL' (q : St6) (l r : List CRun) : CState := + match r with + | [] => .mk false q l [] + | r0 :: rs => .mk false q l (r0 :: rs) + +def stepSingleR (q : St6) (s : Bit) (l r' : List CRun) : CState := + match q, s with + | .A, .b0 => mkStR .B (cpush1 l) r' + | .A, .b1 => mkStR .F (cpush0 l) r' + | .B, .b0 => mkStR .C (cpush1 l) r' + | .B, .b1 => mkStR .B (cpush0 l) r' + | .C, .b0 => mkStL' .D l (cpush1 r') + | .C, .b1 => mkStR .A (cpush0 l) r' + | .D, .b0 => mkStL' .E l (cpush1 r') + | .D, .b1 => mkStL' .D l (cpush0 r') + | .E, .b0 => mkStR .B (cpush1 l) r' + | .E, .b1 => mkStL' .C l (cpush0 r') + | .F, .b0 => mkStL' .A l (cpush1 r') + | .F, .b1 => .mk true q l r' + +def stepSingleL (q : St6) (s : Bit) (l' r : List CRun) : CState := + match q, s with + | .A, .b0 => mkStR .B (cpush1 l') r + | .A, .b1 => mkStR .F (cpush0 l') r + | .B, .b0 => mkStR .C (cpush1 l') r + | .B, .b1 => mkStR .B (cpush0 l') r + | .C, .b0 => mkStL' .D l' (cpush1 r) + | .C, .b1 => mkStR .A (cpush0 l') r + | .D, .b0 => mkStL' .E l' (cpush1 r) + | .D, .b1 => mkStL' .D l' (cpush0 r) + | .E, .b0 => mkStR .B (cpush1 l') r + | .E, .b1 => mkStL' .C l' (cpush0 r) + | .F, .b0 => mkStL' .A l' (cpush1 r) + | .F, .b1 => .mk false q l' r + +def popAndStepR (q : St6) (b : Bit) (n : Nat) (l r' : List CRun) : CState := + match Nat.beq n 1, b with + | true, .b0 => stepSingleR q .b0 l r' + | true, .b1 => stepSingleR q .b1 l r' + | false, .b0 => stepSingleR q .b0 l (consB1 (Nat.sub n 1) r') + | false, .b1 => stepSingleR q .b1 l (consB0 (Nat.sub n 1) r') + +def popAndStepL (q : St6) (b : Bit) (n : Nat) (l' r : List CRun) : CState := + match Nat.beq n 1, b with + | true, .b0 => stepSingleL q .b0 l' r + | true, .b1 => stepSingleL q .b1 l' r + | false, .b0 => stepSingleL q .b0 (consB1 (Nat.sub n 1) l') r + | false, .b1 => stepSingleL q .b1 (consB0 (Nat.sub n 1) l') r + +def csstep : CState → CState + | .mk true q l [] => stepSingleR q .b0 l [] + | .mk true q l (.mk b n :: r') => + match Nat.beq n 0 with + | true => .mk true q l r' + | false => + match q, b with + | .B, .b0 => + match Nat.mod n 4 with + | 0 => mkStR .B (cpushRun00 n l) r' + | 1 => mkStR .C (cpushRun10 n l) r' + | 2 => mkStR .A (cpushRun00 n l) r' + | _ => mkStR .B (cpushRun10 n l) r' + | .C, .b1 => + match Nat.mod n 4 with + | 0 => mkStR .C (cpushRun11 n l) r' + | 1 => mkStR .A (cpushRun01 n l) r' + | 2 => mkStR .B (cpushRun11 n l) r' + | _ => mkStR .B (cpushRun01 n l) r' + | .A, .b0 => + match Nat.mod n 4 with + | 0 => mkStR .A (cpushRun00 n l) r' + | 1 => mkStR .B (cpushRun10 n l) r' + | 2 => mkStR .B (cpushRun00 n l) r' + | _ => mkStR .C (cpushRun10 n l) r' + | .B, .b1 => + match Nat.mod n 4 with + | 0 => mkStR .B (cpushRun11 n l) r' + | 1 => mkStR .B (cpushRun01 n l) r' + | 2 => mkStR .C (cpushRun11 n l) r' + | _ => mkStR .A (cpushRun01 n l) r' + | .F, .b1 => .mk true .F l (.mk .b1 n :: r') + | _, _ => popAndStepR q b n l r' + | .mk false q [] r => stepSingleL q .b0 [] r + | .mk false q (.mk b n :: l') r => + match Nat.beq n 0 with + | true => .mk false q l' r + | false => + match q, b with + | .D, .b1 => + match Nat.mod n 4 with + | 0 => mkStL' .D l' (cpushRun11 n r) + | 1 => mkStL' .D l' (cpushRun01 n r) + | 2 => mkStL' .E l' (cpushRun11 n r) + | _ => mkStL' .C l' (cpushRun01 n r) + | .D, .b0 => + match Nat.mod n 4 with + | 0 => mkStL' .D l' (cpushRun00 n r) + | 1 => mkStL' .E l' (cpushRun10 n r) + | 2 => mkStL' .C l' (cpushRun00 n r) + | _ => mkStL' .D l' (cpushRun10 n r) + | .E, .b1 => + match Nat.mod n 4 with + | 0 => mkStL' .E l' (cpushRun11 n r) + | 1 => mkStL' .C l' (cpushRun01 n r) + | 2 => mkStL' .D l' (cpushRun11 n r) + | _ => mkStL' .D l' (cpushRun01 n r) + | .C, .b0 => + match Nat.mod n 4 with + | 0 => mkStL' .C l' (cpushRun00 n r) + | 1 => mkStL' .D l' (cpushRun10 n r) + | 2 => mkStL' .D l' (cpushRun00 n r) + | _ => mkStL' .E l' (cpushRun10 n r) + | .F, .b1 => .mk false .F (.mk .b1 n :: l') r + | _, _ => popAndStepL q b n l' r + +def cstep2n : Nat → CState → CState + | 0, st => csstep st + | k + 1, st => + match cstep2n k st with + | .mk d q l r => cstep2n k (.mk d q l r) + +def evBit : Bit → Sym2 + | .b0 => 0 + | .b1 => 1 + +def evSt6 : St6 → Fin 6 + | .A => A | .B => B | .C => C | .D => D | .E => E | .F => F + +def toRun : CRun → run + | .mk b n => (evBit b, cn n) + +def toSd (rs : List CRun) : sd := + (rs.map toRun, .T0) + +def toCfg : CState → cfg + | .mk true q l r => .Rc (evSt6 q) (toSd l) (toSd r) + | .mk false q l r => .Lc (evSt6 q) (toSd l) (toSd r) + +theorem consB0_eq (n : Nat) (rest : List CRun) : consB0 n rest = .mk .b0 n :: rest := rfl +theorem consB1_eq (n : Nat) (rest : List CRun) : consB1 n rest = .mk .b1 n :: rest := rfl + +theorem mkStR_eq (q : St6) (l r : List CRun) : mkStR q l r = .mk true q l r := by + cases l <;> rfl + +theorem mkStL'_eq (q : St6) (l r : List CRun) : mkStL' q l r = .mk false q l r := by + cases r <;> rfl + +theorem toSd_cpush0 (l : List CRun) : toSd (cpush0 l) = push 0 (toSd l) := by + rcases l with _ | ⟨⟨_ | _, n0⟩, rest⟩ <;> rfl + +theorem toSd_cpush1 (l : List CRun) : toSd (cpush1 l) = push 1 (toSd l) := by + rcases l with _ | ⟨⟨_ | _, n0⟩, rest⟩ <;> rfl + +theorem lf_add_cn (n n0 : Nat) : lf_add (cn n) (cn n0) = cn (n + n0) := rfl + +theorem toSd_cpushRun00 (n : Nat) (l : List CRun) (h : afterb 0 (cn n) = 0) : + toSd (cpushRun00 n l) = push_run 0 (cn n) (toSd l) := by + rcases l with _ | ⟨⟨_ | _, n0⟩, rest⟩ <;> + simp [cpushRun00, consB0_eq, toSd, toRun, evBit, push_run, h, seqb, lf_add_cn] + +theorem toSd_cpushRun01 (n : Nat) (l : List CRun) (h : afterb 0 (cn n) = 1) : + toSd (cpushRun01 n l) = push_run 0 (cn n) (toSd l) := by + rcases l with _ | ⟨⟨_ | _, n0⟩, rest⟩ <;> + simp [cpushRun01, consB0_eq, toSd, toRun, evBit, push_run, h, seqb, lf_add_cn] + +theorem toSd_cpushRun10 (n : Nat) (l : List CRun) (h : afterb 1 (cn n) = 0) : + toSd (cpushRun10 n l) = push_run 1 (cn n) (toSd l) := by + rcases l with _ | ⟨⟨_ | _, n0⟩, rest⟩ <;> + simp [cpushRun10, consB1_eq, toSd, toRun, evBit, push_run, h, seqb, lf_add_cn] + +theorem toSd_cpushRun11 (n : Nat) (l : List CRun) (h : afterb 1 (cn n) = 1) : + toSd (cpushRun11 n l) = push_run 1 (cn n) (toSd l) := by + rcases l with _ | ⟨⟨_ | _, n0⟩, rest⟩ <;> + simp [cpushRun11, consB1_eq, toSd, toRun, evBit, push_run, h, seqb, lf_add_cn] + +def cpopRest (b : Bit) (n : Nat) (r' : List CRun) : List CRun := + match Nat.beq n 1, b with + | true, .b0 => r' + | true, .b1 => r' + | false, .b0 => consB1 (Nat.sub n 1) r' + | false, .b1 => consB0 (Nat.sub n 1) r' + +theorem popAndStepR_eq (q : St6) (b : Bit) (n : Nat) (l r' : List CRun) : + popAndStepR q b n l r' = stepSingleR q b l (cpopRest b n r') := by + unfold popAndStepR cpopRest + cases Nat.beq n 1 <;> cases b <;> rfl + +theorem popAndStepL_eq (q : St6) (b : Bit) (n : Nat) (l' r : List CRun) : + popAndStepL q b n l' r = stepSingleL q b (cpopRest b n l') r := by + unfold popAndStepL cpopRest + cases Nat.beq n 1 <;> cases b <;> rfl + +theorem beq_eq_nat_beq (n k : Nat) : (n == k) = Nat.beq n k := by + rw [Bool.eq_iff_iff, beq_iff_eq, Nat.beq_eq] + +theorem is_zero_cn (n : Nat) : is_zero (cn n) = Nat.beq n 0 := by + simp [is_zero, cn, allz, beq_eq_nat_beq] + +theorem is_one_cn (n : Nat) : is_one (cn n) = Nat.beq n 1 := by + simp [is_one, cn, allz, beq_eq_nat_beq] + +theorem posb_cn (n : Nat) : posb (cn n) = !(Nat.beq n 0) := by + simp [posb, cn, beq_eq_nat_beq] + +theorem toSd_nil : toSd [] = ([], .T0) := rfl + +theorem toSd_cons (b : Bit) (n : Nat) (rs : List CRun) : + toSd (.mk b n :: rs) = ((evBit b, cn n) :: (toSd rs).1, .T0) := rfl + +theorem pop_toSd_b0 (n : Nat) (r' : List CRun) (hz : Nat.beq n 0 = false) : + pop ((0, cn n) :: (toSd r').1, .T0) = some (0, toSd (cpopRest .b0 n r')) := by + unfold pop pop_runs cpopRest + rw [is_zero_cn, posb_cn, is_one_cn, hz] + cases Nat.beq n 1 <;> rfl + +theorem pop_toSd_b1 (n : Nat) (r' : List CRun) (hz : Nat.beq n 0 = false) : + pop ((1, cn n) :: (toSd r').1, .T0) = some (1, toSd (cpopRest .b1 n r')) := by + unfold pop pop_runs cpopRest + rw [is_zero_cn, posb_cn, is_one_cn, hz] + cases Nat.beq n 1 <;> rfl + +theorem mod4_cases (n : Nat) : + n % 4 = 0 ∨ n % 4 = 1 ∨ n % 4 = 2 ∨ n % 4 = 3 := by omega + +theorem mod2_of_mod4 (n : Nat) : n % 2 = (n % 4) % 2 := by omega + +theorem cn_lc (n : Nat) : (cn n).lc = n := rfl +theorem cn_lv (n : Nat) : (cn n).lv = [] := rfl + +theorem lastb_cn (b : Sym2) (n : Nat) : + lastb b (cn n) = if (n % 4) % 2 == 0 then sneg b else b := by + unfold lastb cn + dsimp + rw [mod2_of_mod4] + +theorem afterb_cn (c : Sym2) (n : Nat) : + afterb c (cn n) = if (n % 4) % 2 == 0 then c else sneg c := by + unfold afterb cn + dsimp + rw [mod2_of_mod4] + +theorem toCfg_csstep (st : CState) : toCfg (csstep st) = urun 1 (toCfg st) := by + rcases st with ⟨_ | _, q, l, r⟩ + · -- dir = false (Lc) + rcases l with _ | ⟨⟨b, n⟩, l'⟩ + · -- l = [] + cases q <;> + simp [csstep, stepSingleL, mkStR_eq, mkStL'_eq, toCfg, toSd_nil, toSd_cpush1, + urun, sstep, tag, single, pop, pop_runs, evSt6, tm372] + · -- l = .mk b n :: l' + simp only [csstep] + rcases hz : Nat.beq n 0 + · -- Nat.beq n 0 = false + have hzne : is_zero (cn n) = false := by rw [is_zero_cn, hz] + have hpop0 := pop_toSd_b0 n l' hz + have hpop1 := pop_toSd_b1 n l' hz + cases q <;> cases b + · -- A, b0 + simp [popAndStepL_eq, stepSingleL, mkStR_eq, toCfg, toSd_cons, + toSd_cpush1, + urun, sstep, hzne, cL_idx, evSt6, evBit, tag, single, hpop0, tm372] + · -- A, b1 + simp [popAndStepL_eq, stepSingleL, mkStR_eq, toCfg, toSd_cons, toSd_cpush0, + urun, sstep, hzne, cL_idx, evSt6, evBit, tag, single, hpop1, tm372] + · -- B, b0 + simp [popAndStepL_eq, stepSingleL, mkStR_eq, toCfg, toSd_cons, + toSd_cpush1, + urun, sstep, hzne, cL_idx, evSt6, evBit, tag, single, hpop0, tm372] + · -- B, b1 + simp [popAndStepL_eq, stepSingleL, mkStR_eq, toCfg, toSd_cons, toSd_cpush0, + urun, sstep, hzne, cL_idx, evSt6, evBit, tag, single, hpop1, tm372] + · -- C, b0 (accelerated) + change toCfg (match n % 4 with | 0 => _ | 1 => _ | 2 => _ | _ => _) = _ + rcases mod4_cases n with h4 | h4 | h4 | h4 + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun00 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun10 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun00 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun10 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · -- C, b1 + simp [popAndStepL_eq, stepSingleL, mkStR_eq, toCfg, toSd_cons, toSd_cpush0, + urun, sstep, hzne, cL_idx, evSt6, evBit, tag, single, hpop1, tm372] + · -- D, b0 (accelerated) + change toCfg (match n % 4 with | 0 => _ | 1 => _ | 2 => _ | _ => _) = _ + rcases mod4_cases n with h4 | h4 | h4 | h4 + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun00 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun10 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun00 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun10 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · -- D, b1 (accelerated) + change toCfg (match n % 4 with | 0 => _ | 1 => _ | 2 => _ | _ => _) = _ + rcases mod4_cases n with h4 | h4 | h4 | h4 + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun11 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun01 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun11 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun01 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · -- E, b0 + simp [popAndStepL_eq, stepSingleL, mkStR_eq, toCfg, toSd_cons, + toSd_cpush1, + urun, sstep, hzne, cL_idx, evSt6, evBit, tag, single, hpop0, tm372] + · -- E, b1 (accelerated) + change toCfg (match n % 4 with | 0 => _ | 1 => _ | 2 => _ | _ => _) = _ + rcases mod4_cases n with h4 | h4 | h4 | h4 + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun11 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun01 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun11 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStL'_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cL_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun01 n r (by rw [afterb_cn, h4]; rfl)]; rfl + · -- F, b0 + simp [popAndStepL_eq, stepSingleL, mkStL'_eq, toCfg, toSd_cons, + toSd_cpush1, + urun, sstep, hzne, cL_idx, evSt6, evBit, tag, single, hpop0, tm372] + · -- F, b1 (halting) + simp [toCfg, toSd_cons, urun, sstep, hzne, cL_idx, evSt6, evBit, tag, single, hpop1, + tm372] + · -- Nat.beq n 0 = true + have hzeq : is_zero (cn n) = true := by rw [is_zero_cn, hz] + simp [toCfg, toSd, toRun, urun, sstep, hzeq] + · -- dir = true (Rc) + rcases r with _ | ⟨⟨b, n⟩, r'⟩ + · -- r = [] + cases q <;> + simp [csstep, stepSingleR, mkStR_eq, mkStL'_eq, toCfg, toSd_nil, toSd_cpush1, + urun, sstep, tag, single, pop, pop_runs, evSt6, tm372] + · -- r = .mk b n :: r' + simp only [csstep] + rcases hz : Nat.beq n 0 + · -- Nat.beq n 0 = false + have hzne : is_zero (cn n) = false := by rw [is_zero_cn, hz] + have hpop0 := pop_toSd_b0 n r' hz + have hpop1 := pop_toSd_b1 n r' hz + cases q <;> cases b + · -- A, b0 (accelerated) + change toCfg (match n % 4 with | 0 => _ | 1 => _ | 2 => _ | _ => _) = _ + rcases mod4_cases n with h4 | h4 | h4 | h4 + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun00 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun10 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun00 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun10 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · -- A, b1 + simp [popAndStepR_eq, stepSingleR, mkStR_eq, toCfg, toSd_cons, toSd_cpush0, + urun, sstep, hzne, cR_idx, evSt6, evBit, tag, single, hpop1, tm372] + · -- B, b0 (accelerated) + change toCfg (match n % 4 with | 0 => _ | 1 => _ | 2 => _ | _ => _) = _ + rcases mod4_cases n with h4 | h4 | h4 | h4 + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun00 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun10 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun00 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun10 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · -- B, b1 (accelerated) + change toCfg (match n % 4 with | 0 => _ | 1 => _ | 2 => _ | _ => _) = _ + rcases mod4_cases n with h4 | h4 | h4 | h4 + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun11 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun01 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun11 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun01 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · -- C, b0 + simp [popAndStepR_eq, stepSingleR, mkStL'_eq, toCfg, toSd_cons, + toSd_cpush1, + urun, sstep, hzne, cR_idx, evSt6, evBit, tag, single, hpop0, tm372] + · -- C, b1 (accelerated) + change toCfg (match n % 4 with | 0 => _ | 1 => _ | 2 => _ | _ => _) = _ + rcases mod4_cases n with h4 | h4 | h4 | h4 + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun11 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun01 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun11 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · simp only [cn_lc, cn_lv, h4, mkStR_eq, toCfg, toSd_cons, urun, sstep, evSt6, evBit, + hzne, Bool.false_eq_true, ↓reduceIte, cR_idx, all4, List.all_nil, lastb_cn] + rw [toSd_cpushRun01 n l (by rw [afterb_cn, h4]; rfl)]; rfl + · -- D, b0 + simp [popAndStepR_eq, stepSingleR, mkStL'_eq, toCfg, toSd_cons, + toSd_cpush1, + urun, sstep, hzne, cR_idx, evSt6, evBit, tag, single, hpop0, tm372] + · -- D, b1 + simp [popAndStepR_eq, stepSingleR, mkStL'_eq, toCfg, toSd_cons, toSd_cpush0, + urun, sstep, hzne, cR_idx, evSt6, evBit, tag, single, hpop1, tm372] + · -- E, b0 + simp [popAndStepR_eq, stepSingleR, mkStR_eq, toCfg, toSd_cons, + toSd_cpush1, + urun, sstep, hzne, cR_idx, evSt6, evBit, tag, single, hpop0, tm372] + · -- E, b1 + simp [popAndStepR_eq, stepSingleR, mkStL'_eq, toCfg, toSd_cons, toSd_cpush0, + urun, sstep, hzne, cR_idx, evSt6, evBit, tag, single, hpop1, tm372] + · -- F, b0 + simp [popAndStepR_eq, stepSingleR, mkStL'_eq, toCfg, toSd_cons, + toSd_cpush1, + urun, sstep, hzne, cR_idx, evSt6, evBit, tag, single, hpop0, tm372] + · -- F, b1 (halting) + simp [toCfg, toSd_cons, urun, sstep, hzne, cR_idx, evSt6, evBit, tag, single, hpop1, + tm372] + · -- Nat.beq n 0 = true + have hzeq : is_zero (cn n) = true := by rw [is_zero_cn, hz] + simp [toCfg, toSd, toRun, urun, sstep, hzeq] + +theorem csstep_spec (st : CState) : + (ev_cfg [] (fun _ => default) (toCfg st)) [tm372]⊢* (ev_cfg [] (fun _ => + default) (toCfg (csstep st))) := by + rw [toCfg_csstep] + exact urun_spec 1 (toCfg st) [] (fun _ => default) + +theorem cstep2n_spec (k : Nat) (st : CState) : + (ev_cfg [] (fun _ => default) (toCfg st)) [tm372]⊢* (ev_cfg [] (fun _ => + default) (toCfg (cstep2n k st))) := by + induction k generalizing st with + | zero => exact csstep_spec st + | succ k ih => + simp only [cstep2n] + have h1 := ih st + rcases hst : cstep2n k st with ⟨d, q, l, r⟩ + rw [hst] at h1 + exact stepStar_trans h1 (ih (.mk d q l r)) + +def csstepN : Nat → CState → CState + | 0, st => st + | k + 1, st => csstepN k (csstep st) + +theorem csstepN_spec (k : Nat) (st : CState) : + (ev_cfg [] (fun _ => default) (toCfg st)) [tm372]⊢* + (ev_cfg [] (fun _ => default) (toCfg (csstepN k st))) := by + induction k generalizing st with + | zero => exact ⟨0, rfl⟩ + | succ k ih => exact stepStar_trans (csstep_spec st) (ih (csstep st)) + +theorem chain_cstep2n (k : Nat) (s1 s2 s3 : CState) + (h1 : cstep2n k s1 = s2) + (h2 : (ev_cfg [] (fun _ => default) (toCfg s2)) [tm372]⊢* (ev_cfg [] (fun _ => + default) (toCfg s3))) : + (ev_cfg [] (fun _ => default) (toCfg s1)) [tm372]⊢* (ev_cfg [] (fun _ => default) (toCfg s3)) := + by + have hc := cstep2n_spec k s1 + rw [h1] at hc + exact stepStar_trans hc h2 + +theorem step_to_Gc (extra m : Nat) (rem r Rs : List run) (nus : List (List Nat)) + (h1 : sd_eqb (norm_sd ((0, cn (extra + 3)) :: rem)) (norm_sd ((0, cn extra) :: (0, + cn 3) :: rem)) = true) + (h2 : urun 1 (.Lc D ([(0, cn extra)], .TV 0) (r, .T0)) = .Lc D ([], .TV 0) (Rs, .T0)) + (h3 : sd_eqb (norm_sd ((0, + cn 3) :: rem)) (norm_sd (chs_runs (rep .U0 m) nus (blk1 .P0 ++ lw 0))) = true) : + ((ev_runs [] ((0, cn (extra + 3)) :: rem) default) <{{D}} (evR [] r)) [tm372]⊢* + Gc (rep .U0 m, .P0, 0) nus (evR [] Rs) := by + have heq1 : ev_runs [] ((0, cn (extra + 3)) :: rem) default = + ev_runs [] [(0, cn extra)] (ev_runs [] ((0, cn 3) :: rem) default) := by + rw [← ev_runs_app] + exact norm_runs_eq h1 + have heq2 : ev_runs [] ((0, cn 3) :: rem) default = chs (rep .U0 m) nus (b1s .P0 (LWs 0)) := by + rw [b1s_lws_eq, ← chs_runs_spec] + exact norm_runs_eq h3 + rw [heq1, heq2] + have hu := urun_spec 1 (.Lc D ([(0, cn extra)], .TV 0) (r, .T0)) [] + (fun _ => chs (rep .U0 m) nus (b1s .P0 (LWs 0))) + rw [h2] at hu + exact hu + +theorem run_concrete_interval (m : Nat) (nus : List (List Nat)) (prog : List instr) (Rs Re : List + run) (T F_cnt : Nat) + (hm : 2 ≤ m) (hlen : nus.length = m) + (heT : 2 * T + 5 = 3 ^ (m + 2)) + (heF : F_cnt = 81 * 3 ^ (m + 1) - 1 - T) + (hp : prog_check prog Rs Re (cn T) (cn F_cnt) = true) : + (Gc (rep .U0 m, .P0, 0) nus (evR [] Rs)) [tm372]⊢⁺ + ((ev_runs [] [(0, cn 1), (0, cn (2 + 4 * rtop nus 0))] + (chs (rep .U0 m) (rshift nus 0) (b1s .P0 (LWs 0)))) {{B}}> (evR [] Re)) := by + have hint : (Gc (rep .U0 m, .P0, 0) nus (evR [] Rs)) [tm372]⊢* + (Gc (rep .D0 m, .PD0, 80) nus (evR [] Re)) := by + refine interval_tm m nus (evR [] Rs) (evR [] Re) hm hlen ?_ + intro T' hT' + have hTeq : T' = T := by omega + subst hTeq + rw [← heF] + exact prog_check_spec hp [] + have hrec : (Gc (rep .D0 m, .PD0, 80) nus (evR [] Re)) [tm372]⊢⁺ + ((chs (rep .D2 m) nus (b1s .PD2 (LWs 81))) {{B}}> (evR [] Re)) := + record_visit m nus (evR [] Re) hlen + have htot := stepStar_stepPlus_trans hint hrec + have hreg := regroup nus 0 (b1s .PD2 (LWs 81)) (b1s .P0 (LWs 0)) regroup_b1 + rw [hlen] at hreg + rw [hreg] at htot + exact htot + +theorem Gc_to_after (m : Nat) (nus : List (List Nat)) (prog : List instr) (Rs Re : List run) (T + F_cnt : Nat) + (l_after r_after : List CRun) + (hm : 2 ≤ m) (hlen : nus.length = m) + (heT : 2 * T + 5 = 3 ^ (m + 2)) + (heF : F_cnt = 81 * 3 ^ (m + 1) - 1 - T) + (hp : prog_check prog Rs Re (cn T) (cn F_cnt) = true) + (h_out_L : sd_eqb (norm_sd ([(0, cn 1), (0, cn (2 + 4 * rtop nus 0))] ++ + chs_runs (rep .U0 m) (rshift nus 0) (blk1 .P0 ++ lw 0))) + (norm_sd (l_after.map toRun)) = true) + (h_out_R : r_after.map toRun = Re) : + (Gc (rep .U0 m, .P0, 0) nus (evR [] Rs)) [tm372]⊢⁺ + ev_cfg [] (fun _ => default) (toCfg (.mk true .B l_after r_after)) := by + have h1 := run_concrete_interval m nus prog Rs Re T F_cnt hm hlen heT heF hp + have heqL : ev_runs [] [(0, cn 1), (0, cn (2 + 4 * rtop nus 0))] + (chs (rep .U0 m) (rshift nus 0) (b1s .P0 (LWs 0))) = + ev_runs [] (l_after.map toRun) default := by + rw [b1s_lws_eq, ← chs_runs_spec, ← ev_runs_app] + exact norm_runs_eq h_out_L + change _ [tm372]⊢⁺ ((ev_runs [] (l_after.map toRun) default) {{B}}> (evR [] (r_after.map toRun))) + rw [← heqL, h_out_R] + exact h1 + +theorem interval_step_zero (m T F_cnt k : Nat) (l r l_after r_after : List CRun) + (nus : List (List Nat)) (prog : List instr) (Rs Re : List run) (st_next : CState) + (h_in_L : sd_eqb (norm_sd (l.map toRun)) (norm_sd (chs_runs (rep .U0 m) nus (blk1 .P0 ++ + lw 0))) = true) + (h_in_R : r.map toRun = Rs) + (hm : 2 ≤ m) (hlen : nus.length = m) + (heT : 2 * T + 5 = 3 ^ (m + 2)) + (heF : F_cnt = 81 * 3 ^ (m + 1) - 1 - T) + (hp : prog_check prog Rs Re (cn T) (cn F_cnt) = true) + (h_out_L : sd_eqb (norm_sd ([(0, cn 1), (0, cn (2 + 4 * rtop nus 0))] ++ + chs_runs (rep .U0 m) (rshift nus 0) (blk1 .P0 ++ lw 0))) + (norm_sd (l_after.map toRun)) = true) + (h_out_R : r_after.map toRun = Re) + (hk : csstepN k (.mk true .B l_after r_after) = st_next) : + (ev_cfg [] (fun _ => default) (toCfg (.mk false .D l r))) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st_next)) := by + have heqL : ev_runs [] (l.map toRun) default = chs (rep .U0 m) nus (b1s .P0 (LWs 0)) := by + rw [b1s_lws_eq, ← chs_runs_spec] + exact norm_runs_eq h_in_L + have hin : ev_cfg [] (fun _ => default) (toCfg (.mk false .D l r)) = + Gc (rep .U0 m, .P0, 0) nus (evR [] Rs) := by + change ((ev_runs [] (l.map toRun) default) <{{D}} (evR [] (r.map toRun))) = _ + rw [heqL, h_in_R] + rfl + rw [hin] + have hmid := + Gc_to_after m nus prog Rs Re T F_cnt l_after r_after hm hlen heT heF hp h_out_L h_out_R + have hout := csstepN_spec k (.mk true .B l_after r_after) + rw [hk] at hout + exact stepPlus_stepStar_trans hmid hout + +theorem interval_step_pos (extra m T F_cnt k : Nat) (l r l_after r_after : List CRun) + (nus : List (List Nat)) (prog : List instr) (Rs Re : List run) (st_next : CState) + (h_l : l.map toRun = (0, cn (extra + 3)) :: (l.tail.map toRun)) + (h1 : sd_eqb (norm_sd ((0, cn (extra + 3)) :: (l.tail.map toRun))) + (norm_sd ((0, cn extra) :: (0, cn 3) :: (l.tail.map toRun))) = true) + (h2 : urun 1 (.Lc D ([(0, cn extra)], .TV 0) (r.map toRun, .T0)) = .Lc D ([], .TV 0) (Rs, .T0)) + (h3 : sd_eqb (norm_sd ((0, cn 3) :: (l.tail.map toRun))) + (norm_sd (chs_runs (rep .U0 m) nus (blk1 .P0 ++ lw 0))) = true) + (hm : 2 ≤ m) (hlen : nus.length = m) + (heT : 2 * T + 5 = 3 ^ (m + 2)) + (heF : F_cnt = 81 * 3 ^ (m + 1) - 1 - T) + (hp : prog_check prog Rs Re (cn T) (cn F_cnt) = true) + (h_out_L : sd_eqb (norm_sd ([(0, cn 1), (0, cn (2 + 4 * rtop nus 0))] ++ + chs_runs (rep .U0 m) (rshift nus 0) (blk1 .P0 ++ lw 0))) + (norm_sd (l_after.map toRun)) = true) + (h_out_R : r_after.map toRun = Re) + (hk : csstepN k (.mk true .B l_after r_after) = st_next) : + (ev_cfg [] (fun _ => default) (toCfg (.mk false .D l r))) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st_next)) := by + have hin : ev_cfg [] (fun _ => default) (toCfg (.mk false .D l r)) = + ((ev_runs [] ((0, + cn (extra + 3)) :: (l.tail.map toRun)) default) <{{D}} (evR [] (r.map toRun))) := by + change ((ev_runs [] (l.map toRun) default) <{{D}} (evR [] (r.map toRun))) = _ + rw [h_l] + rw [hin] + have hpre := step_to_Gc extra m (l.tail.map toRun) (r.map toRun) Rs nus h1 h2 h3 + have hmid := + Gc_to_after m nus prog Rs Re T F_cnt l_after r_after hm hlen heT heF hp h_out_L h_out_R + have hout := csstepN_spec k (.mk true .B l_after r_after) + rw [hk] at hout + exact stepPlus_stepStar_trans (stepStar_stepPlus_trans hpre hmid) hout + +theorem final_to_cfgI (extra : Nat) (l r : List CRun) (nus28 : List (List Nat)) + (h_l : l.map toRun = (0, cn (extra + 3)) :: (l.tail.map toRun)) + (h1 : sd_eqb (norm_sd ((0, cn (extra + 3)) :: (l.tail.map toRun))) + (norm_sd ((0, cn extra) :: (0, cn 3) :: (l.tail.map toRun))) = true) + (h2 : urun 1 (.Lc D ([(0, cn extra)], .TV 0) (r.map toRun, .T0)) = + .Lc D ([], .TV 0) (Rs_r5.map (fun x => (x.1, cn (evN [0] x.2))), .T0)) + (h3 : sd_eqb (norm_sd ((0, cn 3) :: (l.tail.map toRun))) + (norm_sd (chs_runs (rep .U0 6) nus28 (blk1 .P0 ++ lw 0))) = true) + (hlen : nus28.length = 6) : + (ev_cfg [] (fun _ => default) (toCfg (.mk false .D l r))) [tm372]⊢* + cfgI (.C5, 2, 0, nus28) := by + have hin : ev_cfg [] (fun _ => default) (toCfg (.mk false .D l r)) = + ((ev_runs [] ((0, + cn (extra + 3)) :: (l.tail.map toRun)) default) <{{D}} (evR [] (r.map toRun))) := by + change ((ev_runs [] (l.map toRun) default) <{{D}} (evR [] (r.map toRun))) = _ + rw [h_l] + rw [hin] + have hpre := step_to_Gc extra 6 (l.tail.map toRun) (r.map toRun) + (Rs_r5.map (fun x => (x.1, cn (evN [0] x.2)))) nus28 h1 h2 h3 + rw [b28_right] at hpre + rw [cfgI, Gc, Rs, hlen] + exact hpre + +theorem isNotHalt_of_reach_cfgI (s : ist) (hinit : (init []) [tm372]⊢* (cfgI s)) (hs : Inv s) : + IsNotHalt tm372 := by + refine IsNotHalt.of_reachesPlus_invariant (M := tm372) (P := + fun x => ∃ s', x = cfgI s' ∧ Inv s') hinit ⟨s, rfl, hs⟩ ?_ + rintro x ⟨s', rfl, hs'⟩ + rcases inv_step s' hs' with ⟨s'', hstep, hinv''⟩ + exact ⟨cfgI s'', hstep, s'', rfl, hinv''⟩ + + +def Rs_c1 : List run := [(1, cn 6445), (1, cn 1)] +def Re_c1 : List run := [(0, cn 4), (1, cn 6800), (0, cn 19318), (1, cn 1)] +def r_after_c1 : List CRun := [.mk .b0 4, .mk .b1 6800, .mk .b0 19318, .mk .b1 1] +def prog_c1 : List instr := + [.IJump true (cn 29), .ISingle true, .ISingle true, .ISingle true, .ISingle false, + .ISingle false, .IJump false (cn 1609), .ISingle false, .ISingle false, .ISingle false] +theorem int_c1 : prog_check prog_c1 Rs_c1 Re_c1 (cn 119) (cn 6441) = true := by decide +kernel + +def Rs_c2 : List run := [(0, cn 24908), (1, cn 7), (1, cn 6800), (0, cn 19329), (0, cn 2)] +def Re_c2 : List run := [(0, cn 24908), (1, cn 8), (0, cn 361), (0, cn 71921), (0, cn 2)] +def r_after_c2 : List CRun := [.mk .b0 24908, .mk .b1 8, .mk .b0 361, .mk .b0 71921, .mk .b0 2] +def prog_c2 : List instr := + [.IJump true (cn 29), .ISingle true, .ISingle true, .ISingle true, .ISingle false, + .IJump false (cn 1610)] +theorem int_c2 : prog_check prog_c2 Rs_c2 Re_c2 (cn 119) (cn 6441) = true := by decide +kernel + +def Rs_c3 : List run := + [(0, cn 8276), (1, cn 24911), (1, cn 7), (1, cn 361), (1, cn 71936), (0, cn 2)] +def Re_c3 : List run := + [(0, cn 8276), (1, cn 24912), (0, cn 74808), (1, cn 3), (1, cn 19321), (1, cn 1)] +def r_after_c3 : List CRun := + [.mk .b0 8276, .mk .b1 24912, .mk .b0 74808, .mk .b1 3, .mk .b1 19321, .mk .b1 1] +def prog_c3 : List instr := + [.IJump true (cn 29), .ISingle true, .ISingle true, .ISingle true, .ISingle false, + .ISingle false, .IJump false (cn 1609), .ISingle false, .ISingle false, .ISingle false] +theorem int_c3 : prog_check prog_c3 Rs_c3 Re_c3 (cn 119) (cn 6441) = true := by decide +kernel + +def Rs_c4 : List run := + [(0, cn 2732), (1, cn 8279), (1, cn 24912), (0, cn 74808), (1, cn 4), (0, cn 19330)] +def Re_c4 : List run := + [(0, cn 2732), (1, cn 8280), (0, cn 24912), (1, cn 74807), (1, cn 7), (1, cn 20408), (0, + cn 57957), (0, cn 2)] +def r_after_c4 : List CRun := + [.mk .b0 2732, .mk .b1 8280, .mk .b0 24912, .mk .b1 74807, .mk .b1 7, .mk .b1 20408, + .mk .b0 57957, .mk .b0 2] +def prog_c4 : List instr := + [.IJump true (cn 29), .ISingle true, .ISingle true, .ISingle true, .ISingle false, + .ISingle false, .IJump false (cn 1609), .ISingle false, .ISingle false, .ISingle false] +theorem int_c4 : prog_check prog_c4 Rs_c4 Re_c4 (cn 119) (cn 6441) = true := by decide +kernel + +def Rs_c5 : List run := [(0, cn 74804), (1, cn 7), (1, cn 20407), (1, cn 57965), (1, cn 1)] +def Re_c5 : List run := [(0, cn 74804), (1, cn 7), (1, cn 1093), (1, cn 215768), (0, cn 2)] +def r_after_c5 : List CRun := [.mk .b0 74804, .mk .b1 7, .mk .b1 1093, .mk .b1 215768, .mk .b0 2] +def prog_c5 : List instr := + [.IJump true (cn 90), .ISingle true, .ISingle true, .ISingle false, .IJump false (cn 4829), + .ISingle false, .ISingle false, .ISingle false] +theorem int_c5 : prog_check prog_c5 Rs_c5 Re_c5 (cn 362) (cn 19320) = true := by decide +kernel + +def Rs_c6 : List run := [(0, cn 24908), (1, cn 74807), (1, cn 8), (0, cn 1088), (1, cn 215797)] +def Re_c6 : List run := [(0, cn 24908), (1, cn 74808), (0, cn 224496), (1, cn 4), (0, cn 57958)] +def r_after_c6 : List CRun := + [.mk .b0 24908, .mk .b1 74808, .mk .b0 224496, .mk .b1 4, .mk .b0 57958] +def prog_c6 : List instr := + [.IJump true (cn 90), .ISingle true, .ISingle true, .ISingle false, .ISingle false, + .IJump false (cn 4829), .ISingle false, .ISingle false] +theorem int_c6 : prog_check prog_c6 Rs_c6 Re_c6 (cn 362) (cn 19320) = true := by decide +kernel + +def Rs_c7 : List run := [(1, cn 57961), (1, cn 1)] +def Re_c7 : List run := [(0, cn 4), (1, cn 61232), (0, cn 173866), (1, cn 1)] +def r_after_c7 : List CRun := [.mk .b0 4, .mk .b1 61232, .mk .b0 173866, .mk .b1 1] +def prog_c7 : List instr := + [.IJump true (cn 272), .ISingle true, .ISingle true, .ISingle true, .ISingle false, + .ISingle false, .IJump false (cn 14488), .ISingle false, .ISingle false, .ISingle false] +theorem int_c7 : prog_check prog_c7 Rs_c7 Re_c7 (cn 1091) (cn 57957) = true := by decide +kernel + +def Rs_c8 : List run := [(0, cn 224492), (1, cn 7), (1, cn 61232), (0, cn 173877), (0, cn 2)] +def Re_c8 : List run := [(0, cn 224492), (1, cn 8), (0, cn 3277), (0, cn 647345), (0, cn 2)] +def r_after_c8 : List CRun := [.mk .b0 224492, .mk .b1 8, .mk .b0 3277, .mk .b0 647345, .mk .b0 2] +def prog_c8 : List instr := + [.IJump true (cn 272), .ISingle true, .ISingle true, .ISingle true, .ISingle false, + .IJump false (cn 14489)] +theorem int_c8 : prog_check prog_c8 Rs_c8 Re_c8 (cn 1091) (cn 57957) = true := by decide +kernel + +def Rs_c9 : List run := + [(0, cn 74804), (1, cn 224495), (1, cn 7), (1, cn 3277), (1, cn 647360), (0, cn 2)] +def Re_c9 : List run := + [(0, cn 74804), (1, cn 224496), (0, cn 673560), (1, cn 3), (1, cn 173869), (1, cn 1)] +def r_after_c9 : List CRun := + [.mk .b0 74804, .mk .b1 224496, .mk .b0 673560, .mk .b1 3, .mk .b1 173869, .mk .b1 1] +def prog_c9 : List instr := + [.IJump true (cn 272), .ISingle true, .ISingle true, .ISingle true, .ISingle false, + .ISingle false, .IJump false (cn 14488), .ISingle false, .ISingle false, .ISingle false] +theorem int_c9 : prog_check prog_c9 Rs_c9 Re_c9 (cn 1091) (cn 57957) = true := by decide +kernel + +def Rs_c10 : List run := + [(0, cn 24908), (1, cn 74807), (1, cn 224496), (0, cn 673560), (1, cn 4), (0, cn 173878)] +def Re_c10 : List run := + [(0, cn 24908), (1, cn 74808), (0, cn 224496), (1, cn 673559), (1, cn 7), (1, cn 183704), (0, + cn 521601), (0, cn 2)] +def r_after_c10 : List CRun := + [.mk .b0 24908, .mk .b1 74808, .mk .b0 224496, .mk .b1 673559, .mk .b1 7, .mk .b1 183704, + .mk .b0 521601, .mk .b0 2] +def prog_c10 : List instr := + [.IJump true (cn 272), .ISingle true, .ISingle true, .ISingle true, .ISingle false, + .ISingle false, .IJump false (cn 14488), .ISingle false, .ISingle false, .ISingle false] +theorem int_c10 : prog_check prog_c10 Rs_c10 Re_c10 (cn 1091) (cn 57957) = true := by decide +kernel + +def Rs_c11 : List run := [(0, cn 673556), (1, cn 7), (1, cn 183703), (1, cn 521609), (1, cn 1)] +def Re_c11 : List run := [(0, cn 673556), (1, cn 7), (1, cn 9841), (1, cn 1942040), (0, cn 2)] +def r_after_c11 : List CRun := [.mk .b0 673556, .mk .b1 7, .mk .b1 9841, .mk .b1 1942040, .mk .b0 2] +def prog_c11 : List instr := + [.IJump true (cn 819), .ISingle true, .ISingle true, .ISingle false, .IJump false (cn 43466), + .ISingle false, .ISingle false, .ISingle false] +theorem int_c11 : prog_check prog_c11 Rs_c11 Re_c11 (cn 3278) (cn 173868) = true := by + decide +kernel + +def st372_init : CState := .mk true .A [] [] +def st372_0 : CState := .mk true .A [] [] +def st372_1 : CState := + .mk false .A [.mk .b0 1, .mk .b0 502, .mk .b1 752, .mk .b0 6, .mk .b1 2736, .mk .b0 972, + .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, .mk .b1 24, .mk .b0 15, .mk .b0 7, .mk .b0 1, + .mk .b0 5, .mk .b0 3, .mk .b0 3, .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 1] +def st372_2 : CState := + .mk true .B [.mk .b1 1, .mk .b1 229, .mk .b1 8, .mk .b0 2734, .mk .b1 972, .mk .b0 36, + .mk .b1 40, .mk .b0 35, .mk .b0 43, .mk .b0 24, .mk .b1 16, .mk .b0 7, .mk .b0 3, .mk .b0 2, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 3, .mk .b0 3, .mk .b0 2] [.mk .b1 6454, .mk .b0 2] +def st372_3 : CState := + .mk true .A [.mk .b0 1, .mk .b0 39, .mk .b0 36, .mk .b1 44, .mk .b0 22, .mk .b1 16, .mk .b0 8, + .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 2, .mk .b1 4, .mk .b0 1, + .mk .b0 5, .mk .b0 2] [.mk .b0 34, .mk .b1 972, .mk .b0 2736, .mk .b1 8279, .mk .b1 7, + .mk .b1 2264, .mk .b0 734] +def st372_4 : CState := + .mk true .F [.mk .b0 1, .mk .b0 8279, .mk .b0 2736, .mk .b1 972, .mk .b0 35, .mk .b0 39, + .mk .b0 36, .mk .b1 44, .mk .b0 22, .mk .b1 16, .mk .b0 8, .mk .b1 4, .mk .b0 3, .mk .b0 3, + .mk .b0 2, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 3, .mk .b0 3, .mk .b0 2] [.mk .b0 6, + .mk .b1 2264, .mk .b0 5433, .mk .b0 2] +def st372_5 : CState := + .mk false .D [.mk .b1 11510, .mk .b0 1676, .mk .b1 8, .mk .b0 8277, .mk .b0 2737, .mk .b0 972, + .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, .mk .b1 24, .mk .b0 14, .mk .b1 8, .mk .b0 4, + .mk .b1 4, .mk .b0 3, .mk .b0 3, .mk .b0 2, .mk .b1 4, .mk .b0 3, .mk .b0 3, .mk .b0 1, + .mk .b0 5, .mk .b0 2] [.mk .b1 1] +def st372_6 : CState := + .mk false .D [.mk .b1 18150, .mk .b0 848, .mk .b1 8, .mk .b0 8277, .mk .b0 2737, .mk .b0 972, + .mk .b1 36, .mk .b0 38, .mk .b1 36, .mk .b0 44, .mk .b1 24, .mk .b0 13, .mk .b0 9, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 3, + .mk .b0 3, .mk .b0 2] [.mk .b1 1, .mk .b1 1] +def st372_7 : CState := + .mk true .B [.mk .b0 2737, .mk .b0 972, .mk .b1 36, .mk .b0 39, .mk .b0 35, .mk .b0 43, + .mk .b0 24, .mk .b1 16, .mk .b0 5, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 2, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 8277, + .mk .b1 8, .mk .b0 13, .mk .b0 24809, .mk .b0 2] +def st372_8 : CState := + .mk false .D [.mk .b1 3888, .mk .b0 3, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, + .mk .b0 36, .mk .b1 40, .mk .b0 34, .mk .b1 44, .mk .b0 24, .mk .b1 16, .mk .b0 6, .mk .b1 4, + .mk .b0 4, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 3, .mk .b0 3, + .mk .b0 2, .mk .b1 4, .mk .b0 2] [.mk .b1 1, .mk .b1 1] +def st372_9 : CState := + .mk false .D [.mk .b0 2733, .mk .b0 973, .mk .b0 36, .mk .b1 40, .mk .b0 34, .mk .b1 44, + .mk .b0 24, .mk .b1 16, .mk .b0 7, .mk .b0 3, .mk .b0 4, .mk .b1 4, .mk .b0 2, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 2] [.mk .b1 8280, + .mk .b0 24912, .mk .b1 4, .mk .b0 5861, .mk .b0 2] +def st372_10 : CState := + .mk true .B [.mk .b1 8280, .mk .b0 2734, .mk .b1 972, .mk .b0 36, .mk .b1 40, .mk .b0 35, + .mk .b0 43, .mk .b0 24, .mk .b1 16, .mk .b0 7, .mk .b0 3, .mk .b0 4, .mk .b1 4, .mk .b0 2, + .mk .b1 4, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, + .mk .b0 2] [.mk .b0 24912, .mk .b1 4, .mk .b0 6354, .mk .b1 1] +def st372_11 : CState := + .mk true .B [.mk .b1 8280, .mk .b0 2733, .mk .b0 973, .mk .b0 36, .mk .b1 40, .mk .b0 33, + .mk .b0 45, .mk .b0 24, .mk .b1 16, .mk .b0 7, .mk .b0 3, .mk .b0 4, .mk .b1 4, .mk .b0 3, + .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, + .mk .b0 2] [.mk .b0 24912, .mk .b1 4, .mk .b0 6414, .mk .b1 1] +def st372_12 : CState := + .mk false .A [.mk .b0 1, .mk .b0 3, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 1, + .mk .b1 5, .mk .b1 16, .mk .b0 24, .mk .b1 43, .mk .b1 35, .mk .b1 40, .mk .b0 36, .mk .b1 971, + .mk .b1 2735, .mk .b1 8280, .mk .b0 24912, .mk .b1 4, .mk .b0 6442] +def st372_13 : CState := + .mk false .D [.mk .b0 3, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, .mk .b0 36, + .mk .b1 40, .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 16, .mk .b0 5, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 6445, .mk .b1 1] + +theorem step372_0 : cstep2n 15 st372_0 = st372_1 := by decide +kernel +theorem step372_1 : cstep2n 15 st372_1 = st372_2 := by decide +kernel +theorem step372_2 : cstep2n 15 st372_2 = st372_3 := by decide +kernel +theorem step372_3 : cstep2n 15 st372_3 = st372_4 := by decide +kernel +theorem step372_4 : cstep2n 15 st372_4 = st372_5 := by decide +kernel +theorem step372_5 : cstep2n 15 st372_5 = st372_6 := by decide +kernel +theorem step372_6 : cstep2n 15 st372_6 = st372_7 := by decide +kernel +theorem step372_7 : cstep2n 15 st372_7 = st372_8 := by decide +kernel +theorem step372_8 : cstep2n 14 st372_8 = st372_9 := by decide +kernel +theorem step372_9 : cstep2n 12 st372_9 = st372_10 := by decide +kernel +theorem step372_10 : cstep2n 9 st372_10 = st372_11 := by decide +kernel +theorem step372_11 : cstep2n 8 st372_11 = st372_12 := by decide +kernel +theorem step372_12 : cstep2n 5 st372_12 = st372_13 := by decide +kernel + +theorem stem_372 : (ev_cfg [] (fun _ => default) (toCfg st372_init)) [tm372]⊢* + (ev_cfg [] (fun _ => default) (toCfg st372_13)) := by + have h13 : (ev_cfg [] (fun _ => default) (toCfg st372_13)) [tm372]⊢* + (ev_cfg [] (fun _ => default) (toCfg st372_13)) := ⟨0, rfl⟩ + have h12 := chain_cstep2n 5 st372_12 st372_13 st372_13 step372_12 h13 + have h11 := chain_cstep2n 8 st372_11 st372_12 st372_13 step372_11 h12 + have h10 := chain_cstep2n 9 st372_10 st372_11 st372_13 step372_10 h11 + have h9 := chain_cstep2n 12 st372_9 st372_10 st372_13 step372_9 h10 + have h8 := chain_cstep2n 14 st372_8 st372_9 st372_13 step372_8 h9 + have h7 := chain_cstep2n 15 st372_7 st372_8 st372_13 step372_7 h8 + have h6 := chain_cstep2n 15 st372_6 st372_7 st372_13 step372_6 h7 + have h5 := chain_cstep2n 15 st372_5 st372_6 st372_13 step372_5 h6 + have h4 := chain_cstep2n 15 st372_4 st372_5 st372_13 step372_4 h5 + have h3 := chain_cstep2n 15 st372_3 st372_4 st372_13 step372_3 h4 + have h2 := chain_cstep2n 15 st372_2 st372_3 st372_13 step372_2 h3 + have h1 := chain_cstep2n 15 st372_1 st372_2 st372_13 step372_1 h2 + have h0 := chain_cstep2n 15 st372_0 st372_1 st372_13 step372_0 h1 + exact h0 + +def l372_in1 : List CRun := + [.mk .b0 3, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, .mk .b0 36, .mk .b1 40, + .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 16, .mk .b0 5, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r372_in1 : List CRun := [.mk .b1 6445, .mk .b1 1] +def nus372_1 : List (List Nat) := [[6227, 2069, 683, 242], [8, 9, 8, 10], [5, 3, 1, 0]] +def l372_after1 : List CRun := + [.mk .b0 1, .mk .b0 24913, .mk .b0 8280, .mk .b1 2736, .mk .b0 969, .mk .b0 37, .mk .b0 40, + .mk .b1 36, .mk .b0 41, .mk .b0 25, .mk .b0 16, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st372_int1 : CState := .mk false .D l372_in1 r372_in1 +def l372_in2 : List CRun := + [.mk .b0 24911, .mk .b0 8280, .mk .b1 2736, .mk .b0 969, .mk .b0 37, .mk .b0 40, .mk .b1 36, + .mk .b0 41, .mk .b0 25, .mk .b0 16, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r372_in2 : List CRun := [.mk .b1 7, .mk .b1 6800, .mk .b0 19329, .mk .b0 2] +def nus372_2 : List (List Nat) := [[2069, 683, 242, 8], [9, 8, 10, 5], [3, 1, 0, 0]] +def l372_after2 : List CRun := + [.mk .b0 1, .mk .b0 8281, .mk .b0 2736, .mk .b1 972, .mk .b0 33, .mk .b0 41, .mk .b0 36, + .mk .b1 44, .mk .b0 21, .mk .b0 17, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st372_int2 : CState := .mk false .D l372_in2 r372_in2 +def l372_in3 : List CRun := + [.mk .b0 8279, .mk .b0 2736, .mk .b1 972, .mk .b0 33, .mk .b0 41, .mk .b0 36, .mk .b1 44, + .mk .b0 21, .mk .b0 17, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r372_in3 : List CRun := [.mk .b1 24911, .mk .b1 7, .mk .b1 361, .mk .b1 71936, .mk .b0 2] +def nus372_3 : List (List Nat) := [[683, 242, 8, 9], [8, 10, 5, 3], [1, 0, 0, 0]] +def l372_after3 : List CRun := + [.mk .b0 1, .mk .b0 2737, .mk .b0 972, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, + .mk .b1 24, .mk .b0 13, .mk .b0 9, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st372_int3 : CState := .mk false .D l372_in3 r372_in3 +def l372_in4 : List CRun := + [.mk .b0 2735, .mk .b0 972, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, .mk .b1 24, + .mk .b0 13, .mk .b0 9, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r372_in4 : List CRun := [.mk .b1 8279, .mk .b1 24912, .mk .b0 74808, .mk .b1 4, .mk .b0 19330] +def nus372_4 : List (List Nat) := [[242, 8, 9, 8], [10, 5, 3, 1], [0, 0, 0, 0]] +def l372_after4 : List CRun := + [.mk .b0 1, .mk .b0 973, .mk .b0 36, .mk .b1 40, .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 16, + .mk .b0 5, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def st372_int4 : CState := .mk false .D l372_in4 r372_in4 +def l372_in5 : List CRun := + [.mk .b0 74807, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, .mk .b0 36, .mk .b1 40, + .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 16, .mk .b0 5, .mk .b0 5, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r372_in5 : List CRun := [.mk .b1 7, .mk .b1 20407, .mk .b1 57965, .mk .b1 1] +def nus372_5 : List (List Nat) := + [[6227, 2069, 683, 242], [8, 9, 8, 10], [5, 3, 1, 0], [0, 0, 0, 0]] +def l372_after5 : List CRun := + [.mk .b0 1, .mk .b0 24913, .mk .b0 8280, .mk .b1 2736, .mk .b0 969, .mk .b0 37, .mk .b0 40, + .mk .b1 36, .mk .b0 41, .mk .b0 25, .mk .b0 16, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st372_int5 : CState := .mk false .D l372_in5 r372_in5 +def l372_in6 : List CRun := + [.mk .b0 24911, .mk .b0 8280, .mk .b1 2736, .mk .b0 969, .mk .b0 37, .mk .b0 40, .mk .b1 36, + .mk .b0 41, .mk .b0 25, .mk .b0 16, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r372_in6 : List CRun := [.mk .b1 74807, .mk .b1 8, .mk .b0 1088, .mk .b1 215797] +def nus372_6 : List (List Nat) := [[2069, 683, 242, 8], [9, 8, 10, 5], [3, 1, 0, 0], [0, 0, 0, 0]] +def l372_after6 : List CRun := + [.mk .b0 1, .mk .b0 8281, .mk .b0 2736, .mk .b1 972, .mk .b0 33, .mk .b0 41, .mk .b0 36, + .mk .b1 44, .mk .b0 21, .mk .b0 17, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st372_int6 : CState := .mk false .D l372_in6 r372_in6 +def l372_in7 : List CRun := + [.mk .b0 3, .mk .b0 224496, .mk .b1 74808, .mk .b0 24909, .mk .b0 8281, .mk .b0 2736, + .mk .b1 972, .mk .b0 33, .mk .b0 41, .mk .b0 36, .mk .b1 44, .mk .b0 21, .mk .b0 17, .mk .b0 8, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r372_in7 : List CRun := [.mk .b1 57961, .mk .b1 1] +def nus372_7 : List (List Nat) := + [[56123, 18701, 6227, 2069], [683, 242, 8, 9], [8, 10, 5, 3], [1, 0, 0, 0], [0, 0, 0, 0]] +def l372_after7 : List CRun := + [.mk .b0 1, .mk .b0 224497, .mk .b0 74808, .mk .b1 24912, .mk .b0 8277, .mk .b0 2737, + .mk .b0 972, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, .mk .b1 24, .mk .b0 13, .mk .b0 9, + .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st372_int7 : CState := .mk false .D l372_in7 r372_in7 +def l372_in8 : List CRun := + [.mk .b0 224495, .mk .b0 74808, .mk .b1 24912, .mk .b0 8277, .mk .b0 2737, .mk .b0 972, + .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, .mk .b1 24, .mk .b0 13, .mk .b0 9, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r372_in8 : List CRun := [.mk .b1 7, .mk .b1 61232, .mk .b0 173877, .mk .b0 2] +def nus372_8 : List (List Nat) := + [[18701, 6227, 2069, 683], [242, 8, 9, 8], [10, 5, 3, 1], [0, 0, 0, 0], [0, 0, 0, 0]] +def l372_after8 : List CRun := + [.mk .b0 1, .mk .b0 74809, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, .mk .b0 36, + .mk .b1 40, .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 16, .mk .b0 5, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st372_int8 : CState := .mk false .D l372_in8 r372_in8 +def l372_in9 : List CRun := + [.mk .b0 74807, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, .mk .b0 36, .mk .b1 40, + .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 16, .mk .b0 5, .mk .b0 5, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r372_in9 : List CRun := [.mk .b1 224495, .mk .b1 7, .mk .b1 3277, .mk .b1 647360, .mk .b0 2] +def nus372_9 : List (List Nat) := + [[6227, 2069, 683, 242], [8, 9, 8, 10], [5, 3, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0]] +def l372_after9 : List CRun := + [.mk .b0 1, .mk .b0 24913, .mk .b0 8280, .mk .b1 2736, .mk .b0 969, .mk .b0 37, .mk .b0 40, + .mk .b1 36, .mk .b0 41, .mk .b0 25, .mk .b0 16, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st372_int9 : CState := .mk false .D l372_in9 r372_in9 +def l372_in10 : List CRun := + [.mk .b0 24911, .mk .b0 8280, .mk .b1 2736, .mk .b0 969, .mk .b0 37, .mk .b0 40, .mk .b1 36, + .mk .b0 41, .mk .b0 25, .mk .b0 16, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r372_in10 : List CRun := + [.mk .b1 74807, .mk .b1 224496, .mk .b0 673560, .mk .b1 4, .mk .b0 173878] +def nus372_10 : List (List Nat) := + [[2069, 683, 242, 8], [9, 8, 10, 5], [3, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] +def l372_after10 : List CRun := + [.mk .b0 1, .mk .b0 8281, .mk .b0 2736, .mk .b1 972, .mk .b0 33, .mk .b0 41, .mk .b0 36, + .mk .b1 44, .mk .b0 21, .mk .b0 17, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st372_int10 : CState := .mk false .D l372_in10 r372_in10 +def l372_in11 : List CRun := + [.mk .b0 673559, .mk .b0 224496, .mk .b1 74808, .mk .b0 24909, .mk .b0 8281, .mk .b0 2736, + .mk .b1 972, .mk .b0 33, .mk .b0 41, .mk .b0 36, .mk .b1 44, .mk .b0 21, .mk .b0 17, .mk .b0 8, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r372_in11 : List CRun := [.mk .b1 7, .mk .b1 183703, .mk .b1 521609, .mk .b1 1] +def nus372_11 : List (List Nat) := + [[56123, 18701, 6227, 2069], [683, 242, 8, 9], [8, 10, 5, 3], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, + 0, 0]] +def l372_after11 : List CRun := + [.mk .b0 1, .mk .b0 224497, .mk .b0 74808, .mk .b1 24912, .mk .b0 8277, .mk .b0 2737, + .mk .b0 972, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, .mk .b1 24, .mk .b0 13, .mk .b0 9, + .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st372_int11 : CState := .mk false .D l372_in11 r372_in11 +def l372_in12 : List CRun := + [.mk .b0 224495, .mk .b0 74808, .mk .b1 24912, .mk .b0 8277, .mk .b0 2737, .mk .b0 972, + .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, .mk .b1 24, .mk .b0 13, .mk .b0 9, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r372_in12 : List CRun := [.mk .b1 673559, .mk .b1 8, .mk .b0 9836, .mk .b1 1942069] +def st372_int12 : CState := .mk false .D l372_in12 r372_in12 + +theorem istep372_1 : (ev_cfg [] (fun _ => default) (toCfg st372_int1)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st372_int2)) := by + exact interval_step_zero 3 119 6441 51 l372_in1 r372_in1 + l372_after1 r_after_c1 nus372_1 prog_c1 Rs_c1 Re_c1 st372_int2 + (by decide +kernel) (by decide +kernel) (by decide) (by decide) + (by decide) (by decide) int_c1 (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep372_2 : (ev_cfg [] (fun _ => default) (toCfg st372_int2)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st372_int3)) := by + exact interval_step_pos 24908 3 119 6441 72 l372_in2 r372_in2 + l372_after2 r_after_c2 nus372_2 prog_c2 Rs_c2 Re_c2 st372_int3 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c2 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep372_3 : (ev_cfg [] (fun _ => default) (toCfg st372_int3)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st372_int4)) := by + exact interval_step_pos 8276 3 119 6441 56 l372_in3 r372_in3 + l372_after3 r_after_c3 nus372_3 prog_c3 Rs_c3 Re_c3 st372_int4 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c3 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep372_4 : (ev_cfg [] (fun _ => default) (toCfg st372_int4)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st372_int5)) := by + exact interval_step_pos 2732 3 119 6441 43 l372_in4 r372_in4 + l372_after4 r_after_c4 nus372_4 prog_c4 Rs_c4 Re_c4 st372_int5 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c4 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep372_5 : (ev_cfg [] (fun _ => default) (toCfg st372_int5)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st372_int6)) := by + exact interval_step_pos 74804 4 362 19320 111 l372_in5 r372_in5 + l372_after5 r_after_c5 nus372_5 prog_c5 Rs_c5 Re_c5 st372_int6 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c5 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep372_6 : (ev_cfg [] (fun _ => default) (toCfg st372_int6)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st372_int7)) := by + exact interval_step_pos 24908 4 362 19320 14 l372_in6 r372_in6 + l372_after6 r_after_c6 nus372_6 prog_c6 Rs_c6 Re_c6 st372_int7 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c6 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep372_7 : (ev_cfg [] (fun _ => default) (toCfg st372_int7)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st372_int8)) := by + exact interval_step_zero 5 1091 57957 51 l372_in7 r372_in7 + l372_after7 r_after_c7 nus372_7 prog_c7 Rs_c7 Re_c7 st372_int8 + (by decide +kernel) (by decide +kernel) (by decide) (by decide) + (by decide) (by decide) int_c7 (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep372_8 : (ev_cfg [] (fun _ => default) (toCfg st372_int8)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st372_int9)) := by + exact interval_step_pos 224492 5 1091 57957 72 l372_in8 r372_in8 + l372_after8 r_after_c8 nus372_8 prog_c8 Rs_c8 Re_c8 st372_int9 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c8 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep372_9 : (ev_cfg [] (fun _ => default) (toCfg st372_int9)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st372_int10)) := by + exact interval_step_pos 74804 5 1091 57957 56 l372_in9 r372_in9 + l372_after9 r_after_c9 nus372_9 prog_c9 Rs_c9 Re_c9 st372_int10 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c9 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep372_10 : (ev_cfg [] (fun _ => default) (toCfg st372_int10)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st372_int11)) := by + exact interval_step_pos 24908 5 1091 57957 43 l372_in10 r372_in10 + l372_after10 r_after_c10 nus372_10 prog_c10 Rs_c10 Re_c10 st372_int11 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c10 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep372_11 : (ev_cfg [] (fun _ => default) (toCfg st372_int11)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st372_int12)) := by + exact interval_step_pos 673556 6 3278 173868 111 l372_in11 r372_in11 + l372_after11 r_after_c11 nus372_11 prog_c11 Rs_c11 Re_c11 st372_int12 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c11 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep372_12 : (ev_cfg [] (fun _ => default) (toCfg st372_int12)) [tm372]⊢* + cfgI (.C5, 2, 0, nus28_372) := by + exact final_to_cfgI 224492 l372_in12 r372_in12 nus28_372 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide) + +theorem reach_cfgI_372 : (ev_cfg [] (fun _ => default) (toCfg st372_init)) [tm372]⊢⁺ + cfgI (.C5, 2, 0, nus28_372) := by + have h0 : st372_13 = st372_int1 := rfl + have hs := stem_372 + rw [h0] at hs + have p1 := stepStar_stepPlus_trans hs istep372_1 + have p2 := stepPlus_trans p1 istep372_2 + have p3 := stepPlus_trans p2 istep372_3 + have p4 := stepPlus_trans p3 istep372_4 + have p5 := stepPlus_trans p4 istep372_5 + have p6 := stepPlus_trans p5 istep372_6 + have p7 := stepPlus_trans p6 istep372_7 + have p8 := stepPlus_trans p7 istep372_8 + have p9 := stepPlus_trans p8 istep372_9 + have p10 := stepPlus_trans p9 istep372_10 + have p11 := stepPlus_trans p10 istep372_11 + exact stepPlus_stepStar_trans p11 istep372_12 + +def st557_init : CState := .mk true .B [] [] +def st557_0 : CState := .mk true .B [] [] +def st557_1 : CState := + .mk false .E [.mk .b0 2737, .mk .b0 972, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, + .mk .b1 24, .mk .b0 19, .mk .b0 7, .mk .b0 1, .mk .b0 5, .mk .b0 3, .mk .b0 3, .mk .b0 1, + .mk .b0 5, .mk .b0 2] [.mk .b1 5, .mk .b1 752, .mk .b0 502, .mk .b1 1] +def st557_2 : CState := + .mk true .A [.mk .b0 6453, .mk .b0 230, .mk .b1 8, .mk .b0 2734, .mk .b1 972, .mk .b0 36, + .mk .b1 40, .mk .b0 35, .mk .b0 43, .mk .b0 24, .mk .b1 20, .mk .b0 7, .mk .b0 3, .mk .b0 2, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 3, .mk .b0 3, .mk .b0 2] [] +def st557_3 : CState := + .mk false .D [.mk .b0 7, .mk .b0 8279, .mk .b0 2736, .mk .b1 972, .mk .b0 34, .mk .b1 40, + .mk .b0 36, .mk .b1 44, .mk .b0 22, .mk .b1 20, .mk .b0 8, .mk .b1 4, .mk .b0 2, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 2, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 2264, + .mk .b0 734] +def st557_4 : CState := + .mk false .C [.mk .b1 40, .mk .b0 36, .mk .b1 44, .mk .b0 22, .mk .b1 20, .mk .b0 8, .mk .b1 4, + .mk .b0 3, .mk .b0 3, .mk .b0 2, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 3, .mk .b0 3, + .mk .b0 2] [.mk .b0 34, .mk .b1 972, .mk .b0 2736, .mk .b1 8279, .mk .b1 7, .mk .b1 2264, + .mk .b0 5433, .mk .b0 2] +def st557_5 : CState := + .mk true .B [.mk .b0 2737, .mk .b0 972, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, + .mk .b1 24, .mk .b0 18, .mk .b1 8, .mk .b0 4, .mk .b1 4, .mk .b0 3, .mk .b0 3, .mk .b0 2, + .mk .b1 4, .mk .b0 3, .mk .b0 3, .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 8277, .mk .b1 8, + .mk .b0 1676, .mk .b1 11509] +def st557_6 : CState := + .mk true .A [.mk .b0 846, .mk .b1 8, .mk .b0 8277, .mk .b0 2737, .mk .b0 972, .mk .b1 36, + .mk .b0 38, .mk .b1 36, .mk .b0 44, .mk .b1 24, .mk .b0 17, .mk .b0 9, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 3, .mk .b0 3, + .mk .b0 2] [.mk .b1 18152, .mk .b0 2] +def st557_7 : CState := + .mk true .B [.mk .b1 36, .mk .b0 39, .mk .b0 35, .mk .b0 43, .mk .b0 24, .mk .b1 20, .mk .b0 5, + .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b0 972, .mk .b1 2735, .mk .b1 8279, .mk .b1 8, + .mk .b0 13, .mk .b0 24809, .mk .b0 2] +def st557_8 : CState := + .mk true .C [.mk .b1 1, .mk .b1 3887, .mk .b1 4, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, + .mk .b0 973, .mk .b0 36, .mk .b1 40, .mk .b0 34, .mk .b1 44, .mk .b0 24, .mk .b1 20, .mk .b0 6, + .mk .b1 4, .mk .b0 4, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 3, + .mk .b0 3, .mk .b0 2, .mk .b1 4, .mk .b0 2] [] +def st557_9 : CState := + .mk true .C [.mk .b1 1, .mk .b1 5861, .mk .b1 4, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, + .mk .b0 973, .mk .b0 36, .mk .b1 40, .mk .b0 34, .mk .b1 44, .mk .b0 24, .mk .b1 20, .mk .b0 7, + .mk .b0 3, .mk .b0 4, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 3, + .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 2] [] +def st557_10 : CState := + .mk false .D [.mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, .mk .b0 36, .mk .b1 40, + .mk .b0 35, .mk .b0 43, .mk .b0 24, .mk .b1 20, .mk .b0 7, .mk .b0 3, .mk .b0 4, .mk .b1 4, + .mk .b0 2, .mk .b1 4, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, + .mk .b0 2] [.mk .b1 4, .mk .b0 6354, .mk .b1 1] +def st557_11 : CState := + .mk true .A [.mk .b0 971, .mk .b0 36, .mk .b1 40, .mk .b0 33, .mk .b0 45, .mk .b0 24, + .mk .b1 20, .mk .b0 7, .mk .b0 3, .mk .b0 4, .mk .b1 4, .mk .b0 3, .mk .b0 3, .mk .b0 3, + .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 2] [.mk .b1 2735, .mk .b1 8280, + .mk .b0 24912, .mk .b1 4, .mk .b0 6414, .mk .b1 1] +def st557_12 : CState := + .mk false .A [.mk .b0 1, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 1, .mk .b1 1, .mk .b1 3, + .mk .b1 7, .mk .b1 20, .mk .b0 24, .mk .b1 43, .mk .b1 35, .mk .b1 40, .mk .b0 36, .mk .b1 971, + .mk .b1 2735, .mk .b1 8280, .mk .b0 24912, .mk .b1 4, .mk .b0 6442] +def st557_13 : CState := + .mk false .D [.mk .b1 1, .mk .b1 6443, .mk .b1 4, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, + .mk .b0 973, .mk .b0 36, .mk .b1 40, .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 20, .mk .b0 5, + .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 1] +def st557_14 : CState := + .mk true .C [.mk .b1 6444, .mk .b0 3, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, + .mk .b0 36, .mk .b1 40, .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 20, .mk .b0 5, .mk .b0 5, + .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b0 2] +def st557_15 : CState := + .mk false .D [.mk .b0 3, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, .mk .b0 36, + .mk .b1 40, .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 20, .mk .b0 5, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 6445, .mk .b1 1] + +theorem step557_0 : cstep2n 15 st557_0 = st557_1 := by decide +kernel +theorem step557_1 : cstep2n 15 st557_1 = st557_2 := by decide +kernel +theorem step557_2 : cstep2n 15 st557_2 = st557_3 := by decide +kernel +theorem step557_3 : cstep2n 15 st557_3 = st557_4 := by decide +kernel +theorem step557_4 : cstep2n 15 st557_4 = st557_5 := by decide +kernel +theorem step557_5 : cstep2n 15 st557_5 = st557_6 := by decide +kernel +theorem step557_6 : cstep2n 15 st557_6 = st557_7 := by decide +kernel +theorem step557_7 : cstep2n 15 st557_7 = st557_8 := by decide +kernel +theorem step557_8 : cstep2n 14 st557_8 = st557_9 := by decide +kernel +theorem step557_9 : cstep2n 12 st557_9 = st557_10 := by decide +kernel +theorem step557_10 : cstep2n 9 st557_10 = st557_11 := by decide +kernel +theorem step557_11 : cstep2n 8 st557_11 = st557_12 := by decide +kernel +theorem step557_12 : cstep2n 5 st557_12 = st557_13 := by decide +kernel +theorem step557_13 : cstep2n 2 st557_13 = st557_14 := by decide +kernel +theorem step557_14 : cstep2n 1 st557_14 = st557_15 := by decide +kernel + +theorem stem_557 : (ev_cfg [] (fun _ => default) (toCfg st557_init)) [tm372]⊢* + (ev_cfg [] (fun _ => default) (toCfg st557_15)) := by + have h15 : (ev_cfg [] (fun _ => default) (toCfg st557_15)) [tm372]⊢* + (ev_cfg [] (fun _ => default) (toCfg st557_15)) := ⟨0, rfl⟩ + have h14 := chain_cstep2n 1 st557_14 st557_15 st557_15 step557_14 h15 + have h13 := chain_cstep2n 2 st557_13 st557_14 st557_15 step557_13 h14 + have h12 := chain_cstep2n 5 st557_12 st557_13 st557_15 step557_12 h13 + have h11 := chain_cstep2n 8 st557_11 st557_12 st557_15 step557_11 h12 + have h10 := chain_cstep2n 9 st557_10 st557_11 st557_15 step557_10 h11 + have h9 := chain_cstep2n 12 st557_9 st557_10 st557_15 step557_9 h10 + have h8 := chain_cstep2n 14 st557_8 st557_9 st557_15 step557_8 h9 + have h7 := chain_cstep2n 15 st557_7 st557_8 st557_15 step557_7 h8 + have h6 := chain_cstep2n 15 st557_6 st557_7 st557_15 step557_6 h7 + have h5 := chain_cstep2n 15 st557_5 st557_6 st557_15 step557_5 h6 + have h4 := chain_cstep2n 15 st557_4 st557_5 st557_15 step557_4 h5 + have h3 := chain_cstep2n 15 st557_3 st557_4 st557_15 step557_3 h4 + have h2 := chain_cstep2n 15 st557_2 st557_3 st557_15 step557_2 h3 + have h1 := chain_cstep2n 15 st557_1 st557_2 st557_15 step557_1 h2 + have h0 := chain_cstep2n 15 st557_0 st557_1 st557_15 step557_0 h1 + exact h0 + +def l557_in1 : List CRun := + [.mk .b0 3, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, .mk .b0 36, .mk .b1 40, + .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 20, .mk .b0 5, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r557_in1 : List CRun := [.mk .b1 6445, .mk .b1 1] +def nus557_1 : List (List Nat) := [[6227, 2069, 683, 242], [8, 9, 8, 10], [5, 4, 1, 0]] +def l557_after1 : List CRun := + [.mk .b0 1, .mk .b0 24913, .mk .b0 8280, .mk .b1 2736, .mk .b0 969, .mk .b0 37, .mk .b0 40, + .mk .b1 36, .mk .b0 41, .mk .b0 25, .mk .b0 20, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st557_int1 : CState := .mk false .D l557_in1 r557_in1 +def l557_in2 : List CRun := + [.mk .b0 24911, .mk .b0 8280, .mk .b1 2736, .mk .b0 969, .mk .b0 37, .mk .b0 40, .mk .b1 36, + .mk .b0 41, .mk .b0 25, .mk .b0 20, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r557_in2 : List CRun := [.mk .b1 7, .mk .b1 6800, .mk .b0 19329, .mk .b0 2] +def nus557_2 : List (List Nat) := [[2069, 683, 242, 8], [9, 8, 10, 5], [4, 1, 0, 0]] +def l557_after2 : List CRun := + [.mk .b0 1, .mk .b0 8281, .mk .b0 2736, .mk .b1 972, .mk .b0 33, .mk .b0 41, .mk .b0 36, + .mk .b1 44, .mk .b0 21, .mk .b0 21, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st557_int2 : CState := .mk false .D l557_in2 r557_in2 +def l557_in3 : List CRun := + [.mk .b0 8279, .mk .b0 2736, .mk .b1 972, .mk .b0 33, .mk .b0 41, .mk .b0 36, .mk .b1 44, + .mk .b0 21, .mk .b0 21, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r557_in3 : List CRun := [.mk .b1 24911, .mk .b1 7, .mk .b1 361, .mk .b1 71936, .mk .b0 2] +def nus557_3 : List (List Nat) := [[683, 242, 8, 9], [8, 10, 5, 4], [1, 0, 0, 0]] +def l557_after3 : List CRun := + [.mk .b0 1, .mk .b0 2737, .mk .b0 972, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, + .mk .b1 24, .mk .b0 17, .mk .b0 9, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st557_int3 : CState := .mk false .D l557_in3 r557_in3 +def l557_in4 : List CRun := + [.mk .b0 2735, .mk .b0 972, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, .mk .b1 24, + .mk .b0 17, .mk .b0 9, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r557_in4 : List CRun := [.mk .b1 8279, .mk .b1 24912, .mk .b0 74808, .mk .b1 4, .mk .b0 19330] +def nus557_4 : List (List Nat) := [[242, 8, 9, 8], [10, 5, 4, 1], [0, 0, 0, 0]] +def l557_after4 : List CRun := + [.mk .b0 1, .mk .b0 973, .mk .b0 36, .mk .b1 40, .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 20, + .mk .b0 5, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def st557_int4 : CState := .mk false .D l557_in4 r557_in4 +def l557_in5 : List CRun := + [.mk .b0 74807, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, .mk .b0 36, .mk .b1 40, + .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 20, .mk .b0 5, .mk .b0 5, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r557_in5 : List CRun := [.mk .b1 7, .mk .b1 20407, .mk .b1 57965, .mk .b1 1] +def nus557_5 : List (List Nat) := + [[6227, 2069, 683, 242], [8, 9, 8, 10], [5, 4, 1, 0], [0, 0, 0, 0]] +def l557_after5 : List CRun := + [.mk .b0 1, .mk .b0 24913, .mk .b0 8280, .mk .b1 2736, .mk .b0 969, .mk .b0 37, .mk .b0 40, + .mk .b1 36, .mk .b0 41, .mk .b0 25, .mk .b0 20, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st557_int5 : CState := .mk false .D l557_in5 r557_in5 +def l557_in6 : List CRun := + [.mk .b0 24911, .mk .b0 8280, .mk .b1 2736, .mk .b0 969, .mk .b0 37, .mk .b0 40, .mk .b1 36, + .mk .b0 41, .mk .b0 25, .mk .b0 20, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r557_in6 : List CRun := [.mk .b1 74807, .mk .b1 8, .mk .b0 1088, .mk .b1 215797] +def nus557_6 : List (List Nat) := [[2069, 683, 242, 8], [9, 8, 10, 5], [4, 1, 0, 0], [0, 0, 0, 0]] +def l557_after6 : List CRun := + [.mk .b0 1, .mk .b0 8281, .mk .b0 2736, .mk .b1 972, .mk .b0 33, .mk .b0 41, .mk .b0 36, + .mk .b1 44, .mk .b0 21, .mk .b0 21, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st557_int6 : CState := .mk false .D l557_in6 r557_in6 +def l557_in7 : List CRun := + [.mk .b0 3, .mk .b0 224496, .mk .b1 74808, .mk .b0 24909, .mk .b0 8281, .mk .b0 2736, + .mk .b1 972, .mk .b0 33, .mk .b0 41, .mk .b0 36, .mk .b1 44, .mk .b0 21, .mk .b0 21, .mk .b0 8, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r557_in7 : List CRun := [.mk .b1 57961, .mk .b1 1] +def nus557_7 : List (List Nat) := + [[56123, 18701, 6227, 2069], [683, 242, 8, 9], [8, 10, 5, 4], [1, 0, 0, 0], [0, 0, 0, 0]] +def l557_after7 : List CRun := + [.mk .b0 1, .mk .b0 224497, .mk .b0 74808, .mk .b1 24912, .mk .b0 8277, .mk .b0 2737, + .mk .b0 972, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, .mk .b1 24, .mk .b0 17, .mk .b0 9, + .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st557_int7 : CState := .mk false .D l557_in7 r557_in7 +def l557_in8 : List CRun := + [.mk .b0 224495, .mk .b0 74808, .mk .b1 24912, .mk .b0 8277, .mk .b0 2737, .mk .b0 972, + .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, .mk .b1 24, .mk .b0 17, .mk .b0 9, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r557_in8 : List CRun := [.mk .b1 7, .mk .b1 61232, .mk .b0 173877, .mk .b0 2] +def nus557_8 : List (List Nat) := + [[18701, 6227, 2069, 683], [242, 8, 9, 8], [10, 5, 4, 1], [0, 0, 0, 0], [0, 0, 0, 0]] +def l557_after8 : List CRun := + [.mk .b0 1, .mk .b0 74809, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, .mk .b0 36, + .mk .b1 40, .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 20, .mk .b0 5, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st557_int8 : CState := .mk false .D l557_in8 r557_in8 +def l557_in9 : List CRun := + [.mk .b0 74807, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 973, .mk .b0 36, .mk .b1 40, + .mk .b0 33, .mk .b0 45, .mk .b0 24, .mk .b1 20, .mk .b0 5, .mk .b0 5, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r557_in9 : List CRun := [.mk .b1 224495, .mk .b1 7, .mk .b1 3277, .mk .b1 647360, .mk .b0 2] +def nus557_9 : List (List Nat) := + [[6227, 2069, 683, 242], [8, 9, 8, 10], [5, 4, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0]] +def l557_after9 : List CRun := + [.mk .b0 1, .mk .b0 24913, .mk .b0 8280, .mk .b1 2736, .mk .b0 969, .mk .b0 37, .mk .b0 40, + .mk .b1 36, .mk .b0 41, .mk .b0 25, .mk .b0 20, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st557_int9 : CState := .mk false .D l557_in9 r557_in9 +def l557_in10 : List CRun := + [.mk .b0 24911, .mk .b0 8280, .mk .b1 2736, .mk .b0 969, .mk .b0 37, .mk .b0 40, .mk .b1 36, + .mk .b0 41, .mk .b0 25, .mk .b0 20, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r557_in10 : List CRun := + [.mk .b1 74807, .mk .b1 224496, .mk .b0 673560, .mk .b1 4, .mk .b0 173878] +def nus557_10 : List (List Nat) := + [[2069, 683, 242, 8], [9, 8, 10, 5], [4, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] +def l557_after10 : List CRun := + [.mk .b0 1, .mk .b0 8281, .mk .b0 2736, .mk .b1 972, .mk .b0 33, .mk .b0 41, .mk .b0 36, + .mk .b1 44, .mk .b0 21, .mk .b0 21, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st557_int10 : CState := .mk false .D l557_in10 r557_in10 +def l557_in11 : List CRun := + [.mk .b0 673559, .mk .b0 224496, .mk .b1 74808, .mk .b0 24909, .mk .b0 8281, .mk .b0 2736, + .mk .b1 972, .mk .b0 33, .mk .b0 41, .mk .b0 36, .mk .b1 44, .mk .b0 21, .mk .b0 21, .mk .b0 8, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r557_in11 : List CRun := [.mk .b1 7, .mk .b1 183703, .mk .b1 521609, .mk .b1 1] +def nus557_11 : List (List Nat) := + [[56123, 18701, 6227, 2069], [683, 242, 8, 9], [8, 10, 5, 4], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, + 0, 0]] +def l557_after11 : List CRun := + [.mk .b0 1, .mk .b0 224497, .mk .b0 74808, .mk .b1 24912, .mk .b0 8277, .mk .b0 2737, + .mk .b0 972, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, .mk .b1 24, .mk .b0 17, .mk .b0 9, + .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st557_int11 : CState := .mk false .D l557_in11 r557_in11 +def l557_in12 : List CRun := + [.mk .b0 224495, .mk .b0 74808, .mk .b1 24912, .mk .b0 8277, .mk .b0 2737, .mk .b0 972, + .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 44, .mk .b1 24, .mk .b0 17, .mk .b0 9, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r557_in12 : List CRun := [.mk .b1 673559, .mk .b1 8, .mk .b0 9836, .mk .b1 1942069] +def st557_int12 : CState := .mk false .D l557_in12 r557_in12 + +theorem istep557_1 : (ev_cfg [] (fun _ => default) (toCfg st557_int1)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st557_int2)) := by + exact interval_step_zero 3 119 6441 51 l557_in1 r557_in1 + l557_after1 r_after_c1 nus557_1 prog_c1 Rs_c1 Re_c1 st557_int2 + (by decide +kernel) (by decide +kernel) (by decide) (by decide) + (by decide) (by decide) int_c1 (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep557_2 : (ev_cfg [] (fun _ => default) (toCfg st557_int2)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st557_int3)) := by + exact interval_step_pos 24908 3 119 6441 72 l557_in2 r557_in2 + l557_after2 r_after_c2 nus557_2 prog_c2 Rs_c2 Re_c2 st557_int3 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c2 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep557_3 : (ev_cfg [] (fun _ => default) (toCfg st557_int3)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st557_int4)) := by + exact interval_step_pos 8276 3 119 6441 56 l557_in3 r557_in3 + l557_after3 r_after_c3 nus557_3 prog_c3 Rs_c3 Re_c3 st557_int4 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c3 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep557_4 : (ev_cfg [] (fun _ => default) (toCfg st557_int4)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st557_int5)) := by + exact interval_step_pos 2732 3 119 6441 43 l557_in4 r557_in4 + l557_after4 r_after_c4 nus557_4 prog_c4 Rs_c4 Re_c4 st557_int5 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c4 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep557_5 : (ev_cfg [] (fun _ => default) (toCfg st557_int5)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st557_int6)) := by + exact interval_step_pos 74804 4 362 19320 111 l557_in5 r557_in5 + l557_after5 r_after_c5 nus557_5 prog_c5 Rs_c5 Re_c5 st557_int6 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c5 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep557_6 : (ev_cfg [] (fun _ => default) (toCfg st557_int6)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st557_int7)) := by + exact interval_step_pos 24908 4 362 19320 14 l557_in6 r557_in6 + l557_after6 r_after_c6 nus557_6 prog_c6 Rs_c6 Re_c6 st557_int7 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c6 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep557_7 : (ev_cfg [] (fun _ => default) (toCfg st557_int7)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st557_int8)) := by + exact interval_step_zero 5 1091 57957 51 l557_in7 r557_in7 + l557_after7 r_after_c7 nus557_7 prog_c7 Rs_c7 Re_c7 st557_int8 + (by decide +kernel) (by decide +kernel) (by decide) (by decide) + (by decide) (by decide) int_c7 (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep557_8 : (ev_cfg [] (fun _ => default) (toCfg st557_int8)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st557_int9)) := by + exact interval_step_pos 224492 5 1091 57957 72 l557_in8 r557_in8 + l557_after8 r_after_c8 nus557_8 prog_c8 Rs_c8 Re_c8 st557_int9 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c8 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep557_9 : (ev_cfg [] (fun _ => default) (toCfg st557_int9)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st557_int10)) := by + exact interval_step_pos 74804 5 1091 57957 56 l557_in9 r557_in9 + l557_after9 r_after_c9 nus557_9 prog_c9 Rs_c9 Re_c9 st557_int10 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c9 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep557_10 : (ev_cfg [] (fun _ => default) (toCfg st557_int10)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st557_int11)) := by + exact interval_step_pos 24908 5 1091 57957 43 l557_in10 r557_in10 + l557_after10 r_after_c10 nus557_10 prog_c10 Rs_c10 Re_c10 st557_int11 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c10 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep557_11 : (ev_cfg [] (fun _ => default) (toCfg st557_int11)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st557_int12)) := by + exact interval_step_pos 673556 6 3278 173868 111 l557_in11 r557_in11 + l557_after11 r_after_c11 nus557_11 prog_c11 Rs_c11 Re_c11 st557_int12 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c11 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep557_12 : (ev_cfg [] (fun _ => default) (toCfg st557_int12)) [tm372]⊢* + cfgI (.C5, 2, 0, nus28_557) := by + exact final_to_cfgI 224492 l557_in12 r557_in12 nus28_557 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide) + +theorem reach_cfgI_557 : (ev_cfg [] (fun _ => default) (toCfg st557_init)) [tm372]⊢⁺ + cfgI (.C5, 2, 0, nus28_557) := by + have h0 : st557_15 = st557_int1 := rfl + have hs := stem_557 + rw [h0] at hs + have p1 := stepStar_stepPlus_trans hs istep557_1 + have p2 := stepPlus_trans p1 istep557_2 + have p3 := stepPlus_trans p2 istep557_3 + have p4 := stepPlus_trans p3 istep557_4 + have p5 := stepPlus_trans p4 istep557_5 + have p6 := stepPlus_trans p5 istep557_6 + have p7 := stepPlus_trans p6 istep557_7 + have p8 := stepPlus_trans p7 istep557_8 + have p9 := stepPlus_trans p8 istep557_9 + have p10 := stepPlus_trans p9 istep557_10 + have p11 := stepPlus_trans p10 istep557_11 + exact stepPlus_stepStar_trans p11 istep557_12 + + +def st638_init : CState := .mk true .F [] [] +def st638_0 : CState := .mk true .F [] [] +def st638_1 : CState := + .mk false .A [.mk .b0 1, .mk .b0 35, .mk .b0 52, .mk .b1 8, .mk .b0 2, .mk .b1 4, .mk .b0 2, + .mk .b1 4, .mk .b0 3, .mk .b0 3, .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 1, .mk .b1 37, + .mk .b1 36, .mk .b0 936, .mk .b1 2735, .mk .b1 7, .mk .b1 752, .mk .b0 554] +def st638_2 : CState := + .mk true .B [.mk .b1 8, .mk .b0 2734, .mk .b1 936, .mk .b0 36, .mk .b1 40, .mk .b0 35, + .mk .b0 51, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 3, .mk .b0 3, .mk .b0 1, + .mk .b0 5, .mk .b0 3, .mk .b0 3, .mk .b0 2] [.mk .b0 220, .mk .b1 6525] +def st638_3 : CState := + .mk false .D [.mk .b0 5, .mk .b0 8281, .mk .b0 2736, .mk .b1 936, .mk .b0 34, .mk .b1 40, + .mk .b0 36, .mk .b1 52, .mk .b0 5, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 3, .mk .b0 3, + .mk .b0 1, .mk .b0 5, .mk .b0 2, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 2264, + .mk .b0 782] +def st638_4 : CState := + .mk false .D [.mk .b1 1, .mk .b1 5481, .mk .b1 2264, .mk .b0 5, .mk .b0 8281, .mk .b0 2736, + .mk .b1 936, .mk .b0 34, .mk .b1 40, .mk .b0 36, .mk .b1 52, .mk .b0 5, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 3, .mk .b0 3, .mk .b0 2, .mk .b1 4, .mk .b0 3, + .mk .b0 3, .mk .b0 2] [.mk .b1 1] +def st638_5 : CState := + .mk true .B [.mk .b1 1668, .mk .b0 9, .mk .b0 8277, .mk .b0 2737, .mk .b0 936, .mk .b1 36, + .mk .b0 37, .mk .b0 37, .mk .b0 52, .mk .b1 8, .mk .b0 3, .mk .b0 3, .mk .b0 4, .mk .b1 4, + .mk .b0 3, .mk .b0 3, .mk .b0 2, .mk .b1 4, .mk .b0 3, .mk .b0 3, .mk .b0 1, .mk .b0 5, + .mk .b0 2] [.mk .b1 1, .mk .b1 11574, .mk .b0 2] +def st638_6 : CState := + .mk true .B [.mk .b1 1, .mk .b1 36, .mk .b0 52, .mk .b1 8, .mk .b0 2, .mk .b1 4, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 3, + .mk .b0 3, .mk .b0 2] [.mk .b1 37, .mk .b1 36, .mk .b0 936, .mk .b1 2735, .mk .b1 8279, + .mk .b1 8, .mk .b0 836, .mk .b1 18229] +def st638_7 : CState := + .mk true .A [.mk .b0 24872, .mk .b1 7, .mk .b1 8, .mk .b0 8277, .mk .b0 2737, .mk .b0 935, + .mk .b0 36, .mk .b1 40, .mk .b0 33, .mk .b0 53, .mk .b0 8, .mk .b1 4, .mk .b0 2, .mk .b1 4, + .mk .b0 4, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 1] +def st638_8 : CState := + .mk false .D [.mk .b0 4, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 3, + .mk .b0 3, .mk .b0 2, .mk .b1 4, .mk .b0 2] [.mk .b1 3, .mk .b1 3, .mk .b1 4, .mk .b0 8, + .mk .b1 51, .mk .b1 35, .mk .b1 40, .mk .b0 36, .mk .b1 935, .mk .b1 2735, .mk .b1 8280, + .mk .b0 24912, .mk .b1 4, .mk .b0 3930, .mk .b1 1] +def st638_9 : CState := + .mk true .B [.mk .b0 8, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 4, .mk .b1 4, .mk .b0 3, + .mk .b0 3, .mk .b0 1, .mk .b0 5, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, + .mk .b0 2] [.mk .b1 51, .mk .b1 35, .mk .b1 40, .mk .b0 36, .mk .b1 935, .mk .b1 2735, + .mk .b1 8280, .mk .b0 24912, .mk .b1 4, .mk .b0 5902] +def st638_10 : CState := + .mk false .D [.mk .b0 24912, .mk .b1 8280, .mk .b0 2735, .mk .b0 935, .mk .b0 36, .mk .b1 40, + .mk .b0 33, .mk .b0 53, .mk .b0 8, .mk .b1 4, .mk .b0 2, .mk .b1 4, .mk .b0 4, .mk .b1 4, + .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, + .mk .b0 2] [.mk .b1 3, .mk .b1 6397, .mk .b1 1] +def st638_11 : CState := + .mk true .B [.mk .b1 1, .mk .b1 936, .mk .b0 36, .mk .b1 40, .mk .b0 34, .mk .b1 52, .mk .b0 8, + .mk .b1 4, .mk .b0 3, .mk .b0 3, .mk .b0 4, .mk .b1 4, .mk .b0 3, .mk .b0 3, .mk .b0 3, + .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 3, .mk .b0 2] [.mk .b1 2733, .mk .b1 8280, + .mk .b0 24912, .mk .b1 4, .mk .b0 6426, .mk .b1 1] +def st638_12 : CState := + .mk true .B [.mk .b0 2] [.mk .b1 3, .mk .b1 3, .mk .b1 3, .mk .b1 3, .mk .b1 3, .mk .b1 3, + .mk .b1 3, .mk .b1 3, .mk .b1 3, .mk .b1 4, .mk .b0 4, .mk .b1 3, .mk .b1 3, .mk .b1 4, + .mk .b0 8, .mk .b1 51, .mk .b1 35, .mk .b1 40, .mk .b0 36, .mk .b1 935, .mk .b1 2735, + .mk .b1 8280, .mk .b0 24912, .mk .b1 4, .mk .b0 6442] +def st638_13 : CState := + .mk true .B [.mk .b1 4, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 937, .mk .b0 36, + .mk .b1 40, .mk .b0 33, .mk .b0 53, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b0 6442] +def st638_14 : CState := + .mk true .C [.mk .b1 6444, .mk .b0 3, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 937, + .mk .b0 36, .mk .b1 40, .mk .b0 33, .mk .b0 53, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b0 2] +def st638_15 : CState := + .mk false .D [.mk .b0 3, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 937, .mk .b0 36, + .mk .b1 40, .mk .b0 33, .mk .b0 53, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] [.mk .b1 6445, .mk .b1 1] + +theorem step638_0 : cstep2n 15 st638_0 = st638_1 := by decide +kernel +theorem step638_1 : cstep2n 15 st638_1 = st638_2 := by decide +kernel +theorem step638_2 : cstep2n 15 st638_2 = st638_3 := by decide +kernel +theorem step638_3 : cstep2n 15 st638_3 = st638_4 := by decide +kernel +theorem step638_4 : cstep2n 15 st638_4 = st638_5 := by decide +kernel +theorem step638_5 : cstep2n 15 st638_5 = st638_6 := by decide +kernel +theorem step638_6 : cstep2n 15 st638_6 = st638_7 := by decide +kernel +theorem step638_7 : cstep2n 15 st638_7 = st638_8 := by decide +kernel +theorem step638_8 : cstep2n 14 st638_8 = st638_9 := by decide +kernel +theorem step638_9 : cstep2n 12 st638_9 = st638_10 := by decide +kernel +theorem step638_10 : cstep2n 8 st638_10 = st638_11 := by decide +kernel +theorem step638_11 : cstep2n 7 st638_11 = st638_12 := by decide +kernel +theorem step638_12 : cstep2n 6 st638_12 = st638_13 := by decide +kernel +theorem step638_13 : cstep2n 3 st638_13 = st638_14 := by decide +kernel +theorem step638_14 : cstep2n 1 st638_14 = st638_15 := by decide +kernel + +theorem stem_638 : (ev_cfg [] (fun _ => default) (toCfg st638_init)) [tm372]⊢* + (ev_cfg [] (fun _ => default) (toCfg st638_15)) := by + have h15 : (ev_cfg [] (fun _ => default) (toCfg st638_15)) [tm372]⊢* + (ev_cfg [] (fun _ => default) (toCfg st638_15)) := ⟨0, rfl⟩ + have h14 := chain_cstep2n 1 st638_14 st638_15 st638_15 step638_14 h15 + have h13 := chain_cstep2n 3 st638_13 st638_14 st638_15 step638_13 h14 + have h12 := chain_cstep2n 6 st638_12 st638_13 st638_15 step638_12 h13 + have h11 := chain_cstep2n 7 st638_11 st638_12 st638_15 step638_11 h12 + have h10 := chain_cstep2n 8 st638_10 st638_11 st638_15 step638_10 h11 + have h9 := chain_cstep2n 12 st638_9 st638_10 st638_15 step638_9 h10 + have h8 := chain_cstep2n 14 st638_8 st638_9 st638_15 step638_8 h9 + have h7 := chain_cstep2n 15 st638_7 st638_8 st638_15 step638_7 h8 + have h6 := chain_cstep2n 15 st638_6 st638_7 st638_15 step638_6 h7 + have h5 := chain_cstep2n 15 st638_5 st638_6 st638_15 step638_5 h6 + have h4 := chain_cstep2n 15 st638_4 st638_5 st638_15 step638_4 h5 + have h3 := chain_cstep2n 15 st638_3 st638_4 st638_15 step638_3 h4 + have h2 := chain_cstep2n 15 st638_2 st638_3 st638_15 step638_2 h3 + have h1 := chain_cstep2n 15 st638_1 st638_2 st638_15 step638_1 h2 + have h0 := chain_cstep2n 15 st638_0 st638_1 st638_15 step638_0 h1 + exact h0 + +def l638_in1 : List CRun := + [.mk .b0 3, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 937, .mk .b0 36, .mk .b1 40, + .mk .b0 33, .mk .b0 53, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r638_in1 : List CRun := [.mk .b1 6445, .mk .b1 1] +def nus638_1 : List (List Nat) := [[6227, 2069, 683, 233], [8, 9, 8, 12], [1, 0, 0, 0]] +def l638_after1 : List CRun := + [.mk .b0 1, .mk .b0 24913, .mk .b0 8280, .mk .b1 2736, .mk .b0 933, .mk .b0 37, .mk .b0 40, + .mk .b1 36, .mk .b0 49, .mk .b0 9, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st638_int1 : CState := .mk false .D l638_in1 r638_in1 +def l638_in2 : List CRun := + [.mk .b0 24911, .mk .b0 8280, .mk .b1 2736, .mk .b0 933, .mk .b0 37, .mk .b0 40, .mk .b1 36, + .mk .b0 49, .mk .b0 9, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r638_in2 : List CRun := [.mk .b1 7, .mk .b1 6800, .mk .b0 19329, .mk .b0 2] +def nus638_2 : List (List Nat) := [[2069, 683, 233, 8], [9, 8, 12, 1], [0, 0, 0, 0]] +def l638_after2 : List CRun := + [.mk .b0 1, .mk .b0 8281, .mk .b0 2736, .mk .b1 936, .mk .b0 33, .mk .b0 41, .mk .b0 36, + .mk .b1 52, .mk .b0 5, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st638_int2 : CState := .mk false .D l638_in2 r638_in2 +def l638_in3 : List CRun := + [.mk .b0 8279, .mk .b0 2736, .mk .b1 936, .mk .b0 33, .mk .b0 41, .mk .b0 36, .mk .b1 52, + .mk .b0 5, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r638_in3 : List CRun := [.mk .b1 24911, .mk .b1 7, .mk .b1 361, .mk .b1 71936, .mk .b0 2] +def nus638_3 : List (List Nat) := [[683, 233, 8, 9], [8, 12, 1, 0], [0, 0, 0, 0]] +def l638_after3 : List CRun := + [.mk .b0 1, .mk .b0 2737, .mk .b0 936, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 52, + .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st638_int3 : CState := .mk false .D l638_in3 r638_in3 +def l638_in4 : List CRun := + [.mk .b0 2735, .mk .b0 936, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 52, .mk .b1 8, + .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r638_in4 : List CRun := [.mk .b1 8279, .mk .b1 24912, .mk .b0 74808, .mk .b1 4, .mk .b0 19330] +def nus638_4 : List (List Nat) := [[233, 8, 9, 8], [12, 1, 0, 0], [0, 0, 0, 0]] +def l638_after4 : List CRun := + [.mk .b0 1, .mk .b0 937, .mk .b0 36, .mk .b1 40, .mk .b0 33, .mk .b0 53, .mk .b0 8, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def st638_int4 : CState := .mk false .D l638_in4 r638_in4 +def l638_in5 : List CRun := + [.mk .b0 74807, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 937, .mk .b0 36, .mk .b1 40, + .mk .b0 33, .mk .b0 53, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r638_in5 : List CRun := [.mk .b1 7, .mk .b1 20407, .mk .b1 57965, .mk .b1 1] +def nus638_5 : List (List Nat) := + [[6227, 2069, 683, 233], [8, 9, 8, 12], [1, 0, 0, 0], [0, 0, 0, 0]] +def l638_after5 : List CRun := + [.mk .b0 1, .mk .b0 24913, .mk .b0 8280, .mk .b1 2736, .mk .b0 933, .mk .b0 37, .mk .b0 40, + .mk .b1 36, .mk .b0 49, .mk .b0 9, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st638_int5 : CState := .mk false .D l638_in5 r638_in5 +def l638_in6 : List CRun := + [.mk .b0 24911, .mk .b0 8280, .mk .b1 2736, .mk .b0 933, .mk .b0 37, .mk .b0 40, .mk .b1 36, + .mk .b0 49, .mk .b0 9, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r638_in6 : List CRun := [.mk .b1 74807, .mk .b1 8, .mk .b0 1088, .mk .b1 215797] +def nus638_6 : List (List Nat) := [[2069, 683, 233, 8], [9, 8, 12, 1], [0, 0, 0, 0], [0, 0, 0, 0]] +def l638_after6 : List CRun := + [.mk .b0 1, .mk .b0 8281, .mk .b0 2736, .mk .b1 936, .mk .b0 33, .mk .b0 41, .mk .b0 36, + .mk .b1 52, .mk .b0 5, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st638_int6 : CState := .mk false .D l638_in6 r638_in6 +def l638_in7 : List CRun := + [.mk .b0 3, .mk .b0 224496, .mk .b1 74808, .mk .b0 24909, .mk .b0 8281, .mk .b0 2736, + .mk .b1 936, .mk .b0 33, .mk .b0 41, .mk .b0 36, .mk .b1 52, .mk .b0 5, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r638_in7 : List CRun := [.mk .b1 57961, .mk .b1 1] +def nus638_7 : List (List Nat) := + [[56123, 18701, 6227, 2069], [683, 233, 8, 9], [8, 12, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0]] +def l638_after7 : List CRun := + [.mk .b0 1, .mk .b0 224497, .mk .b0 74808, .mk .b1 24912, .mk .b0 8277, .mk .b0 2737, + .mk .b0 936, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 52, .mk .b1 8, .mk .b0 1, .mk .b0 5, + .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st638_int7 : CState := .mk false .D l638_in7 r638_in7 +def l638_in8 : List CRun := + [.mk .b0 224495, .mk .b0 74808, .mk .b1 24912, .mk .b0 8277, .mk .b0 2737, .mk .b0 936, + .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 52, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r638_in8 : List CRun := [.mk .b1 7, .mk .b1 61232, .mk .b0 173877, .mk .b0 2] +def nus638_8 : List (List Nat) := + [[18701, 6227, 2069, 683], [233, 8, 9, 8], [12, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] +def l638_after8 : List CRun := + [.mk .b0 1, .mk .b0 74809, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 937, .mk .b0 36, + .mk .b1 40, .mk .b0 33, .mk .b0 53, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st638_int8 : CState := .mk false .D l638_in8 r638_in8 +def l638_in9 : List CRun := + [.mk .b0 74807, .mk .b0 24912, .mk .b1 8280, .mk .b0 2733, .mk .b0 937, .mk .b0 36, .mk .b1 40, + .mk .b0 33, .mk .b0 53, .mk .b0 8, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r638_in9 : List CRun := [.mk .b1 224495, .mk .b1 7, .mk .b1 3277, .mk .b1 647360, .mk .b0 2] +def nus638_9 : List (List Nat) := + [[6227, 2069, 683, 233], [8, 9, 8, 12], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] +def l638_after9 : List CRun := + [.mk .b0 1, .mk .b0 24913, .mk .b0 8280, .mk .b1 2736, .mk .b0 933, .mk .b0 37, .mk .b0 40, + .mk .b1 36, .mk .b0 49, .mk .b0 9, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st638_int9 : CState := .mk false .D l638_in9 r638_in9 +def l638_in10 : List CRun := + [.mk .b0 24911, .mk .b0 8280, .mk .b1 2736, .mk .b0 933, .mk .b0 37, .mk .b0 40, .mk .b1 36, + .mk .b0 49, .mk .b0 9, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, + .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 5, .mk .b0 2] +def r638_in10 : List CRun := + [.mk .b1 74807, .mk .b1 224496, .mk .b0 673560, .mk .b1 4, .mk .b0 173878] +def nus638_10 : List (List Nat) := + [[2069, 683, 233, 8], [9, 8, 12, 1], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] +def l638_after10 : List CRun := + [.mk .b0 1, .mk .b0 8281, .mk .b0 2736, .mk .b1 936, .mk .b0 33, .mk .b0 41, .mk .b0 36, + .mk .b1 52, .mk .b0 5, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, + .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st638_int10 : CState := .mk false .D l638_in10 r638_in10 +def l638_in11 : List CRun := + [.mk .b0 673559, .mk .b0 224496, .mk .b1 74808, .mk .b0 24909, .mk .b0 8281, .mk .b0 2736, + .mk .b1 936, .mk .b0 33, .mk .b0 41, .mk .b0 36, .mk .b1 52, .mk .b0 5, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r638_in11 : List CRun := [.mk .b1 7, .mk .b1 183703, .mk .b1 521609, .mk .b1 1] +def nus638_11 : List (List Nat) := + [[56123, 18701, 6227, 2069], [683, 233, 8, 9], [8, 12, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, + 0, 0]] +def l638_after11 : List CRun := + [.mk .b0 1, .mk .b0 224497, .mk .b0 74808, .mk .b1 24912, .mk .b0 8277, .mk .b0 2737, + .mk .b0 936, .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 52, .mk .b1 8, .mk .b0 1, .mk .b0 5, + .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, + .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def st638_int11 : CState := .mk false .D l638_in11 r638_in11 +def l638_in12 : List CRun := + [.mk .b0 224495, .mk .b0 74808, .mk .b1 24912, .mk .b0 8277, .mk .b0 2737, .mk .b0 936, + .mk .b1 36, .mk .b0 37, .mk .b0 37, .mk .b0 52, .mk .b1 8, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 4, + .mk .b1 4, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 6, .mk .b1 4, .mk .b0 1, .mk .b0 5, + .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 1, .mk .b0 5, .mk .b0 2] +def r638_in12 : List CRun := [.mk .b1 673559, .mk .b1 8, .mk .b0 9836, .mk .b1 1942069] +def st638_int12 : CState := .mk false .D l638_in12 r638_in12 + +theorem istep638_1 : (ev_cfg [] (fun _ => default) (toCfg st638_int1)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st638_int2)) := by + exact interval_step_zero 3 119 6441 51 l638_in1 r638_in1 + l638_after1 r_after_c1 nus638_1 prog_c1 Rs_c1 Re_c1 st638_int2 + (by decide +kernel) (by decide +kernel) (by decide) (by decide) + (by decide) (by decide) int_c1 (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep638_2 : (ev_cfg [] (fun _ => default) (toCfg st638_int2)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st638_int3)) := by + exact interval_step_pos 24908 3 119 6441 72 l638_in2 r638_in2 + l638_after2 r_after_c2 nus638_2 prog_c2 Rs_c2 Re_c2 st638_int3 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c2 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep638_3 : (ev_cfg [] (fun _ => default) (toCfg st638_int3)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st638_int4)) := by + exact interval_step_pos 8276 3 119 6441 56 l638_in3 r638_in3 + l638_after3 r_after_c3 nus638_3 prog_c3 Rs_c3 Re_c3 st638_int4 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c3 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep638_4 : (ev_cfg [] (fun _ => default) (toCfg st638_int4)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st638_int5)) := by + exact interval_step_pos 2732 3 119 6441 43 l638_in4 r638_in4 + l638_after4 r_after_c4 nus638_4 prog_c4 Rs_c4 Re_c4 st638_int5 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c4 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep638_5 : (ev_cfg [] (fun _ => default) (toCfg st638_int5)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st638_int6)) := by + exact interval_step_pos 74804 4 362 19320 111 l638_in5 r638_in5 + l638_after5 r_after_c5 nus638_5 prog_c5 Rs_c5 Re_c5 st638_int6 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c5 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep638_6 : (ev_cfg [] (fun _ => default) (toCfg st638_int6)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st638_int7)) := by + exact interval_step_pos 24908 4 362 19320 14 l638_in6 r638_in6 + l638_after6 r_after_c6 nus638_6 prog_c6 Rs_c6 Re_c6 st638_int7 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c6 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep638_7 : (ev_cfg [] (fun _ => default) (toCfg st638_int7)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st638_int8)) := by + exact interval_step_zero 5 1091 57957 51 l638_in7 r638_in7 + l638_after7 r_after_c7 nus638_7 prog_c7 Rs_c7 Re_c7 st638_int8 + (by decide +kernel) (by decide +kernel) (by decide) (by decide) + (by decide) (by decide) int_c7 (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep638_8 : (ev_cfg [] (fun _ => default) (toCfg st638_int8)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st638_int9)) := by + exact interval_step_pos 224492 5 1091 57957 72 l638_in8 r638_in8 + l638_after8 r_after_c8 nus638_8 prog_c8 Rs_c8 Re_c8 st638_int9 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c8 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep638_9 : (ev_cfg [] (fun _ => default) (toCfg st638_int9)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st638_int10)) := by + exact interval_step_pos 74804 5 1091 57957 56 l638_in9 r638_in9 + l638_after9 r_after_c9 nus638_9 prog_c9 Rs_c9 Re_c9 st638_int10 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c9 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep638_10 : (ev_cfg [] (fun _ => default) (toCfg st638_int10)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st638_int11)) := by + exact interval_step_pos 24908 5 1091 57957 43 l638_in10 r638_in10 + l638_after10 r_after_c10 nus638_10 prog_c10 Rs_c10 Re_c10 st638_int11 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c10 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep638_11 : (ev_cfg [] (fun _ => default) (toCfg st638_int11)) [tm372]⊢⁺ + (ev_cfg [] (fun _ => default) (toCfg st638_int12)) := by + exact interval_step_pos 673556 6 3278 173868 111 l638_in11 r638_in11 + l638_after11 r_after_c11 nus638_11 prog_c11 Rs_c11 Re_c11 st638_int12 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) + (by decide) (by decide) (by decide) (by decide) int_c11 + (by decide +kernel) (by decide +kernel) (by decide +kernel) + +theorem istep638_12 : (ev_cfg [] (fun _ => default) (toCfg st638_int12)) [tm372]⊢* + cfgI (.C5, 2, 0, nus28_638) := by + exact final_to_cfgI 224492 l638_in12 r638_in12 nus28_638 + (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide +kernel) (by decide) + +theorem reach_cfgI_638 : (ev_cfg [] (fun _ => default) (toCfg st638_init)) [tm372]⊢⁺ + cfgI (.C5, 2, 0, nus28_638) := by + have h0 : st638_15 = st638_int1 := rfl + have hs := stem_638 + rw [h0] at hs + have p1 := stepStar_stepPlus_trans hs istep638_1 + have p2 := stepPlus_trans p1 istep638_2 + have p3 := stepPlus_trans p2 istep638_3 + have p4 := stepPlus_trans p3 istep638_4 + have p5 := stepPlus_trans p4 istep638_5 + have p6 := stepPlus_trans p5 istep638_6 + have p7 := stepPlus_trans p6 istep638_7 + have p8 := stepPlus_trans p7 istep638_8 + have p9 := stepPlus_trans p8 istep638_9 + have p10 := stepPlus_trans p9 istep638_10 + have p11 := stepPlus_trans p10 istep638_11 + exact stepPlus_stepStar_trans p11 istep638_12 + + +theorem neverHaltsFrom_of_reach_cfgI {c₀ : Cfg6} (s : ist) + (hinit : c₀ [tm372]⊢* (cfgI s)) (hs : Inv s) : + ∀ cfg : Cfg6, (c₀ [tm372]⊢* cfg) → (step tm372 cfg).isSome := by + refine Counter.does_not_halt_of_invariant + (Inv := fun x => ∃ s', x = cfgI s' ∧ Inv s') + ⟨cfgI s, hinit, s, rfl, hs⟩ ?_ + rintro x ⟨s', rfl, hs'⟩ + rcases inv_step s' hs' with ⟨s'', hstep, hinv''⟩ + exact ⟨cfgI s'', hstep, s'', rfl, hinv''⟩ + +end + +public section + +theorem is_not_halt_from_0557 : + ∀ cfg : Cfg (Fin 2) (Fin 6), + (((default : ListBlank (Fin 2)) {{1}}> default) [target]⊢* cfg) → + (step target cfg).isSome := by + rw [target_eq_tm372] + have hinit : ReachesStar tm372 ((default : ListBlank (Fin 2)) {{1}}> default) + (cfgI (.C5, 2, 0, nus28_557)) := by + have h0 : ((default : ListBlank (Fin 2)) {{1}}> default) = + ev_cfg [] (fun _ => default) (toCfg st557_init) := rfl + rw [h0] + exact stepPlus_to_stepStar reach_cfgI_557 + exact neverHaltsFrom_of_reach_cfgI (.C5, 2, 0, nus28_557) hinit inv28_557 + +theorem is_not_halt_from_0638 : + ∀ cfg : Cfg (Fin 2) (Fin 6), + (((default : ListBlank (Fin 2)) {{5}}> default) [target]⊢* cfg) → + (step target cfg).isSome := by + rw [target_eq_tm372] + have hinit : ReachesStar tm372 ((default : ListBlank (Fin 2)) {{5}}> default) + (cfgI (.C5, 2, 0, nus28_638)) := by + have h0 : ((default : ListBlank (Fin 2)) {{5}}> default) = + ev_cfg [] (fun _ => default) (toCfg st638_init) := rfl + rw [h0] + exact stepPlus_to_stepStar reach_cfgI_638 + exact neverHaltsFrom_of_reach_cfgI (.C5, 2, 0, nus28_638) hinit inv28_638 + +theorem is_not_halt : IsNotHalt target := by + rw [target_eq_tm372] + have hinit : ReachesStar tm372 (init []) (cfgI (.C5, 2, 0, nus28_372)) := by + have h0 : init [] = ev_cfg [] (fun _ => default) (toCfg st372_init) := rfl + rw [h0] + exact stepPlus_to_stepStar reach_cfgI_372 + exact isNotHalt_of_reach_cfgI (.C5, 2, 0, nus28_372) hinit inv28_372 + +end + +end BusyBeaver.M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH diff --git a/BusyBeaver/BB6/NonHalt/M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE.lean b/BusyBeaver/BB6/NonHalt/M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE.lean new file mode 100644 index 00000000..73a99bcd --- /dev/null +++ b/BusyBeaver/BB6/NonHalt/M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE.lean @@ -0,0 +1,46 @@ +/- +Copyright (c) 2026 Google LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +-/ +module + +import BusyBeaver.Basic +public import BusyBeaver.Bridge +import BusyBeaver.Calculi.Counter +import BusyBeaver.BB6.NonHalt.M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA + +open Mathlib Relation Nat Turing BusyBeaver SixState + +namespace BusyBeaver.M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE + +@[expose] public section + +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE" + +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB + +end + +def stateMap_m0554 : Fin 6 → Fin 6 + | 0 => 5 + | 1 => 3 + | 2 => 4 + | 3 => 1 + | 4 => 2 + | 5 => 0 + +public section + +theorem is_not_halt : IsNotHalt target := by + exact Counter.does_not_halt_of_conj_stem + (M_tgt := target) + (M_src := BusyBeaver.M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA.target) + (σ := stateMap_m0554) (f := true) + (c₁ := (default : ListBlank (Fin 2)) {{5}}> default) + (by decide) (Counter.init_reaches_conjCfg_default rfl) + BusyBeaver.M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA.is_not_halt_from_0554 + +end + +end BusyBeaver.M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE diff --git a/BusyBeaver/BB6/NonHalt/M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD.lean b/BusyBeaver/BB6/NonHalt/M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD.lean new file mode 100644 index 00000000..ba1a88c4 --- /dev/null +++ b/BusyBeaver/BB6/NonHalt/M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD.lean @@ -0,0 +1,4475 @@ +/- +Copyright (c) 2026 Google LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +-/ +module + +import BusyBeaver.Basic +public import BusyBeaver.Bridge +import BusyBeaver.WordRLE + +open Mathlib Relation Nat Turing BusyBeaver SixState + +namespace BusyBeaver.M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD + +@[expose] public section + +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD" + +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB + +end + +abbrev target_tm : Machine (Fin 2) (Fin 6) := target + + +@[simp] +theorem zero_pow_append_default (n : ℕ) : + ([0] : List (Fin 2)) ^ n +> (default : ListBlank (Fin 2)) = default := + WordRLE.lb_blank_pow [0] (by decide) n + +/-! ## Reflective Trigram-Halfspace Symbolic Certificate Verifier -/ + +abbrev b0 : Fin 2 := 0 +abbrev b1 : Fin 2 := 1 + +@[inline] +def forceNat {α : Type*} (n : ℕ) (k : ℕ → α) : α := + Nat.casesOn (Nat.add n 1) (k 0) k + +theorem forceNat_eq {α : Type*} (n : ℕ) (k : ℕ → α) : forceNat n k = k n := + rfl + +def qOf : ℕ → Fin 6 + | 0 => 0 + | 1 => 1 + | 2 => 2 + | 3 => 3 + | 4 => 4 + | _ => 5 + +def stepCode : ℕ → Fin 2 → Option (Fin 2 × Bool × ℕ) + | 0, 0 => some (1, true, 1) + | 0, 1 => some (1, true, 0) + | 1, 0 => some (0, false, 2) + | 1, 1 => some (0, true, 0) + | 2, 0 => some (1, true, 2) + | 2, 1 => some (1, false, 3) + | 3, 0 => some (0, false, 1) + | 3, 1 => some (1, false, 4) + | 4, 0 => some (1, false, 5) + | 4, 1 => some (0, true, 2) + | 5, 1 => some (0, false, 3) + | _, _ => none + +theorem stepCode_agrees : WordRLE.StepCodeAgrees target_tm qOf stepCode := by + intro q a b dir' q' h + rcases a with ⟨_ | _ | n, ha⟩ + · match q with + | 0 | 1 | 2 | 3 | 4 => + simp only [stepCode] at h + rcases h with ⟨rfl, rfl, rfl⟩ + rfl + | 5 => simp [stepCode] at h + | _ + 6 => simp [stepCode] at h + · match q with + | 0 | 1 | 2 | 3 | 4 | 5 => + simp only [stepCode] at h + rcases h with ⟨rfl, rfl, rfl⟩ + rfl + | _ + 6 => simp [stepCode] at h + · omega + +def StepRel (prog : Bool) (c₁ c₂ : Cfg (Fin 2) (Fin 6)) : Prop := + if prog then ReachesPlus target_tm c₁ c₂ else ReachesStar target_tm c₁ c₂ + +theorem StepRel.refl (c : Cfg (Fin 2) (Fin 6)) : StepRel false c c := + ⟨0, rfl⟩ + +theorem StepRel.trans {p₁ p₂ : Bool} {c₁ c₂ c₃ : Cfg (Fin 2) (Fin 6)} + (h₁ : StepRel p₁ c₁ c₂) (h₂ : StepRel p₂ c₂ c₃) : + StepRel (p₁ || p₂) c₁ c₃ := by + cases p₁ <;> cases p₂ + · exact ReachesStar.trans h₁ h₂ + · exact ReachesStar.trans_plus h₁ h₂ + · exact ReachesPlus.trans_star h₁ h₂ + · exact ReachesPlus.trans h₁ h₂ + +theorem StepRel.chain {gProg dp : Bool} {c₁ c₂ c₃ : Cfg (Fin 2) (Fin 6)} + (h₁ : StepRel dp c₁ c₂) (h₂ : StepRel (!(gProg || dp)) c₂ c₃) : + StepRel (!gProg) c₁ c₃ := by + have htr := StepRel.trans h₁ h₂ + cases gProg <;> cases dp + · exact htr + · exact htr + · exact htr + · exact ReachesPlus.to_star htr + +theorem StepRel.of_reachesIn {dt : ℕ} {prog : Bool} {c₁ c₂ : Cfg (Fin 2) (Fin 6)} + (h : ReachesIn target_tm dt c₁ c₂) (hp : prog = true → dt > 0) : + StepRel prog c₁ c₂ := by + cases prog + · exact ⟨dt, h⟩ + · exact ⟨dt, hp rfl, h⟩ + +/-! ### GMP Bit-Packed Concrete Zipper (`simZipNat`) -/ + +def bitOfBool (b : Bool) : Fin 2 := + if b then b1 else b0 + +def unpackBits : ℕ → ℕ → List (Fin 2) + | 0, _ => [] + | k + 1, bits => + forceNat (bits / 2) fun rest ↦ + bitOfBool (Nat.beq (bits % 2) 1) :: unpackBits k rest + +theorem unpackBits_push (b : Bool) (k bits : ℕ) : + unpackBits (k + 1) ((if b then 1 else 0) + 2 * bits) = + bitOfBool b :: unpackBits k bits := by + cases b + · simp only [Bool.false_eq_true, ↓reduceIte, unpackBits, forceNat_eq] + have hm : (0 + 2 * bits) % 2 = 0 := by omega + have hd : (0 + 2 * bits) / 2 = bits := by omega + rw [hm, hd] + rfl + · simp only [↓reduceIte, unpackBits, forceNat_eq] + have hm : (1 + 2 * bits) % 2 = 1 := by omega + have hd : (1 + 2 * bits) / 2 = bits := by omega + rw [hm, hd] + rfl + +theorem unpackBits_zero_append (k : ℕ) : + ListBlank.append (unpackBits k 0) (default : ListBlank (Fin 2)) = default := by + induction k with + | zero => rfl + | succ n ih => + change ListBlank.cons 0 (ListBlank.append (unpackBits n 0) default) = default + rw [ih, ListBlank.cons_zero_default] + +def stepCodeBool : ℕ → Bool → Option (Bool × Bool × ℕ) + | 0, false => some (true, true, 1) + | 0, true => some (true, true, 0) + | 1, false => some (false, false, 2) + | 1, true => some (false, true, 0) + | 2, false => some (true, true, 2) + | 2, true => some (true, false, 3) + | 3, false => some (false, false, 1) + | 3, true => some (true, false, 4) + | 4, false => some (true, false, 5) + | 4, true => some (false, true, 2) + | 5, true => some (false, false, 3) + | _, _ => none + +theorem stepCodeBool_agrees (q : ℕ) (a w dir' : Bool) (q' : ℕ) + (h : stepCodeBool q a = some (w, dir', q')) : + stepCode q (bitOfBool a) = some (bitOfBool w, dir', q') := by + cases a + · match q with + | 0 | 1 | 2 | 3 | 4 => + simp only [stepCodeBool, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl, rfl⟩ + rfl + | 5 => simp [stepCodeBool] at h + | _ + 6 => simp [stepCodeBool] at h + · match q with + | 0 | 1 | 2 | 3 | 4 | 5 => + simp only [stepCodeBool, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl, rfl⟩ + rfl + | _ + 6 => simp [stepCodeBool] at h + +noncomputable def simZipNat : ℕ → ℕ → Bool → ℕ → ℕ → ℕ → ℕ → + Option (ℕ × Bool × ℕ × ℕ × ℕ × ℕ) + | 0, q, dir, kL, lB, kR, rB => + forceNat q fun q' ↦ forceNat kL fun kL' ↦ forceNat lB fun lB' ↦ + forceNat kR fun kR' ↦ forceNat rB fun rB' ↦ + some (q', dir, kL', lB', kR', rB') + | steps + 1, q, true, kL, lB, kR + 1, rB => + let a := Nat.beq (rB % 2) 1 + forceNat (rB / 2) fun rB' ↦ + match stepCodeBool q a with + | none => none + | some (w, true, q') => + forceNat (kL + 1) fun kL' ↦ + forceNat ((if w then 1 else 0) + 2 * lB) fun lB' ↦ + simZipNat steps q' true kL' lB' kR rB' + | some (w, false, q') => + forceNat (kR + 1) fun kR1 ↦ + forceNat ((if w then 1 else 0) + 2 * rB') fun rB1 ↦ + simZipNat steps q' false kL lB kR1 rB1 + | _ + 1, _, true, _, _, 0, _ => none + | steps + 1, q, false, kL + 1, lB, kR, rB => + let a := Nat.beq (lB % 2) 1 + forceNat (lB / 2) fun lB' ↦ + match stepCodeBool q a with + | none => none + | some (w, true, q') => + forceNat (kL + 1) fun kL1 ↦ + forceNat ((if w then 1 else 0) + 2 * lB') fun lB1 ↦ + simZipNat steps q' true kL1 lB1 kR rB + | some (w, false, q') => + forceNat (kR + 1) fun kR' ↦ + forceNat ((if w then 1 else 0) + 2 * rB) fun rB' ↦ + simZipNat steps q' false kL lB' kR' rB' + | _ + 1, _, false, 0, _, _, _ => none + +theorem simZipNat_sound : + ∀ (steps q : ℕ) (dir : Bool) (kL lB kR rB : ℕ) + (q' : ℕ) (dir' : Bool) (kL' lB' kR' rB' : ℕ) (l r : ListBlank (Fin 2)), + simZipNat steps q dir kL lB kR rB = some (q', dir', kL', lB', kR', rB') → + ReachesIn target_tm steps + (WordRLE.dirCfg qOf q dir + (ListBlank.append (unpackBits kL lB) l) + (ListBlank.append (unpackBits kR rB) r)) + (WordRLE.dirCfg qOf q' dir' + (ListBlank.append (unpackBits kL' lB') l) + (ListBlank.append (unpackBits kR' rB') r)) + | 0, q, dir, kL, lB, kR, rB, q', dir', kL', lB', kR', rB', l, r, h => by + simp only [simZipNat, forceNat_eq, Option.some.injEq, Prod.mk.injEq] at h + rcases h with ⟨rfl, rfl, rfl, rfl, rfl, rfl⟩ + exact ReachesIn.zero target_tm _ + | steps + 1, q, true, kL, lB, 0, rB, _, _, _, _, _, _, _, _, h => by + simp [simZipNat] at h + | steps + 1, q, true, kL, lB, kR + 1, rB, q', dir', kL', lB', kR', rB', l, r, h => by + simp only [simZipNat, forceNat_eq] at h + rcases hsc : stepCodeBool q (Nat.beq (rB % 2) 1) with _ | ⟨w, dNext, qNext⟩ + · simp [hsc] at h + · rw [hsc] at h + have hscFin := stepCode_agrees q _ _ dNext qNext (stepCodeBool_agrees _ _ _ _ _ hsc) + cases dNext + · simp only at h + have ih := simZipNat_sound steps qNext false kL lB (kR + 1) + ((if w then 1 else 0) + 2 * (rB / 2)) q' dir' kL' lB' kR' rB' l r h + rw [unpackBits_push] at ih + have hst := step_headRight_left hscFin + (ListBlank.append (unpackBits kL lB) l) + (ListBlank.append (unpackBits kR (rB / 2)) r) + exact ReachesIn.step_left hst ih + · simp only at h + have ih := simZipNat_sound steps qNext true (kL + 1) + ((if w then 1 else 0) + 2 * lB) kR (rB / 2) q' dir' kL' lB' kR' rB' l r h + rw [unpackBits_push] at ih + have hst := step_headRight_right hscFin + (ListBlank.append (unpackBits kL lB) l) + (ListBlank.append (unpackBits kR (rB / 2)) r) + exact ReachesIn.step_left hst ih + | steps + 1, q, false, 0, lB, kR, rB, _, _, _, _, _, _, _, _, h => by + simp [simZipNat] at h + | steps + 1, q, false, kL + 1, lB, kR, rB, q', dir', kL', lB', kR', rB', l, r, h => by + simp only [simZipNat, forceNat_eq] at h + rcases hsc : stepCodeBool q (Nat.beq (lB % 2) 1) with _ | ⟨w, dNext, qNext⟩ + · simp [hsc] at h + · rw [hsc] at h + have hscFin := stepCode_agrees q _ _ dNext qNext (stepCodeBool_agrees _ _ _ _ _ hsc) + cases dNext + · simp only at h + have ih := simZipNat_sound steps qNext false kL (lB / 2) (kR + 1) + ((if w then 1 else 0) + 2 * rB) q' dir' kL' lB' kR' rB' l r h + rw [unpackBits_push] at ih + have hst := step_headLeft_left hscFin + (ListBlank.append (unpackBits kL (lB / 2)) l) + (ListBlank.append (unpackBits kR rB) r) + exact ReachesIn.step_left hst ih + · simp only at h + have ih := simZipNat_sound steps qNext true (kL + 1) + ((if w then 1 else 0) + 2 * (lB / 2)) kR rB q' dir' kL' lB' kR' rB' l r h + rw [unpackBits_push] at ih + have hst := step_headLeft_right hscFin + (ListBlank.append (unpackBits kL (lB / 2)) l) + (ListBlank.append (unpackBits kR rB) r) + exact ReachesIn.step_left hst ih + +structure ZipNatEntry where + steps : ℕ + qIn : ℕ + dirIn : Bool + kL : ℕ + lB : ℕ + kR : ℕ + rB : ℕ + qOut : ℕ + dirOut : Bool + kLOut : ℕ + lOut : ℕ + kROut : ℕ + rOut : ℕ + +noncomputable def unpackZip (p0 : ℕ) : ZipNatEntry := + forceNat (p0 % 65536) fun steps ↦ + forceNat (p0 / 65536) fun p1 ↦ + forceNat (p1 % 8) fun qIn ↦ + let dirIn := Nat.beq ((p1 / 8) % 2) 1 + forceNat (p1 / 16) fun p2 ↦ + forceNat (p2 % 8) fun qOut ↦ + let dirOut := Nat.beq ((p2 / 8) % 2) 1 + forceNat (p2 / 16) fun p3 ↦ + forceNat (p3 % 256) fun kL ↦ + forceNat (p3 / 256) fun p4 ↦ + forceNat (p4 % 256) fun kR ↦ + forceNat (p4 / 256) fun p5 ↦ + forceNat (p5 % 256) fun kLOut ↦ + forceNat (p5 / 256) fun p6 ↦ + forceNat (p6 % 256) fun kROut ↦ + forceNat (p6 / 256) fun p7 ↦ + forceNat (Nat.pow 2 kL) fun mL ↦ + forceNat (p7 % mL) fun lB ↦ + forceNat (p7 / mL) fun p8 ↦ + forceNat (Nat.pow 2 kR) fun mR ↦ + forceNat (p8 % mR) fun rB ↦ + forceNat (p8 / mR) fun p9 ↦ + forceNat (Nat.pow 2 kLOut) fun mLO ↦ + forceNat (p9 % mLO) fun lOut ↦ + forceNat (p9 / mLO) fun rOut ↦ + ⟨steps, qIn, dirIn, kL, lB, kR, rB, qOut, dirOut, kLOut, lOut, kROut, rOut⟩ + +noncomputable def checkZipPacked (_ : ℕ) (p : ℕ) : Bool := + let e := unpackZip p + Nat.ble 1 e.steps && + (simZipNat e.steps e.qIn e.dirIn e.kL e.lB e.kR e.rB == + some (e.qOut, e.dirOut, e.kLOut, e.lOut, e.kROut, e.rOut)) + +/-! ### Trigram Shift Laws -/ + +def symWord : ℕ → List (Fin 2) + | 0 => [0] + | 1 => [1] + | 2 => [0, 1, 0] + | 3 => [1, 1, 0] + | _ => [0, 1, 1] + +theorem exit_waL : + WordRLE.WordExit target_tm qOf [0, 1, 0] 1 false [0, 1, 0] 1 false 3 := + WordRLE.runWordExit_sound stepCode_agrees (fuel := 16) (by decide +kernel) + +theorem exit_wbR : + WordRLE.WordExit target_tm qOf [1, 1, 0] 1 true [0, 1, 1] 1 true 3 := + WordRLE.runWordExit_sound stepCode_agrees (fuel := 16) (by decide +kernel) + +theorem exit_wcL : + WordRLE.WordExit target_tm qOf [0, 1, 1] 5 false [1, 1, 0] 5 false 3 := + WordRLE.runWordExit_sound stepCode_agrees (fuel := 16) (by decide +kernel) + +theorem waR0_one_check : + simZipNat 9 0 true 0 0 4 2 = some (0, true, 3, 2, 1, 0) := by + decide +kernel + +theorem wa_pow_zero_head (n : ℕ) (r : ListBlank (Fin 2)) : + ∃ r', ListBlank.append (([0, 1, 0] : List (Fin 2)) ^ n) (ListBlank.cons 0 r) = + ListBlank.cons 0 r' := by + cases n with + | zero => exact ⟨r, rfl⟩ + | succ k => exact ⟨ListBlank.append [1, 0] (ListBlank.append (([0, 1, 0] : List (Fin 2)) ^ k) + (ListBlank.cons 0 r)), rfl⟩ + +theorem sweep_waR0_sound (n : ℕ) : + ∀ (l r : ListBlank (Fin 2)), + ReachesIn target_tm (9 * n) + (WordRLE.dirCfg qOf 0 true l + (ListBlank.append (([0, 1, 0] : List (Fin 2)) ^ n) (ListBlank.cons 0 r))) + (WordRLE.dirCfg qOf 0 true + (ListBlank.append (([0, 1, 0] : List (Fin 2)) ^ n) l) + (ListBlank.cons 0 r)) := by + induction n with + | zero => + intro l r + exact ReachesIn.zero target_tm _ + | succ k ih => + intro l r + rw [ListBlank.append_pow_succ] + obtain ⟨rMid, hMid⟩ := wa_pow_zero_head k r + have h1 := simZipNat_sound 9 0 true 0 0 4 2 0 true 3 2 1 0 l rMid waR0_one_check + change ReachesIn target_tm 9 + (WordRLE.dirCfg qOf 0 true l (ListBlank.append [0, 1, 0] (ListBlank.cons 0 rMid))) + (WordRLE.dirCfg qOf 0 true (ListBlank.append [0, 1, 0] l) (ListBlank.cons 0 rMid)) at h1 + rw [← hMid] at h1 + have h2 := ih (ListBlank.append [0, 1, 0] l) r + rw [ListBlank.append_pow_comm, ← ListBlank.append_pow_succ] at h2 + have htr := h1.trans h2 + have hdt : 9 + 9 * k = 9 * (k + 1) := by omega + rwa [hdt] at htr + +/-! ### Pure-`ℕ` 3-Variable Affine Forms (`Aff3`), Halfspaces, and Farkas Witnesses -/ + +inductive Var3 where + | va + | vb + | vc + deriving DecidableEq, Inhabited + +structure Aff3 where + c0 : ℕ + ca : ℕ + cb : ℕ + cc : ℕ + deriving DecidableEq, Inhabited + +@[inline] +def Aff3.strict {α : Type*} (e : Aff3) (f : Aff3 → α) : α := + forceNat e.c0 fun c0 ↦ + forceNat e.ca fun ca ↦ + forceNat e.cb fun cb ↦ + forceNat e.cc fun cc ↦ + f ⟨c0, ca, cb, cc⟩ + +theorem Aff3.strict_eq {α : Type*} (e : Aff3) (f : Aff3 → α) : e.strict f = f e := + rfl + +def Aff3.one : Aff3 := ⟨1, 0, 0, 0⟩ +def Aff3.const (k : ℕ) : Aff3 := forceNat k fun k' ↦ ⟨k', 0, 0, 0⟩ + +def Aff3.eval (e : Aff3) (u v w : ℕ) : ℕ := + e.c0 + e.ca * u + e.cb * v + e.cc * w + +def Aff3.isZero (e : Aff3) : Bool := + Nat.beq e.c0 0 && Nat.beq e.ca 0 && Nat.beq e.cb 0 && Nat.beq e.cc 0 + +def Aff3.add (p q : Aff3) : Aff3 := + forceNat (p.c0 + q.c0) fun n0 ↦ + forceNat (p.ca + q.ca) fun na ↦ + forceNat (p.cb + q.cb) fun nb ↦ + forceNat (p.cc + q.cc) fun nc ↦ + ⟨n0, na, nb, nc⟩ + +def Aff3.sub1 (e : Aff3) : Aff3 := + forceNat (e.c0 - 1) fun n0 ↦ ⟨n0, e.ca, e.cb, e.cc⟩ + +def Aff3.addConst (e : Aff3) (d : ℕ) : Aff3 := + forceNat (e.c0 + d) fun n0 ↦ ⟨n0, e.ca, e.cb, e.cc⟩ + +def Aff3.scale (e : Aff3) (k : ℕ) : Aff3 := + forceNat (k * e.c0) fun n0 ↦ + forceNat (k * e.ca) fun na ↦ + forceNat (k * e.cb) fun nb ↦ + forceNat (k * e.cc) fun nc ↦ + ⟨n0, na, nb, nc⟩ + +def Aff3.leCoeff (p q : Aff3) : Bool := + Nat.ble p.c0 q.c0 && Nat.ble p.ca q.ca && Nat.ble p.cb q.cb && Nat.ble p.cc q.cc + +def Aff3.substZero (e : Aff3) : Var3 → Aff3 + | .va => ⟨e.c0, 0, e.cb, e.cc⟩ + | .vb => ⟨e.c0, e.ca, 0, e.cc⟩ + | .vc => ⟨e.c0, e.ca, e.cb, 0⟩ + +def Aff3.substSucc (e : Aff3) : Var3 → Aff3 + | .va => forceNat (e.c0 + e.ca) fun n0 ↦ ⟨n0, e.ca, e.cb, e.cc⟩ + | .vb => forceNat (e.c0 + e.cb) fun n0 ↦ ⟨n0, e.ca, e.cb, e.cc⟩ + | .vc => forceNat (e.c0 + e.cc) fun n0 ↦ ⟨n0, e.ca, e.cb, e.cc⟩ + +theorem Aff3.const_eval (k u v w : ℕ) : (Aff3.const k).eval u v w = k := by + simp [Aff3.const, forceNat_eq, Aff3.eval] + +theorem Aff3.one_eval (u v w : ℕ) : Aff3.one.eval u v w = 1 := by + simp [Aff3.one, Aff3.eval] + +theorem Aff3.isZero_sound {e : Aff3} (h : e.isZero = true) (u v w : ℕ) : + e.eval u v w = 0 := by + unfold Aff3.isZero at h + simp only [Bool.and_eq_true] at h + have h0 := Nat.eq_of_beq_eq_true h.1.1.1 + have ha := Nat.eq_of_beq_eq_true h.1.1.2 + have hb := Nat.eq_of_beq_eq_true h.1.2 + have hc := Nat.eq_of_beq_eq_true h.2 + simp [Aff3.eval, h0, ha, hb, hc] + +theorem Aff3.add_eval (p q : Aff3) (u v w : ℕ) : + (p.add q).eval u v w = p.eval u v w + q.eval u v w := by + simp only [Aff3.add, forceNat_eq, Aff3.eval, Nat.add_mul] + omega + +theorem Aff3.sub1_eval {e : Aff3} (h : Nat.ble 1 e.c0 = true) (u v w : ℕ) : + e.eval u v w = (e.sub1.eval u v w) + 1 := by + have hc : 1 ≤ e.c0 := Nat.le_of_ble_eq_true h + simp only [Aff3.sub1, forceNat_eq, Aff3.eval] + omega + +theorem Aff3.ge1_eval {e : Aff3} (h : Nat.ble 1 e.c0 = true) (u v w : ℕ) : + 1 ≤ e.eval u v w := by + have hc : 1 ≤ e.c0 := Nat.le_of_ble_eq_true h + unfold Aff3.eval + omega + +theorem Aff3.addConst_eval (e : Aff3) (d u v w : ℕ) : + (e.addConst d).eval u v w = e.eval u v w + d := by + simp only [Aff3.addConst, forceNat_eq, Aff3.eval] + omega + +theorem Aff3.scale_eval (e : Aff3) (k u v w : ℕ) : + (e.scale k).eval u v w = k * e.eval u v w := by + simp only [Aff3.scale, forceNat_eq, Aff3.eval, Nat.mul_add, Nat.mul_assoc] + +theorem Aff3.leCoeff_sound {p q : Aff3} (h : p.leCoeff q = true) (u v w : ℕ) : + p.eval u v w ≤ q.eval u v w := by + unfold Aff3.leCoeff at h + simp only [Bool.and_eq_true, Nat.ble_eq] at h + obtain ⟨⟨⟨h0, ha⟩, hb⟩, hc⟩ := h + have mu := Nat.mul_le_mul_right u ha + have mv := Nat.mul_le_mul_right v hb + have mw := Nat.mul_le_mul_right w hc + unfold Aff3.eval + omega + +theorem Aff3.substZero_va (e : Aff3) (v w : ℕ) : + (e.substZero .va).eval 0 v w = e.eval 0 v w := by + simp [Aff3.substZero, Aff3.eval] + +theorem Aff3.substSucc_va (e : Aff3) (u v w : ℕ) : + (e.substSucc .va).eval u v w = e.eval (u + 1) v w := by + simp only [Aff3.substSucc, forceNat_eq, Aff3.eval, Nat.mul_succ] + omega + +theorem Aff3.substZero_vb (e : Aff3) (u w : ℕ) : + (e.substZero .vb).eval u 0 w = e.eval u 0 w := by + simp [Aff3.substZero, Aff3.eval] + +theorem Aff3.substSucc_vb (e : Aff3) (u v w : ℕ) : + (e.substSucc .vb).eval u v w = e.eval u (v + 1) w := by + simp only [Aff3.substSucc, forceNat_eq, Aff3.eval, Nat.mul_succ] + omega + +theorem Aff3.substZero_vc (e : Aff3) (u v : ℕ) : + (e.substZero .vc).eval u v 0 = e.eval u v 0 := by + simp [Aff3.substZero, Aff3.eval] + +theorem Aff3.substSucc_vc (e : Aff3) (u v w : ℕ) : + (e.substSucc .vc).eval u v w = e.eval u v (w + 1) := by + simp only [Aff3.substSucc, forceNat_eq, Aff3.eval, Nat.mul_succ] + omega + +structure AffIneq where + lhs : Aff3 + rhs : Aff3 + deriving DecidableEq, Inhabited + +def AffIneq.holds (h : AffIneq) (u v w : ℕ) : Prop := + h.rhs.eval u v w ≤ h.lhs.eval u v w + +def HubInv (m a b c : ℕ) : Prop := + m < 7 ∧ + match m with + | 0 => 6 ≤ b + c ∧ 1 ≤ a ∧ 7 * a + 8 ≤ 3 * b + 6 * c + | 1 | 2 => 6 ≤ b + c ∧ 1 ≤ a ∧ 7 * a ≤ 3 * b + 6 * c + | 3 => 6 ≤ b + c ∧ 1 ≤ a ∧ 7 * a + 6 ≤ 3 * b + 6 * c + | _ => 6 ≤ b + c ∧ 7 * a + 18 ≤ 6 * b ∧ 7 * a + 24 ≤ 6 * b + 12 * c + +def modeIneqs (m : ℕ) (a b c : Aff3) : AffIneq × AffIneq × AffIneq := + let bc := b.add c + match m with + | 0 => + (⟨bc, Aff3.const 6⟩, ⟨a, Aff3.const 1⟩, + ⟨(b.scale 3).add (c.scale 6), (a.scale 7).addConst 8⟩) + | 1 | 2 => + (⟨bc, Aff3.const 6⟩, ⟨a, Aff3.const 1⟩, + ⟨(b.scale 3).add (c.scale 6), a.scale 7⟩) + | 3 => + (⟨bc, Aff3.const 6⟩, ⟨a, Aff3.const 1⟩, + ⟨(b.scale 3).add (c.scale 6), (a.scale 7).addConst 6⟩) + | _ => + (⟨bc, Aff3.const 6⟩, ⟨b.scale 6, (a.scale 7).addConst 18⟩, + ⟨(b.scale 6).add (c.scale 12), (a.scale 7).addConst 24⟩) + +theorem modeIneqs_iff {m : ℕ} (hm : m < 7) (a b c : Aff3) (u v w : ℕ) : + (let (h0, h1, h2) := modeIneqs m a b c + h0.holds u v w ∧ h1.holds u v w ∧ h2.holds u v w) ↔ + HubInv m (a.eval u v w) (b.eval u v w) (c.eval u v w) := by + match m with + | 0 | 1 | 2 | 3 | 4 | 5 | 6 => + simp [modeIneqs, HubInv, AffIneq.holds, hm, Aff3.const_eval, Aff3.add_eval, + Aff3.addConst_eval, Aff3.scale_eval] + | _ + 7 => omega + +def selIneq (hs : AffIneq × AffIneq × AffIneq) : ℕ → AffIneq + | 0 => hs.1 + | 1 => hs.2.1 + | _ => hs.2.2 + +theorem selIneq_holds {hs : AffIneq × AffIneq × AffIneq} {u v w : ℕ} + (hh : hs.1.holds u v w ∧ hs.2.1.holds u v w ∧ hs.2.2.holds u v w) (idx : ℕ) : + (selIneq hs idx).holds u v w := by + match idx with + | 0 => exact hh.1 + | 1 => exact hh.2.1 + | _ + 2 => exact hh.2.2 + +def isDeadIneq (h : AffIneq) : Bool := + (h.lhs.addConst 1).leCoeff h.rhs + +theorem isDeadIneq_sound {h : AffIneq} {u v w : ℕ} + (hd : isDeadIneq h = true) (hh : h.holds u v w) : False := by + have hle := Aff3.leCoeff_sound hd u v w + rw [Aff3.addConst_eval] at hle + unfold AffIneq.holds at hh + omega + +structure FWit where + k : ℕ + i1 : ℕ + l1 : ℕ + i2 : ℕ + l2 : ℕ + deriving DecidableEq, Inhabited + +def checkFarkas (hs : AffIneq × AffIneq × AffIneq) (goal : AffIneq) (wit : FWit) : Bool := + Nat.ble 1 wit.k && + let h1 := selIneq hs wit.i1 + let h2 := selIneq hs wit.i2 + let p := ((goal.lhs.scale wit.k).addConst (wit.k - 1)).add + ((h1.rhs.scale wit.l1).add (h2.rhs.scale wit.l2)) + let q := (goal.rhs.scale wit.k).add + ((h1.lhs.scale wit.l1).add (h2.lhs.scale wit.l2)) + q.leCoeff p + +theorem checkFarkas_sound {hs : AffIneq × AffIneq × AffIneq} {goal : AffIneq} {wit : FWit} + {u v w : ℕ} (hc : checkFarkas hs goal wit = true) + (hh : hs.1.holds u v w ∧ hs.2.1.holds u v w ∧ hs.2.2.holds u v w) : + goal.holds u v w := by + unfold checkFarkas at hc + simp only [Bool.and_eq_true] at hc + have hk : 1 ≤ wit.k := Nat.le_of_ble_eq_true hc.1 + have hqp := Aff3.leCoeff_sound hc.2 u v w + simp only [Aff3.add_eval, Aff3.addConst_eval, Aff3.scale_eval] at hqp + have hh1 : (selIneq hs wit.i1).rhs.eval u v w ≤ (selIneq hs wit.i1).lhs.eval u v w := + selIneq_holds hh wit.i1 + have hh2 : (selIneq hs wit.i2).rhs.eval u v w ≤ (selIneq hs wit.i2).lhs.eval u v w := + selIneq_holds hh wit.i2 + have hm1 := Nat.mul_le_mul_left wit.l1 hh1 + have hm2 := Nat.mul_le_mul_left wit.l2 hh2 + unfold AffIneq.holds + rcases Nat.lt_or_ge (goal.lhs.eval u v w) (goal.rhs.eval u v w) with hgt | hle + · have hmul := Nat.mul_le_mul_left wit.k hgt + rw [Nat.mul_succ] at hmul + omega + · exact hle + +/-! ### Symbolic RLE Half-Tape Stacks (`SymRun`, `SymCfg`, `canonRight`) -/ + +structure SymRun where + sym : ℕ + cnt : Aff3 + deriving DecidableEq, Inhabited + +def evalStk (side : Bool) (u v w : ℕ) : List SymRun → ListBlank (Fin 2) + | [] => default + | ⟨sym, cnt⟩ :: rest => + let wd := if side then symWord sym else (symWord sym).reverse + ListBlank.append (wd ^ cnt.eval u v w) (evalStk side u v w rest) + +def pushSym (sym : ℕ) (cnt : Aff3) (stk : List SymRun) : List SymRun := + cnt.strict fun cnt' ↦ + if cnt'.isZero then stk + else + match stk with + | [] => if Nat.beq sym 0 then [] else [⟨sym, cnt'⟩] + | ⟨ts, tc⟩ :: rest => + if Nat.beq ts sym then ⟨ts, tc.add cnt'⟩ :: rest + else ⟨sym, cnt'⟩ :: ⟨ts, tc⟩ :: rest + +theorem evalStk_pushSym (side : Bool) (u v w : ℕ) (sym : ℕ) (cnt : Aff3) (stk : List SymRun) : + evalStk side u v w (pushSym sym cnt stk) = + ListBlank.append + ((if side then symWord sym else (symWord sym).reverse) ^ cnt.eval u v w) + (evalStk side u v w stk) := by + unfold pushSym + rw [Aff3.strict_eq] + cases h0 : cnt.isZero + · simp only [Bool.false_eq_true, ↓reduceIte] + cases stk with + | nil => + cases hs : Nat.beq sym 0 + · rfl + · have hsym : sym = 0 := Nat.eq_of_beq_eq_true hs + subst hsym + cases side <;> simp [evalStk, symWord] + | cons top rest => + rcases top with ⟨ts, tc⟩ + simp only + cases hs : Nat.beq ts sym + · rfl + · have heq : ts = sym := Nat.eq_of_beq_eq_true hs + subst heq + simp only [↓reduceIte, evalStk, Aff3.add_eval] + rw [Nat.add_comm (tc.eval u v w), list_pow_add, ListBlank.append_assoc] + · simp only [↓reduceIte, Aff3.isZero_sound h0 u v w, list_pow_zero, ListBlank.append_nil] + +def pushBits : List (Fin 2) → List SymRun → List SymRun + | [], stk => stk + | b :: bs, stk => pushSym b.val Aff3.one (pushBits bs stk) + +theorem symWord_bit_eq (side : Bool) (b : Fin 2) : + (if side then symWord b.val else (symWord b.val).reverse) = [b] := by + rcases b with ⟨_ | _ | n, hb⟩ + · cases side <;> rfl + · cases side <;> rfl + · omega + +theorem evalStk_pushBits (side : Bool) (u v w : ℕ) (ws : List (Fin 2)) (stk : List SymRun) : + evalStk side u v w (pushBits ws stk) = + ListBlank.append ws (evalStk side u v w stk) := by + induction ws with + | nil => rfl + | cons b bs ih => + simp only [pushBits, evalStk_pushSym, symWord_bit_eq, Aff3.one_eval, list_pow_one, ih] + rfl + +def popBit (b : Fin 2) : List SymRun → Option (List SymRun) + | [] => if b == 0 then some [] else none + | ⟨sym, cnt⟩ :: rest => + if Nat.beq sym b.val && Nat.ble 1 cnt.c0 then + cnt.sub1.strict fun k ↦ + if k.isZero then some rest else some (⟨sym, k⟩ :: rest) + else none + +theorem popBit_sound (side : Bool) (u v w : ℕ) (b : Fin 2) (stk stk' : List SymRun) + (h : popBit b stk = some stk') : + evalStk side u v w stk = ListBlank.cons b (evalStk side u v w stk') := by + cases stk with + | nil => + rcases b with ⟨_ | _ | n, hb⟩ + · change popBit 0 [] = some stk' at h + simp only [popBit, beq_self_eq_true, ↓reduceIte, Option.some.injEq] at h + subst h + exact ListBlank.cons_zero_default.symm + · change popBit 1 [] = some stk' at h + simp [popBit] at h + · omega + | cons top rest => + rcases top with ⟨sym, cnt⟩ + simp only [popBit, Aff3.strict_eq] at h + cases hc : Nat.beq sym b.val && Nat.ble 1 cnt.c0 + · simp [hc] at h + · rw [hc] at h + simp only [↓reduceIte] at h + simp only [Bool.and_eq_true] at hc + have hsym : sym = b.val := Nat.eq_of_beq_eq_true hc.1 + subst hsym + have hcnt := Aff3.sub1_eval hc.2 u v w + cases hz : cnt.sub1.isZero + · rw [hz] at h + simp only [Bool.false_eq_true, ↓reduceIte, Option.some.injEq] at h + subst h + simp only [evalStk, symWord_bit_eq, hcnt] + rw [ListBlank.append_pow_succ] + rfl + · rw [hz] at h + simp only [↓reduceIte, Option.some.injEq] at h + subst h + simp only [evalStk, symWord_bit_eq, hcnt, Aff3.isZero_sound hz u v w, Nat.zero_add, + list_pow_one] + rfl + +def popBits : List (Fin 2) → List SymRun → Option (List SymRun) + | [], stk => some stk + | b :: bs, stk => + match popBit b stk with + | none => none + | some stk' => popBits bs stk' + +theorem popBits_sound (side : Bool) (u v w : ℕ) : + ∀ (ws : List (Fin 2)) (stk stk' : List SymRun), + popBits ws stk = some stk' → + evalStk side u v w stk = ListBlank.append ws (evalStk side u v w stk') + | [], stk, stk', h => by + simp only [popBits, Option.some.injEq] at h + subst h + rfl + | b :: bs, stk, stk', h => by + simp only [popBits] at h + rcases hp : popBit b stk with _ | mid + · simp [hp] at h + · rw [hp] at h + simp only at h + rw [popBit_sound side u v w b stk mid hp, popBits_sound side u v w bs mid stk' h] + rfl + +def substStk (sv : Var3) (isSucc : Bool) : List SymRun → List SymRun + | [] => [] + | ⟨sym, cnt⟩ :: rest => + let nc := if isSucc then cnt.substSucc sv else cnt.substZero sv + pushSym sym nc (substStk sv isSucc rest) + +theorem substStk_zero_va (side : Bool) (v w : ℕ) (stk : List SymRun) : + evalStk side 0 v w (substStk .va false stk) = evalStk side 0 v w stk := by + induction stk with + | nil => rfl + | cons top rest ih => + rcases top with ⟨sym, cnt⟩ + simp [substStk, evalStk_pushSym, Aff3.substZero_va, ih, evalStk] + +theorem substStk_succ_va (side : Bool) (u v w : ℕ) (stk : List SymRun) : + evalStk side u v w (substStk .va true stk) = evalStk side (u + 1) v w stk := by + induction stk with + | nil => rfl + | cons top rest ih => + rcases top with ⟨sym, cnt⟩ + simp [substStk, evalStk_pushSym, Aff3.substSucc_va, ih, evalStk] + +theorem substStk_zero_vb (side : Bool) (u w : ℕ) (stk : List SymRun) : + evalStk side u 0 w (substStk .vb false stk) = evalStk side u 0 w stk := by + induction stk with + | nil => rfl + | cons top rest ih => + rcases top with ⟨sym, cnt⟩ + simp [substStk, evalStk_pushSym, Aff3.substZero_vb, ih, evalStk] + +theorem substStk_succ_vb (side : Bool) (u v w : ℕ) (stk : List SymRun) : + evalStk side u v w (substStk .vb true stk) = evalStk side u (v + 1) w stk := by + induction stk with + | nil => rfl + | cons top rest ih => + rcases top with ⟨sym, cnt⟩ + simp [substStk, evalStk_pushSym, Aff3.substSucc_vb, ih, evalStk] + +theorem substStk_zero_vc (side : Bool) (u v : ℕ) (stk : List SymRun) : + evalStk side u v 0 (substStk .vc false stk) = evalStk side u v 0 stk := by + induction stk with + | nil => rfl + | cons top rest ih => + rcases top with ⟨sym, cnt⟩ + simp [substStk, evalStk_pushSym, Aff3.substZero_vc, ih, evalStk] + +theorem substStk_succ_vc (side : Bool) (u v w : ℕ) (stk : List SymRun) : + evalStk side u v w (substStk .vc true stk) = evalStk side u v (w + 1) stk := by + induction stk with + | nil => rfl + | cons top rest ih => + rcases top with ⟨sym, cnt⟩ + simp [substStk, evalStk_pushSym, Aff3.substSucc_vc, ih, evalStk] + +def nearBit (sym : ℕ) (side : Bool) : Fin 2 := + match sym with + | 0 => 0 + | 1 => 1 + | 2 => 0 + | 3 => if side then 1 else 0 + | _ => if side then 0 else 1 + +theorem symWord_nearBit (side : Bool) (sym : ℕ) : + ∃ rest, (if side then symWord sym else (symWord sym).reverse) = nearBit sym side :: rest := by + match sym with + | 0 | 1 | 2 | 3 => cases side <;> exact ⟨_, rfl⟩ + | _ + 4 => cases side <;> exact ⟨_, rfl⟩ + +def peekBit (side : Bool) : List SymRun → Option (Fin 2) + | [] => some 0 + | ⟨sym, cnt⟩ :: rest => + let b := nearBit sym side + if Nat.ble 1 cnt.c0 then some b + else + match peekBit side rest with + | some b' => if b == b' then some b else none + | none => none + +theorem peekBit_sound (side : Bool) (u v w : ℕ) : + ∀ (stk : List SymRun) (b : Fin 2), + peekBit side stk = some b → + ∃ tail, evalStk side u v w stk = ListBlank.cons b tail + | [], b, h => by + simp only [peekBit, Option.some.injEq] at h + subst h + exact ⟨default, ListBlank.cons_zero_default.symm⟩ + | ⟨sym, cnt⟩ :: rest, b, h => by + simp only [peekBit] at h + obtain ⟨wRest, hw⟩ := symWord_nearBit side sym + cases hc : Nat.ble 1 cnt.c0 + · rw [hc] at h + simp only [Bool.false_eq_true, ↓reduceIte] at h + rcases hp : peekBit side rest with _ | b' + · simp [hp] at h + · rw [hp] at h + simp only at h + cases hbb : nearBit sym side == b' + · simp [hbb] at h + · rw [hbb] at h + simp only [↓reduceIte, Option.some.injEq] at h + subst h + have hbEq : nearBit sym side = b' := eq_of_beq hbb + rcases hcnt : cnt.eval u v w with _ | k + · simp only [evalStk, hcnt, list_pow_zero, ListBlank.append_nil] + rw [hbEq] + exact peekBit_sound side u v w rest b' hp + · simp only [evalStk, hcnt, ListBlank.append_pow_succ] + rw [hw] + exact ⟨_, rfl⟩ + · rw [hc] at h + simp only [↓reduceIte, Option.some.injEq] at h + subst h + have hge := Aff3.ge1_eval hc u v w + obtain ⟨k, hk⟩ : ∃ k, cnt.eval u v w = k + 1 := ⟨cnt.eval u v w - 1, by omega⟩ + simp only [evalStk, hk, ListBlank.append_pow_succ] + rw [hw] + exact ⟨_, rfl⟩ + +/-! ### Canonical Right-Stack Normalization (`canonRight`) -/ + +inductive CTok where + | bit (b : Fin 2) + | slope (sym ca cb cc : ℕ) + deriving DecidableEq, Inhabited + +def evalCTok (u v w : ℕ) : CTok → List (Fin 2) + | .bit b => [b] + | .slope sym ca cb cc => symWord sym ^ (ca * u + cb * v + cc * w) + +def evalCanon (u v w : ℕ) : List CTok → ListBlank (Fin 2) + | [] => default + | t :: ts => ListBlank.append (evalCTok u v w t) (evalCanon u v w ts) + +def consBit (b : Fin 2) : List CTok → List CTok + | [] => if b == 0 then [] else [.bit b] + | t :: ts => .bit b :: t :: ts + +theorem evalCanon_consBit (u v w : ℕ) (b : Fin 2) (ts : List CTok) : + evalCanon u v w (consBit b ts) = ListBlank.cons b (evalCanon u v w ts) := by + cases ts with + | nil => + rcases b with ⟨_ | _ | n, hb⟩ + · exact ListBlank.cons_zero_default.symm + · rfl + · omega + | cons t rest => rfl + +def consBits : List (Fin 2) → List CTok → List CTok + | [], ts => ts + | b :: bs, ts => consBit b (consBits bs ts) + +theorem evalCanon_consBits (u v w : ℕ) (ws : List (Fin 2)) (ts : List CTok) : + evalCanon u v w (consBits ws ts) = ListBlank.append ws (evalCanon u v w ts) := by + induction ws with + | nil => rfl + | cons b bs ih => + simp only [consBits, evalCanon_consBit, ih] + rfl + +def consSlopeAux (sym ca cb cc : ℕ) : List CTok → List CTok + | [] => + if Nat.beq sym 0 then [] else [.slope sym ca cb cc] + | .slope sym' ca' cb' cc' :: tail => + if Nat.beq sym sym' && Nat.ble 2 sym then + forceNat (ca + ca') fun na ↦ + forceNat (cb + cb') fun nb ↦ + forceNat (cc + cc') fun nc ↦ + .slope sym na nb nc :: tail + else + .slope sym ca cb cc :: .slope sym' ca' cb' cc' :: tail + | .bit b0 :: .bit b1 :: .bit b2 :: tail => + if Nat.ble 2 sym && ([b0, b1, b2] == symWord sym) then + .bit b0 :: .bit b1 :: .bit b2 :: consSlopeAux sym ca cb cc tail + else + .slope sym ca cb cc :: .bit b0 :: .bit b1 :: .bit b2 :: tail + | t :: tail => + .slope sym ca cb cc :: t :: tail + +theorem evalCanon_consSlopeAux (u v w sym ca cb cc : ℕ) : + ∀ (ts : List CTok), + evalCanon u v w (consSlopeAux sym ca cb cc ts) = + ListBlank.append (symWord sym ^ (ca * u + cb * v + cc * w)) (evalCanon u v w ts) + | [] => by + unfold consSlopeAux + cases hs : Nat.beq sym 0 + · rfl + · have h0 : sym = 0 := Nat.eq_of_beq_eq_true hs + subst h0 + simp [evalCanon, symWord] + | .slope sym' ca' cb' cc' :: tail => by + unfold consSlopeAux + cases hm : Nat.beq sym sym' && Nat.ble 2 sym + · rfl + · simp only [↓reduceIte, forceNat_eq, evalCanon, evalCTok] + simp only [Bool.and_eq_true] at hm + have heq : sym = sym' := Nat.eq_of_beq_eq_true hm.1 + subst heq + have hlin : (ca + ca') * u + (cb + cb') * v + (cc + cc') * w = + (ca * u + cb * v + cc * w) + (ca' * u + cb' * v + cc' * w) := by + simp only [Nat.add_mul] + omega + rw [hlin, list_pow_add, ListBlank.append_assoc] + | .bit b0 :: [.bit b1] => rfl + | .bit b0 :: [.slope _ _ _ _] => rfl + | .bit b0 :: .slope _ _ _ _ :: _ :: _ => rfl + | [.bit b0] => rfl + | .bit b0 :: .bit b1 :: .slope _ _ _ _ :: _ => rfl + | .bit b0 :: .bit b1 :: .bit b2 :: tail => by + unfold consSlopeAux + cases hm : Nat.ble 2 sym && ([b0, b1, b2] == symWord sym) + · rfl + · simp only [↓reduceIte] + simp only [Bool.and_eq_true] at hm + have hw : [b0, b1, b2] = symWord sym := eq_of_beq hm.2 + change ListBlank.append [b0, b1, b2] (evalCanon u v w (consSlopeAux sym ca cb cc tail)) = + ListBlank.append (symWord sym ^ (ca * u + cb * v + cc * w)) + (ListBlank.append [b0, b1, b2] (evalCanon u v w tail)) + rw [evalCanon_consSlopeAux u v w sym ca cb cc tail, hw] + exact (ListBlank.append_pow_comm (symWord sym) (ca * u + cb * v + cc * w) + (evalCanon u v w tail)).symm + +def consSlope (sym ca cb cc : ℕ) (ts : List CTok) : List CTok := + if Nat.beq ca 0 && Nat.beq cb 0 && Nat.beq cc 0 then ts + else consSlopeAux sym ca cb cc ts + +theorem evalCanon_consSlope (u v w sym ca cb cc : ℕ) (ts : List CTok) : + evalCanon u v w (consSlope sym ca cb cc ts) = + ListBlank.append (symWord sym ^ (ca * u + cb * v + cc * w)) (evalCanon u v w ts) := by + unfold consSlope + cases hz : Nat.beq ca 0 && Nat.beq cb 0 && Nat.beq cc 0 + · exact evalCanon_consSlopeAux u v w sym ca cb cc ts + · simp only [↓reduceIte] + simp only [Bool.and_eq_true] at hz + have ha := Nat.eq_of_beq_eq_true hz.1.1 + have hb := Nat.eq_of_beq_eq_true hz.1.2 + have hc := Nat.eq_of_beq_eq_true hz.2 + simp [ha, hb, hc, list_pow_zero] + +def canonRight : List SymRun → List CTok + | [] => [] + | ⟨sym, ⟨c0, ca, cb, cc⟩⟩ :: rest => + consBits (symWord sym ^ c0) (consSlope sym ca cb cc (canonRight rest)) + +theorem evalCanon_canonRight (u v w : ℕ) (r : List SymRun) : + evalCanon u v w (canonRight r) = evalStk true u v w r := by + induction r with + | nil => rfl + | cons top rest ih => + rcases top with ⟨sym, ⟨c0, ca, cb, cc⟩⟩ + rw [canonRight, evalCanon_consBits, evalCanon_consSlope, ih] + simp only [evalStk, ↓reduceIte, Aff3.eval] + rw [← ListBlank.append_assoc, ← list_pow_add] + have hassoc : c0 + (ca * u + cb * v + cc * w) = c0 + ca * u + cb * v + cc * w := by omega + rw [hassoc] + +/-! ### Hub Configurations (`mkSymCfg`, `evalHub`, `checkHubEq`) and Symbolic Ops -/ + +structure SymCfg where + q : ℕ + dir : Bool + prog : Bool + left : List SymRun + right : List SymRun + deriving DecidableEq, Inhabited + +def evalSymCfg (u v w : ℕ) (c : SymCfg) : Cfg (Fin 2) (Fin 6) := + WordRLE.dirCfg qOf c.q c.dir (evalStk false u v w c.left) (evalStk true u v w c.right) + +def modePref : ℕ → List (Fin 2) + | 0 => [1, 1, 1] + | 1 | 4 => [1, 1, 1, 0, 0, 1, 1] + | 2 | 5 => [1, 1, 1, 0, 1, 0, 1, 1, 1] + | _ => [1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1] + +def modeHasZ (m : ℕ) : Bool := + Nat.ble 4 m + +def sepBits : List (Fin 2) := [1, 1, 1, 0, 0] +def sfxBits : List (Fin 2) := [1, 1] + +def mkSymCfg (m : ℕ) (a b c : Aff3) : SymCfg := + let r0 := pushBits sfxBits [] + let r1 := pushSym 3 c r0 + let r2 := pushBits sepBits r1 + let r3 := pushSym 3 b r2 + let r4 := if modeHasZ m then pushBits [0, 0] r3 else r3 + let r5 := pushSym 2 a r4 + let r6 := pushBits ((1 : Fin 2) :: modePref m) r5 + ⟨5, true, false, [], r6⟩ + +def evalHub (m a b c : ℕ) : Cfg (Fin 2) (Fin 6) := + evalSymCfg 0 0 0 (mkSymCfg m (Aff3.const a) (Aff3.const b) (Aff3.const c)) + +theorem evalSymCfg_mkSymCfg (m : ℕ) (a b c : Aff3) (u v w : ℕ) : + evalSymCfg u v w (mkSymCfg m a b c) = + evalHub m (a.eval u v w) (b.eval u v w) (c.eval u v w) := by + unfold evalHub mkSymCfg evalSymCfg + cases modeHasZ m <;> + simp only [↓reduceIte, Bool.false_eq_true, evalStk_pushBits, evalStk_pushSym, + Aff3.const_eval, evalStk] + +def checkHubEq (g : SymCfg) (dm : ℕ) (da db dc : Aff3) : Bool := + Nat.beq g.q 5 && g.prog && + let target := mkSymCfg dm da db dc + if g.dir then + g.left.isEmpty && (canonRight g.right == canonRight target.right) + else + match popBit 1 g.left with + | some [] => + canonRight (pushSym 1 Aff3.one g.right) == canonRight target.right + | _ => false + +theorem checkHubEq_sound {g : SymCfg} {dm : ℕ} {da db dc : Aff3} + (hc : checkHubEq g dm da db dc = true) (u v w : ℕ) : + g.prog = true ∧ + evalSymCfg u v w g = evalHub dm (da.eval u v w) (db.eval u v w) (dc.eval u v w) := by + unfold checkHubEq at hc + simp only [Bool.and_eq_true] at hc + obtain ⟨⟨hq, hprog⟩, hbody⟩ := hc + have hq5 : g.q = 5 := Nat.eq_of_beq_eq_true hq + refine ⟨hprog, ?_⟩ + rw [← evalSymCfg_mkSymCfg] + cases hd : g.dir + · rw [hd] at hbody + simp only [Bool.false_eq_true, ↓reduceIte] at hbody + rcases hp : popBit 1 g.left with _ | lRem + · simp [hp] at hbody + · rw [hp] at hbody + cases lRem with + | cons _ _ => simp at hbody + | nil => + have hcan : canonRight (pushSym 1 Aff3.one g.right) = + canonRight (mkSymCfg dm da db dc).right := eq_of_beq hbody + have hrEq : evalStk true u v w (pushSym 1 Aff3.one g.right) = + evalStk true u v w (mkSymCfg dm da db dc).right := by + rw [← evalCanon_canonRight, hcan, evalCanon_canonRight] + rw [evalStk_pushSym] at hrEq + simp only [↓reduceIte, symWord, Aff3.one_eval, list_pow_one] at hrEq + have hlEq := popBit_sound false u v w 1 g.left [] hp + simp only [evalSymCfg, hd, hq5, hlEq, evalStk, WordRLE.dirCfg, Bool.false_eq_true, + ↓reduceIte] + rw [Cfg.headLeft_cons] + change Cfg.headRight (qOf 5) default + (ListBlank.append [1] (evalStk true u v w g.right)) = _ + rw [hrEq] + rfl + · rw [hd] at hbody + simp only [↓reduceIte, Bool.and_eq_true, List.isEmpty_iff] at hbody + have hcan : canonRight g.right = canonRight (mkSymCfg dm da db dc).right := + eq_of_beq hbody.2 + have hrEq : evalStk true u v w g.right = + evalStk true u v w (mkSymCfg dm da db dc).right := by + rw [← evalCanon_canonRight, hcan, evalCanon_canonRight] + simp only [evalSymCfg, hd, hq5, hbody.1, evalStk, hrEq] + rfl + +inductive SymOp where + | zip (id : ℕ) + | shiftWaL + | shiftWbR + | shiftWcL + | shiftWaR0 + | splitWaLast + | bounce + | unroll + | fold (side : Bool) (sym k : ℕ) + deriving DecidableEq, Inhabited + +def initKL : ℕ := 19 +def initKR : ℕ := 18 +def initQOut : ℕ := 5 +def initDirOut : Bool := false +def initKLOut : ℕ := 2 +def initLBOut : ℕ := 0x1 +def initKROut : ℕ := 35 +def initRBOut : ℕ := 0x36db6d9d7 + +noncomputable def zipCache : WordRLE.NatTrie ℕ := + .node (some 0x2bf8000704038d0012) (.node none (.node none (.node none (.node none (.node none + (.leaf) (.node (some 0x3b00030300980003) (.leaf) (.leaf))) (.node (some 0xed2b06020008920015) + (.leaf) (.node (some 0x4df50602000895000f) (.leaf) (.leaf)))) (.node (some + 0x1a203020104930011) (.node none (.leaf) (.node (some 0xb02000002130004) (.leaf) (.leaf))) + (.node (some 0x700020200890002) (.leaf) (.node (some 0x4504000004250008) (.leaf) (.leaf))))) + (.node (some 0x200010100980001) (.node none (.node none (.leaf) (.node (some + 0x3703000003120005) (.leaf) (.leaf))) (.node (some 0x1da5607020009910016) (.leaf) (.node (some + 0x15eb00070007820011) (.leaf) (.leaf)))) (.node (some 0x5600040202930005) (.node none (.leaf) + (.node (some 0x2303000003230005) (.leaf) (.leaf))) (.node (some 0x500020200990002) (.leaf) + (.node (some 0x201010002830002) (.leaf) (.leaf)))))) (.node (some 0x1870500050029000b) (.node + none (.node none (.node none (.leaf) (.node (some 0x1000001210001) (.leaf) (.leaf))) (.node + (some 0x5d0004000495000b) (.leaf) (.node (some 0x1be03020005910008) (.leaf) (.leaf)))) (.node + (some 0x100010001810001) (.node none (.leaf) (.node (some 0x2b8b00070007820015) (.leaf) + (.leaf))) (.node (some 0x38b05000005120005) (.leaf) (.node (some 0x1947304050702110013) + (.leaf) (.leaf))))) (.node (some 0x3b03000003520003) (.node none (.node none (.leaf) (.node + (some 0xeab0600000612000a) (.leaf) (.leaf))) (.node (some 0xc704000004220006) (.leaf) (.node + (some 0x6a3a0404080018000d) (.leaf) (.leaf)))) (.node (some 0xc00020002a10003) (.node none + (.leaf) (.node (some 0x1d20b0306020792001e) (.leaf) (.leaf))) (.node (some 0xc00020200aa0002) + (.leaf) (.node (some 0x4704000004250006) (.leaf) (.leaf))))))) (.node (some + 0x2a00030300980003) (.node none (.node none (.node none (.node none (.leaf) (.node (some + 0x1703000003150005) (.leaf) (.leaf))) (.node (some 0x75700060600990006) (.leaf) (.node (some + 0x57576000a080293000b) (.leaf) (.leaf)))) (.node (some 0x102000002150002) (.node none (.leaf) + (.node (some 0xf100040004a50007) (.leaf) (.leaf))) (.node (some 0x2000002230002) (.leaf) + (.node (some 0x57573000a080291000f) (.leaf) (.leaf))))) (.node (some 0x1000100290001) (.node + none (.node none (.leaf) (.node (some 0x2e00030300880003) (.leaf) (.leaf))) (.node (some + 0x7700040400990004) (.leaf) (.node (some 0x3a7695ab0d02000f920020) (.leaf) (.leaf)))) (.node + (some 0x1503000003150007) (.node none (.leaf) (.node (some 0x769590902000b950018) (.leaf) + (.leaf))) (.node (some 0x5300040202910009) (.leaf) (.node (some 0xd02000002530002) (.leaf) + (.leaf)))))) (.node (some 0x2502010003820003) (.node none (.node none (.node none (.leaf) + (.node (some 0x577600080602930009) (.leaf) (.leaf))) (.node (some 0x1a503020005950012) (.leaf) + (.node (some 0x15f600070502830008) (.leaf) (.leaf)))) (.node (some 0x402000200380003) (.node + none (.leaf) (.node (some 0x1f00030300890003) (.leaf) (.leaf))) (.node (some + 0x194760405070213000f) (.leaf) (.node (some 0x602000002310002) (.leaf) (.leaf))))) (.node + (some 0x101000001350001) (.node none (.node none (.leaf) (.node (some 0x15f30007050281000c) + (.leaf) (.leaf))) (.node (some 0x1d278030606039d001b) (.leaf) (.node (some + 0x17d00050500890005) (.leaf) (.leaf)))) (.node (some 0xdb020202029a0008) (.node none (.leaf) + (.node (some 0x2bd7d78000d0a038d0018) (.leaf) (.leaf))) (.node (some 0x1700030003830007) + (.leaf) (.leaf)))))) + +def fuelMode0 : ℕ := 211 +noncomputable def streamMode0 : WordRLE.BTree ℕ := + .node (.node (.node (.node (.node (.node (.leaf + 0x6c0201c01c0c0181c0140ac06cac06c01012806c00c19002020010456090000) (.leaf + 0xf20010400a01201b00d03006070020200c02402c10028040240c0181c0080ac)) (.node (.leaf + 0x3006072290020201102b01b0100700502b01b00f0700e0100d03006072290020) (.leaf + 0xf1201b100d0300607229002020010400a071201b00d0300607229002020120))) (.node (.node (.leaf + 0x20a0060762b01b00f0700e0100d0300607229002020010400a0) (.leaf + 0xf0020200c070000000001000000000100000000010000000000060010000000)) (.node (.leaf + 0x10004a006070160601502b01b01401009030060700202b01b0130300607) (.leaf + 0xf00607000000600100000060010000004001000000000002001000000000000)))) (.node (.node (.node + (.leaf 0xc0201c01c0c0181c0140ac06cac0ac01012806c00c19002020010400a0100d03) (.leaf + 0x3c0181c058180540ac06c050040240c0181c0080ac06)) (.node (.leaf + 0x6001000000600100000040010000000000000010000000020000000010004a) (.leaf + 0xf006070160601502b01b0140100d03006070000))) (.node (.node (.leaf + 0x6001000000000100000040010010000000020000010000000000000010011a) (.leaf 0x0)) (.node (.leaf + 0x0) (.leaf 0x0))))) (.node (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) + (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))) + (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node + (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))))) (.node (.node (.node (.node + (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) + (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))) (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) + (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) + (.leaf 0x0))))) (.node (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) + (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))) + (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node + (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))))) + +def fuelMode1 : ℕ := 6307 +noncomputable def streamMode1 : WordRLE.BTree ℕ := + .node (.node (.node (.node (.node (.node (.node (.node (.leaf + 0x1c0c0181c0140ac06cac06c01012806c00c190020200104560901802b01b0170) (.leaf + 0xf700b0400a01201b01a0701902402c10028040240c0181c0080ac06c0201c0)) (.node (.leaf + 0x1303006072290020201d0700903006070020201c02b01b0040400a01201b01b0) (.leaf + 0xf0060700502b01b00f0700e0100d030060700202b01b0))) (.node (.node (.leaf + 0x1000000000100000040010000000000030010000000000000000000010a) (.leaf + 0x3c8a407c180780900e01009030060700202b01b01303006070020200c070000)) (.node (.leaf + 0x1a070220100d0300607229002020010400a01201b02103006072290020202007) (.leaf + 0xf00d030060722900202001040250400a01201b024060230700b0400a01201b0)))) (.node (.node (.node + (.leaf 0x1b00f0700e010260700502b01b00f0700e0100d0300607229002020010400a01) (.leaf + 0xf0060700502b0)) (.node (.leaf + 0x1000000000100000000010000000000060010000000000000000000012a) (.leaf + 0x3dc0080ac06c0101002804806c0a00900b040270701a0762b01b00f070000))) (.node (.node (.leaf + 0x210300607229002020200722901f06029030060700202b01b00807007030060) (.leaf + 0xf300607229002020010400a01202b100d0300607229002020010400a01201b)) (.node (.leaf + 0x10000000000070010000000000000000000030a0060762b01b00f0700e0100d0) (.leaf + 0xf700202b01b01303006072290020200c0700000000010000000001000000000))))) (.node (.node (.node + (.node (.leaf 0xec0340c0181c0080ac06c04c0c0181c8a4008080300900b0400a01009030060) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181c8a40080800410028048)) (.node (.leaf + 0x1000000000100000000010000000000070010000000000000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006072290020200c070000))) (.node (.node (.leaf + 0x801c8a407c180780900e01009030060700202b01b01303006072290020200c0) (.leaf + 0x3d00280480ec40340c0181c8a4008080041002804806c0840c0181c8a400808)) (.node (.leaf + 0x40c0181c0080ac06c0201c01c0c0181c0140ac32c01012806c00c29002020010) (.leaf + 0x3dc0080ac06c04c0c0181c008080301c02c100a81d8ac06c03c1c0380402)))) (.node (.node (.node + (.leaf 0xb01401009030060700202b01b01303006070020200c0700b0400a01009030060) (.leaf + 0xf006070160601502b01)) (.node (.leaf + 0x1000000000100000000010000000000040000000000090000000000014a) (.leaf + 0xf0060762b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x10000000001000000000100000000000b0010000000000000000000040a) (.leaf + 0x3c0981c0080ac06c0401c0b00900b0402b02b01b0100762b01b00f070000)) (.node (.leaf + 0x80010000000020000000000005a0060700502b01b00f0700e01201b) (.leaf + 0xf2b01b01303006072290020200c0700000000010000008001000000000100)))))) (.node (.node (.node + (.node (.node (.leaf 0x40c0181c0080ac06c04c0c0181c8a4008080300900b0400a0100903006070020) + (.leaf 0x3c8004100280480ac0340c0181c0080ac06c04c0c0181c8a4008080741c02)) (.node (.leaf + 0x10000000000000000000020a0060762b01b00f0700e0100d0300607a290020) (.leaf + 0xf3006072290020200c0700000000010000000001000000000100000000000f))) (.node (.node (.leaf + 0x1b01303006072290020200c0700b0400a071201b1009030060700202b01b0130) (.leaf + 0xf2b01b0130300607a290020200c0700b0400a01201b1009030060700202b0)) (.node (.leaf + 0x2804806c0840c0181e8a4008080801e8a407c180780900e0100903006070020) (.leaf + 0xfb14b00404a01b0030a400808004100280480ac40340c0181e8a40080800410)))) (.node (.node (.node + (.leaf 0xb0402a0762b01b00f0700e01009030060700202b01b00807007030060700502) (.leaf + 0xf70020200c0700b0400a01009030060700202b01b01303006070020200c070)) (.node (.leaf + 0x110000000000004a0060700202b01b02d030060700202b01b013030060) (.leaf + 0xf700e0100d03006070000000001000000000100000000010000000000040000))) (.node (.node (.leaf + 0x100000000010000000000130010000000000000000000030a0060762b01b00f0) (.leaf + 0x3c0981c0b00900b0402b02b01b0100762b01b00f070000000001000000000)) (.node (.leaf + 0x100010000000010000000000005a0060700502b01b00f0700e01201b) (.leaf + 0xf2b01b0130300607a290020200c0700000000010000006001000000000100))))) (.node (.node (.node + (.node (.leaf 0x40c0181c0080ac06c04c0c0181e8a4008080300900b0400a0100903006070020) (.leaf + 0x3c80041002804806c0340c0181c0080ac06c04c0c0181e8a4008080741c02)) (.node (.leaf + 0x10a0060700502b01b00f0700e0100d0300607a290020) (.leaf + 0xf7a290020200c07000000000100000000010000000001000000000017001))) (.node (.node (.leaf + 0x300607a290020200c0700b0400a071201b1009030060700202b01b013030060) (.leaf + 0xf0130300607a290020200c0700b0400a01201b1009030060700202b01b013)) (.node (.leaf + 0x806c0840c0181e8a4008080801e8a407c180780900e01009030060700202b01b) (.leaf + 0xf2b01b00807007030060700502b1bb00404a01b0030a4008080041002804)))) (.node (.node (.node + (.leaf 0x30060700202b01b01303006070020200c0700b0400a01201b100903006070020) (.leaf + 0xf700b0400a01201b009030060700202b01b02e0700502b01b00f0700e010090)) (.node (.leaf + 0xb0210300607002020200701f06029030060700202b01b01303006070020200c0) (.leaf + 0xf0060700502b01b00f0700e0100d0300607002020010400a01201))) (.node (.node (.leaf + 0x1000000000100000000010000000000070000000000150000000000010a) (.leaf + 0x3dc0140ac72c01012806c00c29002020010400a01201b100d03006070000)) (.node (.leaf + 0xc0700b0402a0762b01b00f0700e01009030060700202b01b00807007030060) (.leaf + 0xf400a01201b00d030060700202012030060700202b01b013030060700202))))))) (.node (.node (.node + (.node (.node (.node (.node (.leaf + 0x3006070020201102b01b0100700502b01b00f0700e0100d0300607002020010) (.leaf + 0xf400a01201b100d0300607002020010400a071201b00d030060700202012)) (.node (.leaf + 0x140000000000020a0060762b01b00f0700e0100d0300607002020010) (.leaf + 0xf700e0100d030060700000000010000000001000000000100000000000800))) (.node (.node (.leaf + 0x1000000000100000000001b0010000000000000000000020a0060762b01b00f0) (.leaf + 0xf700502b01b00f0700e01201b0260762b01b00f070000000001000000000)) (.node (.leaf + 0x1000000600100000000010000000000180010000000000000000010005a0060) (.leaf + 0x3c0140ac06cac0ac01012806c00c19002020010400a0100d030060700000060)))) (.node (.node (.node + (.leaf 0x181c008080801c07c180780900e01009030060700202b01b008070070300607) (.leaf + 0x3c02c1002804806c0681c088040340c0181c8a4008080041002804806c0840c)) (.node (.leaf + 0x29002020010400a0100d030060722900202001040250400a01201b0240602307) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d03006072))) (.node (.node (.leaf + 0x1000000000100000040010000000000040010000000000000000000012a) (.leaf + 0x3dc0080ac06c0101002804806c0a00900b040270701a0762b01b00f070000)) (.node (.leaf + 0x1201b0210300607002020200701f06029030060700202b01b00807007030060) (.leaf + 0xf100d0300607229002020010400a01202b100d0300607229002020010400a))))) (.node (.node (.node + (.node (.leaf 0x40010000000000050010000000000000000000030a0060762b01b00f0700e0) (.leaf + 0xf30060700202b01b01303006070020200c07000000000100000000010000)) (.node (.leaf + 0x100280480ec0340c0181c0080ac06c04c0c0181c008080300900b0400a010090) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181c8a400808004))) (.node (.node (.leaf + 0x1000000000100000040010000000000050010000000000000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006070020200c070000)) (.node (.leaf + 0x801c8a407c180780900e01009030060700202b01b01303006072290020200c0) (.leaf + 0x3d00280480ec40340c0181c8a4008080041002804806c0840c0181c8a400808)))) (.node (.node (.node + (.leaf 0x40a0060762b01b00f0700e0100d0300607229002020010) (.leaf + 0xf762b01b00f0700000000010000000001000000000100000000000900100)) (.node (.leaf + 0x140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0402b02b01b0100) (.leaf 0x3c0181c0))) + (.node (.node (.leaf 0x1000000800100000000010000000000060010000000020000000000005a) (.leaf + 0x3c0300900b0400a01009030060700202b01b01303006072290020200c070000)) (.node (.leaf + 0xb01b01303006072290020201d07009030060700202b01b013030060722900202) (.leaf + 0xf2b01b00f0700e0100d0300607229002020010400a01202b00d030060700202)))))) (.node (.node (.node + (.node (.node (.leaf 0x1000000000100000000000d0010000000000000000000020a006076) (.leaf + 0xf71201b1009030060700202b01b01303006072290020200c070000000001)) (.node (.leaf + 0xb0400a01201b1009030060700202b01b01303006072290020200c0700b0400a0) (.leaf + 0xfa407c180780900e01009030060700202b01b01303006072290020200c0700))) (.node (.node (.leaf + 0x80480ac40340c0181e8a4008080041002804806c0840c0181e8a4008080801e8) (.leaf + 0xf700202b01b00807007030060700502b12b00404a01b0030a4008080041002)) (.node (.leaf + 0x202b01b01303006070020200c0700b0402a0762b01b00f0700e01009030060) (.leaf + 0xf02d030060700202b01b01303006070020200c0700b0400a010090300607)))) (.node (.node (.node + (.leaf 0x1000000000100000000000400000000000f0000000000004a0060700202b01b) (.leaf + 0xf0060762b01b00f0700e0100d0300607000000000100000000)) (.node (.leaf + 0x1000000000100000000010000000000110010000000000000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000))) (.node (.node (.leaf + 0x1000000000100000000000e0010000000010000000000005a0060700502b01b) (.leaf + 0xf1009030060700202b01b0130300607a290020200c07000000000100000060)) (.node (.leaf + 0x8a4008080741c0240c0181c0080ac06c04c0c0181e8a4008080300900b0400a0) (.leaf + 0x3c0340c0181e8a4008080041002804806c0340c0181c0080ac06c04c0c0181e))))) (.node (.node (.node + (.node (.leaf 0x10000000000150010000000000000000000010a0060700502b01b00f0700e01) (.leaf + 0xf700202b01b0130300607a290020200c070000000001000000000100000000)) (.node (.leaf + 0x30060700202b01b0130300607a290020200c0700b0400a071201b1009030060) (.leaf + 0xf1009030060700202b01b0130300607a290020200c0700b0400a01201b1009))) (.node (.node (.leaf + 0x1e8a4008080041002804806c0840c0181e8a4008080801e8a407c180780900e0) (.leaf + 0xf007030060700502b1ab00404a01b0030a4008080041002804806c40340c018)) (.node (.leaf + 0x6070020200c0700b0402a0762b01b00f0700e01009030060700202b01b00807) (.leaf + 0xf7002020010400a01201b00d030060700202012030060700202b01b013030)))) (.node (.node (.node + (.leaf 0x70020201203006070020201102b01b0100700502b01b00f0700e0100d030060) (.leaf + 0xf7002020010400a01201b100d0300607002020010400a071201b00d03006)) (.node (.leaf + 0x80000000000120000000000020a0060762b01b00f0700e0100d030060) (.leaf + 0xf762b01b00f0700e0100d03006070000000001000000000100000000010000))) (.node (.node (.leaf + 0x1000000000100000000010000000000190010000000000000000000020a0060) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f0700000000)) (.node (.leaf + 0x6001000000600100000000010000000000160010000000000000000010005a) (.leaf + 0xf003064008080741c0240c0181c0080ac06c03c0900e0100d03006070000))))))) (.node (.node (.node + (.node (.node (.node (.leaf + 0x701f06029030060700202b01b00807007030060700502b01b2b04b00404a01b) (.leaf + 0xf0010400a01202b100d0300607002020010400a01201b021030060700202020)) (.node (.leaf + 0x30010000000000000000000030a0060762b01b00f0700e0100d030060700202) (.leaf + 0xf700202b01b0130300607000000c001000000000100000040010000000000))) (.node (.node (.leaf + 0x10a0060700502b01b00f0700e01201b00d030060700202b01b013030060) (.leaf + 0xf7000000000100000000010000000001001000000006000001000000000000)) (.node (.leaf + 0xc0181c0140ac06cac0ec01012806c00c1900202001040270701a0762b01b00f0) (.leaf + 0xf01303006070020200c02402c10028040240c0181c0080ac06c0201c01c0)))) (.node (.node (.node + (.leaf 0x62b01b00f0700e0100d0300607002020010400a01203b00d030060700202b01b) (.leaf 0xf00607)) + (.node (.leaf 0x8001000000000100000040010000000000030010000000010000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006070020200c070000))) (.node (.node (.leaf + 0x4008080801c07c180780900e01009030060700202b01b01303006070020200c0) (.leaf + 0x3c8004100280480ec40340c0181c8a4008080041002804806c0840c0181c8a)) (.node (.leaf + 0x10000000000000000000040a0060762b01b00f0700e0100d03006072290020) (.leaf + 0xfb01b0100762b01b00f07000000000100000000010000000001000000000007))))) (.node (.node (.node + (.node (.leaf 0x3c0181c0140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0402b02) (.leaf + 0x0)) (.node (.leaf 0x1000000000100000000010000000000040010000000030000000000005a) (.leaf + 0x3c80300900b0400a01009030060700202b01b01303006070020200c070000))) (.node (.node (.leaf + 0x2b01b01303006072290020201d07009030060700202b01b01303006072290020) (.leaf + 0xf62b01b00f0700e0100d0300607229002020010400a01202b00d03006070020)) (.node (.leaf + 0x10000000001000000000100000000000b0010000000000000000000020a00607) (.leaf + 0xf00a071201b1009030060700202b01b01303006072290020200c07000000000)))) (.node (.node (.node + (.leaf 0x700b0400a01201b1009030060700202b01b01303006072290020200c0700b04) (.leaf + 0x3dc8a407c180780900e01009030060700202b01b01303006072290020200c)) (.node (.leaf + 0xa01202b100d0300607a29002020010400a01201b0210300607a29002020200) (.leaf + 0x3dc0080ac06c0201c01c0c0181c0140ac42c01012806c00c290020200104))) (.node (.node (.leaf + 0x202b01b01303006070020200c0700b0402a0762b01b00f0700e01009030060) (.leaf + 0xf02d030060700202b01b01303006070020200c0700b0400a010090300607)) (.node (.leaf + 0x1000000000100000000000400000000000d0000000000004a0060700202b01b) (.leaf + 0xf0060762b01b00f0700e0100d0300607000000000100000000)))))) (.node (.node (.node (.node + (.node (.leaf 0x10000000001000000000100000000000f0010000000000000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000)) (.node (.leaf + 0x1000000000100000000000c0010000000010000000000005a0060700502b01b) (.leaf + 0xf1009030060700202b01b01303006072290020200c07000000000100000060))) (.node (.node (.leaf + 0x8a4008080741c0240c0181c0080ac06c04c0c0181e8a4008080300900b0400a0) (.leaf + 0x3c0340c0181e8a4008080041002804806c0340c0181c0080ac06c04c0c0181e)) (.node (.leaf + 0x10000000000130010000000000000000000010a0060700502b01b00f0700e01) (.leaf + 0xf700202b01b0130300607a290020200c070000000001000000000100000000)))) (.node (.node (.node + (.leaf 0x30060700202b01b0130300607a290020200c0700b0400a071201b1009030060) (.leaf + 0xf1009030060700202b01b0130300607a290020200c0700b0400a01201b1009)) (.node (.leaf + 0x1e8a4008080041002804806c0840c0181e8a4008080801e8a407c180780900e0) (.leaf + 0xf007030060700502b18b00404a01b0030a4008080041002804806c40340c018))) (.node (.node (.leaf + 0x6070020200c0700b0402a0762b01b00f0700e01009030060700202b01b00807) (.leaf + 0xf7002020010400a01201b00d030060700202012030060700202b01b013030)) (.node (.leaf + 0x70020201203006070020201102b01b0100700502b01b00f0700e0100d030060) (.leaf + 0xf7002020010400a01201b100d0300607002020010400a071201b00d03006))))) (.node (.node (.node + (.node (.leaf 0x80000000000100000000000020a0060762b01b00f0700e0100d030060) (.leaf + 0xf762b01b00f0700e0100d03006070000000001000000000100000000010000)) (.node (.leaf + 0x1000000000100000000010000000000170010000000000000000000020a0060) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f0700000000))) (.node (.node (.leaf + 0x6001000000600100000000010000000000140010000000000000000010005a) (.leaf + 0x3dc0140ac06cac12c01012806c00c19002020010400a0100d03006070000)) (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0x3c0840c0181c008080801c07c180780900e01009030060700202b01b0130)))) (.node (.node (.node + (.leaf 0x100d0300607229002020010400a01203b100d0300607002020010400a01201b) (.leaf + 0xf0060762b01b00f0700e)) (.node (.leaf + 0xc001000000000100000040010000000000050010000000000000000000040a) (.leaf + 0x3c0981c0080ac06c0401c0b00900b0402b02b01b0100762b01b00f070000))) (.node (.node (.leaf + 0x20010000000050000000000005a0060700502b01b00f0700e01201b) (.leaf + 0xf700202b01b01303006070020200c0700000000010000000001000000000100)) (.node (.leaf + 0x80741c0240c0181c0080ac06c04c0c0181c008080300900b0400a01009030060) (.leaf + 0x3cc0181c8a400808004100280480ac0340c0181c0080ac06c04c0c0181c0080))))))))) (.node (.node + (.node (.node (.node (.node (.node (.leaf + 0x10000000000090010000000000000000000020a0060762b01b00f0700e0100d0) (.leaf + 0xf700202b01b01303006070020200c0700000000010000000001000000000)) (.node (.leaf + 0x9030060700202b01b01303006070020200c0700b0400a071201b1009030060) (.leaf + 0xf00e01009030060700202b01b01303006072290020200c0700b0400a01201b1))) (.node (.node (.leaf + 0xc0181e8a4008080041002804806c0840c0181c8a4008080801c8a407c1807809) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181e8a400808004100280480ac40340)) (.node (.leaf + 0x10000000001000000000100000000000d0010000000000000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000)))) (.node (.node (.node + (.leaf 0x1000000000100000000000a0010000000010000000000005a0060700502b01b) (.leaf + 0xf1009030060700202b01b01303006072290020200c07000000000100000180)) (.node (.leaf + 0x8a4008080741c0240c0181c0080ac06c04c0c0181c8a4008080300900b0400a0) (.leaf + 0x3c0340c0181e8a4008080041002804806c0340c0181c0080ac06c04c0c0181e))) (.node (.node (.leaf + 0x10000000000110010000000000000000000010a0060700502b01b00f0700e01) (.leaf + 0xf700202b01b01303006072290020200c070000000001000000000100000000)) (.node (.leaf + 0x30060700202b01b0130300607a290020200c0700b0400a071201b1009030060) (.leaf + 0xf1009030060700202b01b0130300607a290020200c0700b0400a01201b1009))))) (.node (.node (.node + (.node (.leaf 0x1e8a4008080041002804806c0840c0181e8a4008080801e8a407c180780900e0) (.leaf + 0xf007030060700502b16b00404a01b0030a4008080041002804806c40340c018)) (.node (.leaf + 0x6070020200c0700b0402a0762b01b00f0700e01009030060700202b01b00807) (.leaf + 0xf7002020010400a01201b00d030060700202012030060700202b01b013030))) (.node (.node (.leaf + 0x70020201203006070020201102b01b0100700502b01b00f0700e0100d030060) (.leaf + 0xf7002020010400a01201b100d0300607002020010400a071201b00d03006)) (.node (.leaf + 0x800000000000e0000000000020a0060762b01b00f0700e0100d030060) (.leaf + 0xf762b01b00f0700e0100d03006070000000001000000000100000000010000)))) (.node (.node (.node + (.leaf 0x1000000000100000000010000000000150010000000000000000000020a0060) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f0700000000)) (.node (.leaf + 0x6001000000600100000000010000000000120010000000000000000010005a) (.leaf + 0x3cac06cac16c01012806c00c19002020010400a01201b100d03006070000))) (.node (.node (.leaf + 0x2b01b0100762b01b00f0700e01009030060700202b01b0080700703006070050) (.leaf + 0x3c0181c0140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0402b0)) (.node (.leaf + 0x1000000000100000000010000000000000010000000070000000000005a) (.leaf + 0x3c80300900b0400a01009030060700202b01b01303006070020200c070000)))))) (.node (.node (.node + (.node (.node (.leaf 0x700202b01b01303006070020201d07009030060700202b01b01303006070020) + (.leaf 0xf0060762b01b00f0700e0100d0300607002020010400a01202b00d03006)) (.node (.leaf + 0x1000000000100000000010000000000070010000000010000000000020a) (.leaf + 0xf700b0400a071201b1009030060700202b01b01303006070020200c070000))) (.node (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b01303006070020200c0) (.leaf + 0x3c0181c8a4008080801c07c180780900e01009030060700202b01b013030060)) (.node (.leaf + 0x607a29002020010400a01202b100d0300607229002020010400a01201b02103) (.leaf + 0xf0060762b01b00f0700e0100d030)))) (.node (.node (.node (.leaf + 0x10000000001000000000100000000000b0010000000000000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000)) (.node (.leaf + 0x100000000010000000000080010000000020000000000005a0060700502b01b) (.leaf + 0xf00a01009030060700202b01b01303006070020200c070000000001000000c0))) (.node (.node (.leaf + 0x181c8a4008080741c0240c0181c0080ac06c04c0c0181c8a4008080300900b04) (.leaf + 0x3c40340c0181e8a4008080041002804806c0340c0181c0080ac06c04c0c0)) (.node (.leaf + 0x100000000000f0010000000000000000000010a0060700502b01b00f0700e0) (.leaf + 0xf700202b01b01303006072290020200c07000000000100000000010000000))))) (.node (.node (.node + (.node (.leaf 0x30060700202b01b01303006072290020200c0700b0400a071201b1009030060) (.leaf + 0xf1009030060700202b01b0130300607a290020200c0700b0400a01201b1009)) (.node (.leaf + 0x1e8a4008080041002804806c0840c0181e8a4008080801e8a407c180780900e0) (.leaf + 0x3dd8ac06c03c1c038040340c0181e8a4008080041002804806c40340c018))) (.node (.node (.leaf + 0x1000000000100000000010000000000130010000000000000000000020a0060) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f0700000000)) (.node (.leaf + 0x6001000000600100000000010000000000100010000000000000000010005a) (.leaf + 0x3c00c19002020010402b02b01b0100762b01b00f0700e0100d03006070000)))) (.node (.node (.node + (.leaf 0x400a01009030060700202b01b00807007030060700502b01b2b06b00404a01b) (.leaf + 0x3cc0181c008080741c0240c0181c0080ac06c04c0c0181c008080300900b)) (.node (.leaf + 0x1b00f0700e0100d0300607002020010400a01202b00d030060700202b01b0130) (.leaf 0xf0060762b0))) + (.node (.node (.leaf 0x1000000000100000000010000000000050010000000030000000000020a) (.leaf + 0xf700b0400a071201b1009030060700202b01b01303006070020200c070000)) (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b01303006070020200c0) (.leaf + 0x3cc0181c008080801c07c180780900e01009030060700202b01b013030060))))))) (.node (.node (.node + (.node (.node (.node (.node (.leaf + 0xd0300607229002020010400a01202b100d0300607002020010400a01201b0210) (.leaf + 0xf0060762b01b00f0700e0100)) (.node (.leaf + 0x1000000000100000000010000000000090010000000000000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000))) (.node (.node (.leaf + 0x100000000010000000000060010000000040000000000005a0060700502b01b) (.leaf + 0xf00a01009030060700202b01b01303006070020200c07000000000100000000)) (.node (.leaf + 0x4c0c0181c008080741c0240c0181c0080ac06c04c0c0181c008080300900b04) (.leaf + 0x3c03c1c038040340c0181c8a4008080041002804806c0340c0181c0080ac06c)))) (.node (.node (.node + (.leaf 0x1000000000100000000000d0010000000000000000000010a0060700502b01b) (.leaf + 0xf201b1009030060700202b01b01303006070020200c07000000000100000000)) (.node (.leaf + 0xb0400a01201b1009030060700202b01b01303006070020200c0700b0400a071) (.leaf + 0x3e8a407c180780900e01009030060700202b01b01303006072290020200c070))) (.node (.node (.leaf + 0xa01201b100d0300607a29002020010400a01201b0210300607a290020202007) (.leaf + 0xf0060762b01b00f0700e0100d0300607a2900202001040)) (.node (.leaf + 0x1000000000100000000010000000000110010000000000000000000020a) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f070000))))) (.node (.node (.node (.node (.leaf + 0x60010000006001000000000100000000000e0010000000000000000010005a) (.leaf + 0x3dc0140ac06cac1ec01012806c00c19002020010400a0100d03006070000)) (.node (.leaf + 0x6070020200c0700b0400a071201b1009030060700202b01b00807007030060) (.leaf + 0xf01303006070020200c0700b0400a01201b1009030060700202b01b01303))) (.node (.node (.leaf + 0x2804806c0840c0181c008080801c07c180780900e01009030060700202b01b) (.leaf + 0x3c03c1c038040340c0181c00808004100280480ac40340c0181c008080041)) (.node (.leaf + 0x100000000010000000000070010000000010000000000030a0060762b01b) (.leaf + 0x3c4806c0981c0b00900b0402b02b01b0100762b01b00f07000000000100000)))) (.node (.node (.node + (.leaf 0x10000000000040010000000060000000000005a0060700502b01b00f0700e0) (.leaf + 0xf30060700202b01b01303006070020200c07000000000100000000010000000)) (.node (.leaf + 0xc008080741c0240c0181c0080ac06c04c0c0181c008080300900b0400a010090) (.leaf + 0x3c40340c0181c008080041002804806c0340c0181c0080ac06c04c0c0181))) (.node (.node (.leaf + 0x100000000000b0010000000010000000000010a0060700502b01b00f0700e0) (.leaf + 0xf30060700202b01b01303006070020200c07000000000100000000010000000)) (.node (.leaf + 0x201b1009030060700202b01b01303006070020200c0700b0400a071201b10090) (.leaf + 0x3d80780900e01009030060700202b01b01303006070020200c0700b0400a01)))))) (.node (.node (.node + (.node (.node (.leaf 0x201b100d0300607a29002020010400a01201b0210300607a29002020200701f0) + (.leaf 0xf0060762b01b00f0700e0100d0300607a29002020010400a01)) (.node (.leaf + 0x10000000001000000000100000000000f0010000000000000000000020a) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f070000))) (.node (.node (.leaf + 0x60010000006001000000000100000000000c0010000000010000000010005a) (.leaf + 0x3cac06cac22c01012806c00c19002020010400a071201b100d03006070000)) (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b0080700703006070050) (.leaf + 0xf402b02b01b0100762b01b00f0700e01009030060700202b01b013030060)))) (.node (.node (.node + (.leaf 0x20000000000001680181c0140ac06c03c1c03804806c0981c0b00900b0) (.leaf + 0x3c0181c008080301c0000000004000000000400000000040000000000080040)) (.node (.leaf + 0xc0080ac06c04c0c0181c008080300900b0400a01009030060700202b01b01303) (.leaf + 0x3d002804806c0340c0181c0080ac06c04c0c0181c008080741c0240c0181))) (.node (.node (.leaf + 0x30000000000010a0060700502b01b00f0700e0100d0300607002020010) (.leaf + 0xf006070020200c0700000000010000000001000000000100000000000900100)) (.node (.leaf + 0xb01b01303006070020200c0700b0400a071201b1009030060700202b01b01303) (.leaf + 0xf700202b01b01303006070020200c0700b0400a01201b1009030060700202))))) (.node (.node (.node + (.node (.leaf 0xc008080041002804806c0840c0181c008080801c07c180780900e01009030060) (.leaf + 0x3dd8ac06c03c1c038040340c0181e8a4008080041002804806c40340c0181)) (.node (.leaf + 0x10000000001000000000100000000000d0010000000000000000000020a0060) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f0700000000))) (.node (.node (.leaf + 0x60010000006001000000000100000000000a0010000000030000000010005a) (.leaf + 0x3cac06cac26c01012806c00c19002020010400a01201b100d03006070000)) (.node (.leaf + 0x2b01b0100762b01b00f0700e01009030060700202b01b0080700703006070050) (.leaf + 0x3c900b0400a01009030060700202b01b01303006070020200c0700b0402b0)))) (.node (.node (.node + (.leaf 0x2b01b01303006070020201d07009030060700202b01b01303006070020200c0) (.leaf + 0xf700502b01b00f0700e0100d0300607002020010400a01201b00d0300607002)) (.node (.leaf + 0x1000000000100000000010000000000070010000000050000000000010a0060) (.leaf + 0xf400a071201b1009030060700202b01b01303006070020200c0700000000))) (.node (.node (.leaf + 0x200c0700b0400a01201b1009030060700202b01b01303006070020200c0700b0) (.leaf + 0x3dc008080801c07c180780900e01009030060700202b01b01303006070020)) (.node (.leaf + 0x300607002020010400a01201b100d0300607002020010400a01201b021030060) (.leaf + 0xf0060762b01b00f0700e0100d0))))))) (.node (.node (.node (.node (.node (.node (.leaf + 0x10000000001000000000100000000000b0010000000010000000000020a) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f070000)) (.node (.leaf + 0x6001000000600100000000010000000000080010000000050000000010005a) (.leaf + 0x3c00c19002020010402b02b01b0100762b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x400a01009030060700202b01b00807007030060700502b01b2b0ab00404a01b) (.leaf + 0xf700b0400a071201b1009030060700202b01b01303006070020200c0700b)) (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b01303006070020200c0) (.leaf + 0x3cc0181c008080801c07c180780900e01009030060700202b01b013030060)))) (.node (.node (.node + (.leaf 0x100d0300607002020010400a01201b100d0300607002020010400a01201b0210) (.leaf + 0xf0060762b01b00f0700e0)) (.node (.leaf + 0x1000000000100000000010000000000090010000000030000000000020a) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f070000))) (.node (.node (.leaf + 0x6001000000600100000000010000000000060010000000070000000010005a) (.leaf + 0x3dc0140ac06cac2ec01012806c00c19002020010400a0100d03006070000)) (.node (.leaf + 0x6070020200c0700b0400a071201b1009030060700202b01b00807007030060) (.leaf + 0xf01303006070020200c0700b0400a01201b1009030060700202b01b01303))))) (.node (.node (.node + (.node (.leaf 0x700502b01b00f0700e01201b0260762b01b00f0700e01009030060700202b01b) (.leaf + 0xf0060)) (.node (.leaf 0x6001000000600100000000010000000000040010000000090000000010005a) + (.leaf 0x3cac06cac32c01012806c00c19002020010400a071201b100d03006070000))) (.node (.node + (.leaf 0x70020200c0700b0400a01201b1009030060700202b01b0080700703006070050) (.leaf + 0xf700e01201b0260762b01b00f0700e01009030060700202b01b013030060)) (.node (.leaf + 0x100000000000200100000000b0000000010015a0060700502b01b00f0) (.leaf + 0x3e806c00c19002020010400a01201b100d03006070000006001000000600100)))) (.node (.node (.node + (.leaf 0xb00f0700e01009030060700202b01b00807007030060700502b01b2b0db00404) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01)) (.node (.leaf + 0x60010000006001000000000100000000000000100000000d0000000010025a) (.leaf + 0xf700502b01b00f0700e01201b0260762b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x10000000001000000000100100000000d0000010000000000000010032a0060) (.leaf 0x60)) (.node + (.leaf 0x0) (.leaf 0x0)))))) (.node (.node (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) + (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) + (.leaf 0x0)))) (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf + 0x0))) (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))))) (.node + (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node + (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))) (.node (.node (.node (.leaf 0x0) + (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node + (.leaf 0x0) (.leaf 0x0))))))))) + +def fuelMode2 : ℕ := 7352 +noncomputable def streamMode2 : WordRLE.BTree ℕ := + .node (.node (.node (.node (.node (.node (.node (.node (.leaf + 0x6c0201c01c0c0181c0140ac06cac06c01012806c00c190020200104560902f0) (.leaf + 0xf30060700202b01b01303006070020200c02402c10028040240c0181c0080ac)) (.node (.leaf + 0x7229002020120300607229002020310700b0400a01201b01a0700502b01b0300) (.leaf + 0xf700502b01b00f0700e0100d0300607229002020010400a01201b00d030060))) (.node (.node (.leaf + 0x10400a071201b00d03006072290020201203006072290020201102b01b0100) (.leaf + 0x3c0140ac2ac01012806c00c29002020010400a01201b100d030060722900202)) (.node (.leaf + 0xc0700b0402a0762b01b00f0700e01009030060700202b01b008070070300607) (.leaf + 0xf400a01201b00d030060700202012030060700202b01b0130300607002020)))) (.node (.node (.node + (.leaf 0x3006070020201102b01b0100700502b01b00f0700e0100d0300607002020010) (.leaf + 0xf400a01201b100d0300607002020010400a071201b00d030060700202012)) (.node (.leaf + 0x20000000000020a0060762b01b00f0700e0100d0300607002020010) (.leaf + 0xf700e0100d030060700000000010000000001000000000100000000000800))) (.node (.node (.leaf + 0x100000000010000000000090010000000000000000000020a0060762b01b00f0) (.leaf + 0xf1009030060700202b01b01303006070020200c070000000001000000000)) (.node (.leaf + 0x80900e01009030060700202b01b01303006072290020200c0700b0400a01201b) (.leaf + 0x3cc0181c8a4008080041002804806c0840c0181c8a4008080801c8a407c1807))))) (.node (.node (.node + (.node (.leaf 0x100d030060722900202001040330700b0400a01201b01a0762b01b0320100d0) (.leaf + 0x3c01012806c00c29002020010400a01201b100d0300607229002020010400a)) (.node (.leaf + 0x100762b01b00f0700e01009030060700202b01b00807007030060700502b0ab) (.leaf + 0xf700202012030060700202b01b01303006070020200c0700b0402b02b01b))) (.node (.node (.leaf + 0x30060700202b01b01303006070020201d07009030060700202b01b013030060) (.leaf + 0xf20010400a01201b0210300607002020200701f06029030060700202b01b013)) (.node (.leaf + 0x30000000000010a0060700502b01b00f0700e0100d03006070020) (.leaf + 0xf00f0700e0100d0300607000000000100000000010000000001000000000009)))) (.node (.node (.node + (.leaf 0xc01c0c0181c0140ac2ec01012806c00c29002020010402b02b01b0100762b01b) (.leaf + 0x3cac06c04c0c0181c008080301c02c10028040240c0181c0080ac06c0201)) (.node (.leaf + 0x30060700202b01b01303006070020200c0700b0400a071201b00903006070020) (.leaf + 0xf01f06029030060700202b01b01303006070020200c0700b0400a01201b0090))) (.node (.node (.leaf + 0x2b01b00f0700e0100d0300607002020010400a01201b02103006070020202007) (.leaf 0xf006070050)) + (.node (.leaf 0x1000000000100000000010000000000080000000000040000000000010a) (.leaf + 0x3cc0181c0140ac32c01012806c00c29002020010400a0100d03006070000)))))) (.node (.node (.node + (.node (.node (.leaf 0x1303006070020200c0700b0400a071201b1009030060700202b01b008070070) + (.leaf 0xf2b01b01303006070020200c0700b0400a01201b1009030060700202b01b)) (.node (.leaf + 0xa01201b009030060700202b01b02e0700502b01b00f0700e0100903006070020) (.leaf + 0xf7002020200701f06029030060700202b01b01303006070020200c0700b0400))) (.node (.node (.leaf + 0xf0060700502b01b00f0700e0100d0300607002020010400a01201b021030060) (.leaf 0x0)) (.node + (.leaf 0x1000000000100000000010000000000090000000000050000000000010a) (.leaf + 0x3dc0140ac36c01012806c00c29002020010400a071201b100d03006070000)))) (.node (.node (.node + (.leaf 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xf70020200c0700b0402a0762b01b00f0700e01009030060700202b01b0130)) (.node (.leaf + 0x7002020010400a01201b00d030060700202012030060700202b01b013030060) (.leaf + 0xf70020201203006070020201102b01b0100700502b01b00f0700e0100d03006))) (.node (.node (.leaf + 0x607002020010400a01201b100d0300607002020010400a071201b00d030060) (.leaf + 0xf0060762b01b00f0700e0100d03)) (.node (.leaf + 0x10000000001000000000100000000000a0000000000040000000000020a) (.leaf + 0x3dc0140ac3ac01012806c00c29002020010400a01201b100d03006070000))))) (.node (.node (.node + (.node (.leaf 0xc0700b0402a0762b01b00f0700e01009030060700202b01b00807007030060) (.leaf + 0xf3006070020200c0700b0400a01009030060700202b01b013030060700202)) (.node (.leaf + 0x400000000000b0000000000004a0060700202b01b02d030060700202b01b0130) (.leaf + 0xf00f0700e0100d030060700000000010000000001000000000100000000000))) (.node (.node (.leaf + 0x1000000000100000000000d0010000000000000000000030a0060762b01b) (.leaf + 0x3cac06c0101002804806c0a00900b040340762b01b00f07000000000100000)) (.node (.leaf + 0x4a0060700202b01b02d030060700202b01b0080700703006070020) (.leaf + 0xf200c0700000000010000010001000000000100000000000600100000000000)))) (.node (.node (.node + (.leaf 0x181c8a4008080300900b0400a01009030060700202b01b01303006072290020) (.leaf + 0x3c806c40340c0181c8a4008080041002804806c0340c0181c0080ac06c04c0c)) (.node (.leaf + 0x20010402b02b01b0100762b01b00f0700e0100d0300607229002020010400a01) (.leaf + 0x3cc0181c0140ac36c01012806c00c29002020010400a0100d03006072290020))) (.node (.node (.leaf + 0x1303006070020200c0700b0400a071201b1009030060700202b01b008070070) (.leaf + 0xf2b01b01303006070020200c0700b0400a01201b1009030060700202b01b)) (.node (.leaf + 0xa01201b009030060700202b01b02e0700502b01b00f0700e0100903006070020) (.leaf + 0xf7002020200701f06029030060700202b01b01303006070020200c0700b0400))))))) (.node (.node + (.node (.node (.node (.node (.node (.leaf + 0xf0060700502b01b00f0700e0100d0300607002020010400a01201b021030060) (.leaf 0x0)) (.node + (.leaf 0x1000000000100000000010000000000090000000000060000000000010a) (.leaf + 0x3dc0140ac3ac01012806c00c29002020010400a071201b100d03006070000))) (.node (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xf70020200c0700b0402a0762b01b00f0700e01009030060700202b01b0130)) (.node (.leaf + 0x7002020010400a01201b00d030060700202012030060700202b01b013030060) (.leaf + 0xf70020201203006070020201102b01b0100700502b01b00f0700e0100d03006)))) (.node (.node (.node + (.leaf 0x607002020010400a01201b100d0300607002020010400a071201b00d030060) (.leaf + 0xf0060762b01b00f0700e0100d03)) (.node (.leaf + 0x10000000001000000000100000000000a0000000000050000000000020a) (.leaf + 0x3dc0140ac3ec01012806c00c29002020010400a01201b100d03006070000))) (.node (.node (.leaf + 0xc0700b0402a0762b01b00f0700e01009030060700202b01b00807007030060) (.leaf + 0xf3006070020200c0700b0400a01009030060700202b01b013030060700202)) (.node (.leaf + 0x400000000000c0000000000004a0060700202b01b02d030060700202b01b0130) (.leaf + 0xf00f0700e0100d030060700000000010000000001000000000100000000000))))) (.node (.node (.node + (.node (.leaf 0x1000000000100000000000e0010000000000000000000030a0060762b01b) (.leaf + 0xf201b1009030060700202b01b01303006072290020200c07000000000100000)) (.node (.leaf + 0x180780900e01009030060700202b01b01303006072290020200c0700b0400a01) (.leaf + 0xf4a01b0030a4008080041002804806c0840c0181c8a4008080801c8a407c))) (.node (.node (.leaf + 0x700b0400a01201b1009030060700202b01b00807007030060700502b0db0040) (.leaf + 0xf0020200c0700b0400a01201b1009030060700202b01b01303006070020200c)) (.node (.leaf + 0x700202b01b0100700502b01b00f0700e01009030060700202b01b0130300607) (.leaf + 0xf2b01b01303006070020200c0700b0400a01201b009030060700202b02b02e)))) (.node (.node (.node + (.leaf 0x300607002020010400a01201b0210300607002020200701f0602903006070020) (.leaf + 0xf0060700502b01b00f0700e0100d0)) (.node (.leaf + 0x1000000000100000000010000000000090000000000070000000000010a) (.leaf + 0x3dc0140ac3ac01012806c00c29002020010400a01201b100d03006070000))) (.node (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xf700b0402b02b01b0100762b01b00f0700e01009030060700202b01b0130)) (.node (.leaf + 0x700202b01b013030060700202012030060700202b01b01303006070020200c0) (.leaf + 0xf30060700202b01b013030060700202b01b01303006070020201d0700903006)))))) (.node (.node (.node + (.node (.node (.leaf 0x700e0100d0300607002020010400a01201b0210300607002020200701f060290) + (.leaf 0xf0060700502b01b00f0)) (.node (.leaf + 0x10000000001000000000100000000000b0000000000060000000000010a) (.leaf + 0x3dc0140ac3ec01012806c00c29002020010400a01201b100d03006070000))) (.node (.node (.leaf + 0x402b02b01b0100762b01b00f0700e01009030060700202b01b00807007030060) (.leaf + 0xf200c0700b0400a01009030060700202b01b01303006070020200c0700b0)) (.node (.leaf + 0x3006070020200c0700b0400a071201b009030060700202b01b01303006070020) (.leaf + 0xf2b01b01303006070020200c0700b0400a01201b009030060700202b01b0130)))) (.node (.node (.node + (.leaf 0x300607002020010400a01201b0210300607002020200701f0602903006070020) (.leaf + 0xf0060700502b01b00f0700e0100d0)) (.node (.leaf + 0x10000000001000000000100000000000a0000000000070000000000010a) (.leaf + 0x3c00c29002020010402b02b01b0100762b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x700b0400a01009030060700202b01b00807007030060700502b10b00404a01b) (.leaf + 0xf200c0700b0400a071201b1009030060700202b01b01303006070020200c)) (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b01303006070020) (.leaf + 0xf30060700202b01b02e0700502b01b00f0700e01009030060700202b01b0130))))) (.node (.node (.node + (.node (.leaf 0x701f06029030060700202b01b01303006070020200c0700b0400a01201b0090) (.leaf + 0xf2b01b00f0700e0100d0300607002020010400a01201b021030060700202020)) (.node (.leaf + 0x1000000000100000000000b0000000000080000000000010a006070050) (.leaf + 0x3c0140ac46c01012806c00c29002020010400a0100d03006070000000001000))) (.node (.node (.leaf + 0x6070020200c0700b0400a071201b1009030060700202b01b008070070300607) (.leaf + 0xf01303006070020200c0700b0400a01201b1009030060700202b01b013030)) (.node (.leaf + 0x1303006070020200c0700b0402a0762b01b00f0700e01009030060700202b01b) (.leaf + 0xf300607002020010400a01201b00d030060700202012030060700202b01b0)))) (.node (.node (.node + (.leaf 0x3006070020201203006070020201102b01b0100700502b01b00f0700e0100d0) (.leaf + 0xf300607002020010400a01201b100d0300607002020010400a071201b00d)) (.node (.leaf + 0x100000000000c0000000000070000000000020a0060762b01b00f0700e0100d0) (.leaf + 0x3e9002020010400a071201b100d030060700000000010000000001000000000))) (.node (.node (.leaf + 0xa01201b1009030060700202b01b00807007030060700502b12b00404a01b0030) (.leaf + 0xf62b01b00f0700e01009030060700202b01b01303006070020200c0700b0400)) (.node (.leaf + 0xc0700b0400a01009030060700202b01b01303006070020200c0700b0402a07) (.leaf + 0xf0060700202b01b02d030060700202b01b013030060700202))))))) (.node (.node (.node (.node + (.node (.node (.leaf 0x10000000001000000000100000000000600000000000e0000000000004a) (.leaf + 0x3dc0140ac4ec01012806c00c29002020010400a01201b100d03006070000)) (.node (.leaf + 0xc0700b0402a0762b01b00f0700e01009030060700202b01b00807007030060) (.leaf + 0xf3006070020200c0700b0400a01009030060700202b01b013030060700202))) (.node (.node (.leaf + 0x100000000000014a006070160601502b01b01401009030060700202b01b0130) (.leaf + 0xf100d0300607000000000100000000010000000001000000000004000000000)) (.node (.leaf + 0x10000000000120010000000000000000000040a0060762b01b00f0700e0) (.leaf + 0xf0060700202b01b0350762b01b00f07000000000100000000010000)))) (.node (.node (.node (.leaf + 0x60010000006001000000000100000000000a0010000000000000000010006a) (.leaf + 0x3dc0140ac06cac0ac01012806c00c19002020010400a0100d03006070000)) (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0x3c0840c0181c8a4008080801c07c180780900e01009030060700202b01b0130))) (.node (.node (.leaf + 0x700b0400a01201b01a0762b01b0320100d0300607229002020010400a01201b) (.leaf + 0xf1201b100d0300607229002020010400a0100d03006072290020200104033)) (.node (.leaf + 0x20010402b02b01b0100762b01b00f0700e0100d0300607229002020010400a0) (.leaf + 0x3c40240c0181c0080ac06c0201c01c0c0181c0140ac26c01012806c00c29002))))) (.node (.node (.node + (.node (.leaf 0x700b0400a071201b009030060700202b01b01303006070020200c0700b0400a0) (.leaf + 0xf0020200c0700b0400a01201b009030060700202b01b01303006070020200c0)) (.node (.leaf + 0x400a01201b0210300607002020200701f06029030060700202b01b0130300607) (.leaf + 0xf0060700502b01b00f0700e0100d0300607002020010))) (.node (.node (.leaf + 0x1000000000100000000010000000000080000000000020000000000010a) (.leaf + 0x3cc0181c0140ac2ac01012806c00c29002020010400a0100d03006070000)) (.node (.leaf + 0x1303006070020200c0700b0400a071201b1009030060700202b01b008070070) (.leaf + 0xf2b01b01303006070020200c0700b0400a01201b1009030060700202b01b)))) (.node (.node (.node + (.leaf 0xa01201b009030060700202b01b02e0700502b01b00f0700e0100903006070020) (.leaf + 0xf7002020200701f06029030060700202b01b01303006070020200c0700b0400)) (.node (.leaf + 0xf0060700502b01b00f0700e0100d0300607002020010400a01201b021030060) (.leaf 0x0))) (.node + (.node (.leaf 0x1000000000100000000010000000000090000000000030000000000010a) (.leaf + 0x3dc0140ac2ec01012806c00c29002020010400a071201b100d03006070000)) (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xf70020200c0700b0402a0762b01b00f0700e01009030060700202b01b0130)))))) (.node (.node (.node + (.node (.node (.leaf 0x7002020010400a01201b00d030060700202012030060700202b01b013030060) + (.leaf 0xf70020201203006070020201102b01b0100700502b01b00f0700e0100d03006)) (.node (.leaf + 0x607002020010400a01201b100d0300607002020010400a071201b00d030060) (.leaf + 0xf0060762b01b00f0700e0100d03))) (.node (.node (.leaf + 0x10000000001000000000100000000000a0000000000020000000000020a) (.leaf + 0x3dc0140ac32c01012806c00c29002020010400a01201b100d03006070000)) (.node (.leaf + 0xc0700b0402a0762b01b00f0700e01009030060700202b01b00807007030060) (.leaf + 0xf3006070020200c0700b0400a01009030060700202b01b013030060700202)))) (.node (.node (.node + (.leaf 0x40000000000090000000000004a0060700202b01b02d030060700202b01b0130) (.leaf + 0xf00f0700e0100d030060700000000010000000001000000000100000000000)) (.node (.leaf + 0x1000000000100000000000b0010000000000000000000030a0060762b01b) (.leaf + 0x3cac06c0101002804806c0a00900b040340762b01b00f07000000000100000))) (.node (.node (.leaf + 0x4a0060700202b01b02d030060700202b01b0080700703006070020) (.leaf + 0xf200c070000000001000000c001000000400100000000000400100000000100)) (.node (.leaf + 0xc0c0181c8a4008080300900b0400a01009030060700202b01b01303006070020) (.leaf + 0x3c4806c40340c0181c8a4008080041002804806c0340c0181c0080ac06c04))))) (.node (.node (.node + (.node (.leaf 0x20010402b02b01b0100762b01b00f0700e0100d0300607229002020010400a0) (.leaf + 0xf20010400a071201b100d0300607229002020010400a0100d0300607229002)) (.node (.leaf + 0x6c40240c0181c0080ac06c0201c01c0c0181c0140ac32c01012806c00c290020) (.leaf + 0x3c03c1c038040240c0181c0080ac06c04c0c0181c008080301c02c100280480))) (.node (.node (.leaf + 0x60700202012030060700202b01b01303006070020200c0700b0402a0762b01b) (.leaf + 0xf0100700502b01b00f0700e0100d0300607002020010400a01201b00d030)) (.node (.leaf + 0x607002020010400a071201b00d03006070020201203006070020201102b01b) (.leaf + 0xf0060762b01b00f0700e0100d0300607002020010400a01201b100d03)))) (.node (.node (.node (.leaf + 0x10000000001000000000100000000000a0000000000030000000000020a) (.leaf + 0x3dc0140ac36c01012806c00c29002020010400a01201b100d03006070000)) (.node (.leaf + 0xc0700b0402a0762b01b00f0700e01009030060700202b01b00807007030060) (.leaf + 0xf3006070020200c0700b0400a01009030060700202b01b013030060700202))) (.node (.node (.leaf + 0x400000000000a0000000000004a0060700202b01b02d030060700202b01b0130) (.leaf + 0xf00f0700e0100d030060700000000010000000001000000000100000000000)) (.node (.leaf + 0x1000000000100000000000c0010000000000000000000030a0060762b01b) (.leaf + 0xf201b1009030060700202b01b01303006072290020200c07000000000100000))))))))) (.node (.node + (.node (.node (.node (.node (.node (.leaf + 0x180780900e01009030060700202b01b01303006072290020200c0700b0400a01) (.leaf + 0x3c0340c0181c8a4008080041002804806c0840c0181c8a4008080801c8a407c)) (.node (.leaf + 0xac06c0201c01c0c0181c0140ac32c01012806c00c29002020010400a01201b1) (.leaf + 0x3dc0080ac06c04c0c0181c008080301c02c1002804806c40240c0181c008))) (.node (.node (.leaf + 0x1303006070020200c0700b0402b02b01b0100762b01b00f0700e01009030060) (.leaf + 0xf201d07009030060700202b01b013030060700202012030060700202b01b)) (.node (.leaf + 0x20200701f06029030060700202b01b013030060700202b01b01303006070020) (.leaf + 0xf700502b01b00f0700e0100d0300607002020010400a01201b0210300607002)))) (.node (.node (.node + (.leaf 0x10000000001000000000100000000000b0000000000040000000000010a0060) (.leaf + 0x3c0140ac36c01012806c00c29002020010400a01201b100d030060700000000)) (.node (.leaf + 0x2b02b01b0100762b01b00f0700e01009030060700202b01b008070070300607) (.leaf + 0xf200c0700b0400a01009030060700202b01b01303006070020200c0700b04))) (.node (.node (.leaf + 0x3006070020200c0700b0400a071201b009030060700202b01b01303006070020) (.leaf + 0xf2b01b01303006070020200c0700b0400a01201b009030060700202b01b0130)) (.node (.leaf + 0x300607002020010400a01201b0210300607002020200701f0602903006070020) (.leaf + 0xf0060700502b01b00f0700e0100d0))))) (.node (.node (.node (.node (.leaf + 0x10000000001000000000100000000000a0000000000050000000000010a) (.leaf + 0x3c00c29002020010402b02b01b0100762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x700b0400a01009030060700202b01b00807007030060700502b0eb00404a01b) (.leaf + 0xf200c0700b0400a071201b1009030060700202b01b01303006070020200c))) (.node (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b01303006070020) (.leaf + 0xf30060700202b01b02e0700502b01b00f0700e01009030060700202b01b0130)) (.node (.leaf + 0x701f06029030060700202b01b01303006070020200c0700b0400a01201b0090) (.leaf + 0xf2b01b00f0700e0100d0300607002020010400a01201b021030060700202020)))) (.node (.node (.node + (.leaf 0x1000000000100000000000b0000000000060000000000010a006070050) (.leaf + 0x3c0140ac3ec01012806c00c29002020010400a0100d03006070000000001000)) (.node (.leaf + 0x6070020200c0700b0400a071201b1009030060700202b01b008070070300607) (.leaf + 0xf01303006070020200c0700b0400a01201b1009030060700202b01b013030))) (.node (.node (.leaf + 0x1303006070020200c0700b0402a0762b01b00f0700e01009030060700202b01b) (.leaf + 0xf300607002020010400a01201b00d030060700202012030060700202b01b0)) (.node (.leaf + 0x3006070020201203006070020201102b01b0100700502b01b00f0700e0100d0) (.leaf + 0xf300607002020010400a01201b100d0300607002020010400a071201b00d)))))) (.node (.node (.node + (.node (.node (.leaf 0x100000000000c0000000000050000000000020a0060762b01b00f0700e0100d0) + (.leaf 0x3e9002020010400a071201b100d030060700000000010000000001000000000)) (.node (.leaf + 0xa01201b1009030060700202b01b00807007030060700502b10b00404a01b0030) (.leaf + 0xf62b01b00f0700e01009030060700202b01b01303006070020200c0700b0400))) (.node (.node (.leaf + 0xc0700b0400a01009030060700202b01b01303006070020200c0700b0402a07) (.leaf + 0xf0060700202b01b02d030060700202b01b013030060700202)) (.node (.leaf + 0x10000000001000000000100000000000600000000000c0000000000004a) (.leaf + 0x3dc0140ac46c01012806c00c29002020010400a01201b100d03006070000)))) (.node (.node (.node + (.leaf 0xc0700b0402a0762b01b00f0700e01009030060700202b01b00807007030060) (.leaf + 0xf3006070020200c0700b0400a01009030060700202b01b013030060700202)) (.node (.leaf + 0xe0000000000014a006070160601502b01b01401009030060700202b01b0130) (.leaf + 0xf100d0300607000000000100000000010000000001000000000004000000000))) (.node (.node (.leaf + 0x10000000000100010000000000000000000040a0060762b01b00f0700e0) (.leaf + 0xf0060700202b01b0350762b01b00f07000000000100000000010000)) (.node (.leaf + 0x6001000000600100000000010000000000080010000000000000000010006a) (.leaf + 0x3cac06cac0ec01012806c00c19002020010400a01201b100d03006070000))))) (.node (.node (.node + (.node (.leaf 0xb040340762b01b00f0700e01009030060700202b01b0080700703006070050) (.leaf + 0x3cc0181c0080ac06c0201c01c0c0181c0080ac06c0101002804806c0a009)) (.node (.leaf + 0x40010000000000020010000000030000000000004a0060700202b01b02d0) (.leaf + 0xf1009030060700202b01b01303006070020200c070000000001000000000100))) (.node (.node (.leaf + 0x80041002804806c0340c0181c0080ac06c04c0c0181c008080300900b0400a0) (.leaf + 0x3cac06c03c1c038040340c0181c8a4008080041002804806c40340c0181c008)) (.node (.leaf + 0xd0300607229002020010400a0100d0300607229002020010402b02b01b010076) (.leaf + 0x3c00c29002020010400a01201b100d0300607229002020010400a071201b100)))) (.node (.node (.node + (.leaf 0x1b00f0700e01009030060700202b01b00807007030060700502b0bb00404a01b) (.leaf + 0xf400a01009030060700202b01b01303006070020200c0700b0402a0762b0)) (.node (.leaf + 0x4a0060700202b01b02d030060700202b01b01303006070020200c0700b0) (.leaf + 0xf70000000001000000000100000000010000000000040000000000080000000))) (.node (.node (.leaf + 0xa0010000000000000000000030a0060762b01b00f0700e0100d030060) (.leaf + 0xf2b01b01303006070020200c070000000001000000000100000000010000)) (.node (.leaf + 0x30060700202b01b01303006070020200c0700b0400a01201b100903006070020) (.leaf + 0x3c80041002804806c0840c0181c8a4008080801c8a407c180780900e010090))))))) (.node (.node (.node + (.node (.node (.node (.node (.leaf + 0x10400a01201b100d0300607229002020010400a01201b100d03006072290020) (.leaf + 0x3cc0181c0080ac06c0201c01c0c0181c0140ac2ec01012806c00c29002020)) (.node (.leaf + 0x2b01b01303006070020200c0700b0402b02b01b0100762b01b00f0700e010090) (.leaf + 0xf30060700202b01b01303006070020200c0700b0400a0100903006070020))) (.node (.node (.leaf + 0x1201b009030060700202b01b01303006070020200c0700b0400a071201b0090) (.leaf + 0xf002020200701f06029030060700202b01b01303006070020200c0700b0400a)) (.node (.leaf + 0xf0060700502b01b00f0700e0100d0300607002020010400a01201b0210300607) (.leaf 0x0)))) (.node + (.node (.node (.leaf 0x10000000001000000000100000000000a0000000000030000000000010a) (.leaf + 0x3c00c29002020010402b02b01b0100762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x700b0400a01009030060700202b01b00807007030060700502b0cb00404a01b) (.leaf + 0xf200c0700b0400a071201b1009030060700202b01b01303006070020200c))) (.node (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b01303006070020) (.leaf + 0xf30060700202b01b02e0700502b01b00f0700e01009030060700202b01b0130)) (.node (.leaf + 0x701f06029030060700202b01b01303006070020200c0700b0400a01201b0090) (.leaf + 0xf2b01b00f0700e0100d0300607002020010400a01201b021030060700202020))))) (.node (.node (.node + (.node (.leaf 0x1000000000100000000000b0000000000040000000000010a006070050) (.leaf + 0x3c0140ac36c01012806c00c29002020010400a0100d03006070000000001000)) (.node (.leaf + 0x6070020200c0700b0400a071201b1009030060700202b01b008070070300607) (.leaf + 0xf01303006070020200c0700b0400a01201b1009030060700202b01b013030))) (.node (.node (.leaf + 0x1303006070020200c0700b0402a0762b01b00f0700e01009030060700202b01b) (.leaf + 0xf300607002020010400a01201b00d030060700202012030060700202b01b0)) (.node (.leaf + 0x3006070020201203006070020201102b01b0100700502b01b00f0700e0100d0) (.leaf + 0xf300607002020010400a01201b100d0300607002020010400a071201b00d)))) (.node (.node (.node + (.leaf 0x100000000000c0000000000030000000000020a0060762b01b00f0700e0100d0) (.leaf + 0x3e9002020010400a071201b100d030060700000000010000000001000000000)) (.node (.leaf + 0xa01201b1009030060700202b01b00807007030060700502b0eb00404a01b0030) (.leaf + 0xf62b01b00f0700e01009030060700202b01b01303006070020200c0700b0400))) (.node (.node (.leaf + 0xc0700b0400a01009030060700202b01b01303006070020200c0700b0402a07) (.leaf + 0xf0060700202b01b02d030060700202b01b013030060700202)) (.node (.leaf + 0x10000000001000000000100000000000600000000000a0000000000004a) (.leaf + 0x3dc0140ac3ec01012806c00c29002020010400a01201b100d03006070000)))))) (.node (.node (.node + (.node (.node (.leaf 0xc0700b0402a0762b01b00f0700e01009030060700202b01b00807007030060) + (.leaf 0xf3006070020200c0700b0400a01009030060700202b01b013030060700202)) (.node (.leaf + 0xc0000000000014a006070160601502b01b01401009030060700202b01b0130) (.leaf + 0xf100d0300607000000000100000000010000000001000000000004000000000))) (.node (.node (.leaf + 0x100000000000e0010000000000000000000040a0060762b01b00f0700e0) (.leaf + 0xf0060700202b01b0350762b01b00f07000000000100000000010000)) (.node (.leaf + 0x6001000000600100000000010000000000060010000000000000000010006a) (.leaf + 0x3c01012806c00c1900202001040340762b01b00f0700e0100d03006070000)))) (.node (.node (.node + (.leaf 0x80300900b0400a01009030060700202b01b00807007030060700502b01b2b04b) (.leaf + 0x3cc0181c008080041002804806c0340c0181c0080ac06c04c0c0181c0080)) (.node (.leaf + 0x2b02b01b0100762b01b00f0700e0100d0300607002020010400a01201b100d0) (.leaf + 0xf400a071201b100d0300607229002020010400a0100d03006070020200104))) (.node (.node (.leaf + 0xf0700e0100d0300607229002020010400a01201b100d0300607229002020010) (.leaf 0xf0060762b01b0)) + (.node (.leaf 0x1000000000100000000010000000000080010000000000000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006070020200c070000))))) (.node (.node (.node + (.node (.leaf 0xc008080801c07c180780900e01009030060700202b01b01303006070020200c0) (.leaf + 0x3c008080041002804806c40340c0181c8a4008080041002804806c0840c0181)) (.node (.leaf + 0x762b01b00f0700e0100d0300607229002020010400a01201b100d0300607229) (.leaf + 0x3c0201c01c0c0181c0140ac2ac01012806c00c29002020010402b02b01b010))) (.node (.node (.leaf + 0x30060700202b01b01303006070020200c0700b0400a01009030060700202b01b) (.leaf + 0xf1009030060700202b01b01303006070020200c0700b0400a071201b10090)) (.node (.leaf + 0xb00f0700e01009030060700202b01b01303006070020200c0700b0400a01201b) (.leaf + 0xf3006070020200c0700b0400a01201b009030060700202b01b02e0700502b01)))) (.node (.node (.node + (.leaf 0x20010400a01201b0210300607002020200701f06029030060700202b01b0130) (.leaf + 0xf0060700502b01b00f0700e0100d0300607002)) (.node (.leaf + 0x10000000001000000000100000000000b0000000000020000000000010a) (.leaf + 0x3cc0181c0140ac2ec01012806c00c29002020010400a0100d03006070000))) (.node (.node (.leaf + 0x1303006070020200c0700b0400a071201b1009030060700202b01b008070070) (.leaf + 0xf2b01b01303006070020200c0700b0400a01201b1009030060700202b01b)) (.node (.leaf + 0xb01b01303006070020200c0700b0402a0762b01b00f0700e0100903006070020) (.leaf + 0xf100d0300607002020010400a01201b00d030060700202012030060700202))))))) (.node (.node (.node + (.node (.node (.node (.leaf + 0x1b00d03006070020201203006070020201102b01b0100700502b01b00f0700e0) (.leaf + 0xf100d0300607002020010400a01201b100d0300607002020010400a07120)) (.node (.leaf + 0x100000000000c0000000000010000000000020a0060762b01b00f0700e0) (.leaf + 0x3c00c29002020010400a071201b100d0300607000000000100000000010000))) (.node (.node (.leaf + 0x400a01201b1009030060700202b01b00807007030060700502b0cb00404a01b) (.leaf + 0xf762b01b00f0700e01009030060700202b01b01303006070020200c0700b)) (.node (.leaf + 0x200c0700b0400a01009030060700202b01b01303006070020200c0700b0402a0) (.leaf + 0xf0060700202b01b02d030060700202b01b01303006070020)))) (.node (.node (.node (.leaf + 0x1000000000100000000010000000000060000000000080000000000004a) (.leaf + 0x3dc0140ac36c01012806c00c29002020010400a01201b100d03006070000)) (.node (.leaf + 0xc0700b0402a0762b01b00f0700e01009030060700202b01b00807007030060) (.leaf + 0xf3006070020200c0700b0400a01009030060700202b01b013030060700202))) (.node (.node (.leaf + 0xa0000000000014a006070160601502b01b01401009030060700202b01b0130) (.leaf + 0xf100d0300607000000000100000000010000000001000000000004000000000)) (.node (.leaf + 0x100000000000c0010000000000000000000040a0060762b01b00f0700e0) (.leaf + 0xf0060700202b01b0350762b01b00f07000000000100000000010000))))) (.node (.node (.node (.node + (.leaf 0x6001000000600100000000010000000000040010000000020000000010006a) (.leaf + 0x3dc0140ac06cac16c01012806c00c19002020010400a0100d03006070000)) (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0x3c0840c0181c008080801c07c180780900e01009030060700202b01b0130))) (.node (.node (.leaf + 0x201b100d0300607002020010400a01201b100d0300607002020010400a01201b) (.leaf + 0xf402b02b01b0100762b01b00f0700e0100d0300607229002020010400a01)) (.node (.leaf + 0x181c0140ac26c01012806c00c29002020010400a0100d0300607229002020010) (.leaf + 0x3c0181c008080301c02c100281c4806c40240c0181c0080ac06c0201c01c0c0)))) (.node (.node (.node + (.leaf 0x2b01b01303006070020200c0700b0400a01201b1009030060700202b01b01303) (.leaf + 0xf01303006070020200c0700b0402a0762b01b00f0700e0100903006070020)) (.node (.leaf + 0x100d0300607002020010400a01201b00d030060700202012030060700202b01b) (.leaf + 0xf00d03006070020201203006070020201102b01b0100700502b01b00f0700e0))) (.node (.node (.leaf + 0x700502b0db0040400a01201b0360400a01201b102607002020010400a071201b) (.leaf + 0xf700b0402a0762b01b00f0700e01009030060700202b01b00807007030060)) (.node (.leaf + 0x400a01201b00d030060700202012030060700202b01b01303006070020200c0) (.leaf + 0xf3006070020201102b01b0100700502b01b00f0700e0100d030060700202001)))))) (.node (.node (.node + (.node (.node (.leaf 0x10400a01201b100d0300607002020010400a071201b00d0300607002020120) + (.leaf 0xf0060762b01b00f0700e0100d030060700202)) (.node (.leaf + 0x1000000000100000000010000000000080000000000050000000000020a) (.leaf + 0x3dc0140ac2ac01012806c00c29002020010400a071201b100d03006070000))) (.node (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xf70020200c0700b0402a0762b01b00f0700e01009030060700202b01b0130)) (.node (.leaf + 0x2b01b01303006070020200c0700b0400a01009030060700202b01b013030060) (.leaf + 0xf0060700202b01b02d0300607002)))) (.node (.node (.node (.leaf + 0x1000000000100000000010000000000060000000000060000000000004a) (.leaf + 0x3dc0140ac2ec01012806c00c29002020010400a01201b100d03006070000)) (.node (.leaf + 0xc0700b0402a0762b01b00f0700e01009030060700202b01b00807007030060) (.leaf + 0xf3006070020200c0700b0400a01009030060700202b01b013030060700202))) (.node (.node (.leaf + 0x80000000000014a006070160601502b01b01401009030060700202b01b0130) (.leaf + 0xf100d0300607000000000100000000010000000001000000000004000000000)) (.node (.leaf + 0x100000000000a0010000000000000000000040a0060762b01b00f0700e0) (.leaf + 0xf0060700202b01b0350762b01b00f07000000000100000000010000))))) (.node (.node (.node (.node + (.leaf 0x6001000000600100000000010000000000020010000000040000000010006a) (.leaf + 0x3cac06cac1ac01012806c00c19002020010400a01201b100d03006070000)) (.node (.leaf + 0x2b01b0350762b01b00f0700e01009030060700202b01b0080700703006070050) (.leaf 0xf006070020))) + (.node (.node (.leaf 0x6001000000600100000000010000000000000010000000060000000010006a) + (.leaf 0xf0060700202b01b0350762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x6001000000000100000000010010000000060000010000000000000010013a) (.leaf 0x0)))) (.node + (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf + 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))))))))) + +def fuelMode3 : ℕ := 20396 +noncomputable def streamMode3 : WordRLE.BTree ℕ := + .node (.node (.node (.node (.node (.node (.node (.node (.node (.node (.leaf + 0x1c0c0181c0140ac06cac06c01012806c00c190020200104560903702b02b0170) (.leaf + 0xf2b01b01303006070020200c02402c10028040240c0181c0080ac06c0201c0)) (.node (.leaf + 0x700202b01b010070020200c0700b0400a01201b009030060703803006070020) (.leaf + 0xf00202b01b01303006072290020201d0700903006072290020201c02b03b02e))) (.node (.node (.leaf + 0x290020201d07009030060700202b01b01303006072290020201d070090300607) (.leaf + 0xf700e01201b00d030060700202b01b013030060700202b01b01303006072)) (.node (.leaf + 0x100000000000a0010000000000000000000010a0060700502b01b00f0) (.leaf + 0xf1009030060700202b01b01303006070020200c070000000001000000000100)))) (.node (.node (.node + (.leaf 0x80900e01009030060700202b01b01303006072290020200c0700b0400a01201b) (.leaf + 0x3cc0181c8a4008080041002804806c0840c0181c8a4008080801c8a407c1807)) (.node (.leaf + 0x700202b01b01007016060150200c0700b0400a01201b00903006070220100d0) (.leaf + 0xf300607229002020010400a0100d0300607229002020010401802b02b02e))) (.node (.node (.leaf + 0x81c0140ac2ac01012806c00c29002020390701a0700502b01b00f0700e0100d0) (.leaf + 0x3cc0181c0080ac06c04c0c0181c008080480c0181c0080ac06c0201c01c0c01)) (.node (.leaf + 0x202001040250400a01201b024060230700b0400a01201b01a0702201201b00d0) (.leaf + 0xf10260700502b01b00f0700e0100d0300607002020010400a0100d030060700))))) (.node (.node (.node + (.node (.leaf 0x10000000000040000000000060000000000012a0060700502b01b00f0700e0) (.leaf + 0x3cac2ec01012806c00c29002020120300607000000000100000000010000000)) (.node (.leaf + 0x70020200c0700b0400a01201b009030060700202b01b0080700703006070050) (.leaf + 0xf400a01201b0210300607002020200701f06029030060700202b01b01303006))) (.node (.node (.leaf + 0x1201b024060230700b0400a01201b01a0702201201b100d0300607002020010) (.leaf + 0xf700e0100d0300607002020010400a0100d030060700202001040250400a)) (.node (.leaf + 0x40000000000022a0060700502b01b00f0700e010260762b01b00f0) (.leaf + 0xf00a01201b00d03006070000000001000000000100000000010000000000060)))) (.node (.node (.node + (.leaf 0xc0181c0080ac06c0201c01c0c0181c0140ac32c01012806c00c290020200104) (.leaf + 0x3c0101002804806c0e81c0681c0080ac06c0401c0140ac06c03c1c03804024)) (.node (.leaf + 0x300607002020200701f06029030060700202b01b00807007030060700202b02b) (.leaf + 0xf300607002020010400a01202b100d0300607002020010400a01201b0210))) (.node (.node (.leaf + 0x10000000000050000000000080000000000030a0060762b01b00f0700e0100d0) (.leaf + 0xf700502b01b00f0700e0100d030060700000000010000000001000000000)) (.node (.leaf + 0x80ac06c0201c01c0c0181c0140ac36c01012806c00c290020201102b01b0100) (.leaf + 0x3cc0181c008080741c0240c0181c0080ac06c04c0c0181c008080480c0181c0)))))) (.node (.node (.node + (.node (.node (.leaf 0x1b0040400a01201b01b0700b0400a01201b01a07038030060700202b01b0130) + (.leaf 0xf100d030060700202b01b01303006070020201d0700903006070020201c02b)) (.node (.leaf + 0x10000000000070000000000080000000000010a0060700502b01b00f0700e0) (.leaf + 0x3cac3ac01012806c00c29002020120300607000000000100000000010000000))) (.node (.node (.leaf + 0x70020200c0700b0400a071201b009030060700202b01b0080700703006070050) (.leaf + 0xf01303006070020200c0700b0400a01201b009030060700202b01b013030060)) (.node (.leaf + 0x7002020010400a01201b0210300607002020200701f06029030060700202b01b) (.leaf + 0xf001040250400a01201b024060230700b0400a01201b01a070220100d030060)))) (.node (.node (.node + (.leaf 0x260700502b01b00f0700e0100d0300607002020010400a0100d030060700202) (.leaf + 0xf0060700502b01b00f0700e01)) (.node (.leaf + 0x1000000000100000000010000000000080000000000060000000000012a) (.leaf + 0x3dc0140ac3ec01012806c00c29002020010400a071201b00d03006070000))) (.node (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xf400a01201b03a0701a0700502b01b00f0700e01009030060700202b01b0130)) (.node (.leaf + 0x7002020200701f06029030060700202b01b00807007030060700202b01b0040) (.leaf + 0xf00607002020010400a01202b100d0300607002020010400a01201b02103006))))) (.node (.node (.node + (.node (.leaf 0x70000000000090000000000030a0060762b01b00f0700e0100d03) (.leaf + 0x3e9002020010400a01201b100d0300607000000000100000000010000000001)) (.node (.leaf + 0xf0700e01009030060700202b01b00807007030060700502b10b00404a01b0030) (.leaf + 0xf012030060700202b01b01303006070020200c0700b040270701a0762b01b00))) (.node (.node (.leaf + 0x100d0300607002020010400a01203b00d030060700202b01b013030060700202) (.leaf + 0xf0060762b01b00f0700e0)) (.node (.leaf + 0x10000000001000000000100000000000500000000000c0000000000030a) (.leaf + 0x3d2806c00c2900202001040270701a0762b01b00f0700e0100d03006070000)))) (.node (.node (.node + (.leaf 0x200c0700b0400a01009030060700202b01b00807007030060700502b11b0040) (.leaf + 0xf3006070020200c0700b0400a01201b009030060700202b01b0130300607002)) (.node (.leaf + 0x20010400a01201b0210300607002020200701f06029030060700202b01b0130) (.leaf + 0xf762b01b00f0700e0100d0300607002020010400a01203b100d0300607002))) (.node (.node (.leaf + 0x10000000001000000000100000000000700000000000a0000000000040a0060) (.leaf + 0x3c0181c0140ac4ac01012806c00c29002020010400a0100d030060700000000)) (.node (.leaf + 0x1303006070020200c0700b0400a01201b1009030060700202b01b0080700703) (.leaf + 0xf2b01b0100700202b01b0100700502b01b00f0700e01009030060700202b01b))))))) (.node (.node + (.node (.node (.node (.node (.leaf + 0x20000000000120000000000005a0060700502b01b00f0700e01201b026070020) (.leaf + 0xf400a01201b100d030060700000000010000000001000000000100000000000)) (.node (.leaf + 0x40c0181c0080ac06c0201c01c0c0181c0140ac4ec01012806c00c29002020010) (.leaf + 0x3ec06c04c0c0181c008080301c02c100ac0ac06c0401d8ac06c03c1c0380402))) (.node (.node (.leaf + 0x6070020201d07009030060700202b01b013030060700202012030060700202) (.leaf + 0xf700e0100d0300607002020010400a01202b00d030060700202b01b01303)) (.node (.leaf + 0x1000000000100000000000700000000000e0000000000020a0060762b01b00f0) (.leaf + 0xf402b02b01b0100762b01b00f0700e0100d03006070000000001000000000)))) (.node (.node (.node + (.leaf 0x40c0181c0080ac06c0201c01c0c0181c0140ac52c01012806c00c29002020010) (.leaf + 0x3c0281c4806c0240c0181c0080ac06c04c0c0181c008080301c02c100280402)) (.node (.leaf + 0x200c0700b0400a01201b009030060700202b01b01303006070020200c0700b04) (.leaf + 0xf201b0210300607002020200701f06029030060700202b01b01303006070020))) (.node (.node (.leaf + 0xf0700e0100d0300607002020010400a01202b100d0300607002020010400a01) (.leaf 0xf0060762b01b0)) + (.node (.leaf 0x10000000001000000000100000000000900000000000c0000000000030a) (.leaf + 0x3cc0181c0140ac56c01012806c00c29002020010400a0100d03006070000))))) (.node (.node (.node + (.node (.leaf 0x1303006070020200c0700b0400a071201b1009030060700202b01b008070070) (.leaf + 0xf2b01b01303006070020200c0700b0400a01201b1009030060700202b01b)) (.node (.leaf + 0xf0700e01201b0260700202b01b0100700502b01b00f0700e0100903006070020) (.leaf + 0xf0060700502b01b00))) (.node (.node (.leaf + 0x1000000000100000000010000000000040000000000130000000000005a) (.leaf + 0x3dc0140ac5ac01012806c00c29002020010400a071201b100d03006070000)) (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xf700b0402b02b01b0100762b01b00f0700e01009030060700202b01b0130)))) (.node (.node (.node + (.leaf 0x700202b01b013030060700202012030060700202b01b01303006070020200c0) (.leaf + 0xf20010400a01201b00d030060700202b01b01303006070020201d0700903006)) (.node (.leaf + 0x100000000000010a0060700502b01b00f0700e0100d03006070020) (.leaf + 0xf00a01201b100d0300607000000000100000000010000000001000000000009))) (.node (.node (.leaf + 0xc0181c0080ac06c0201c01c0c0181c0140ac5ec01012806c00c290020200104) (.leaf + 0x3c04c0c0181c008080301c02c100ac0ac06c0401d8ac06c03c1c03804024)) (.node (.leaf + 0x30060700202b01b01303006070020200c0700b0400a01009030060700202b01b) (.leaf + 0xf201b009030060700202b01b01303006070020200c0700b0400a071201b0090)))))) (.node (.node (.node + (.node (.node (.leaf 0x2020200701f06029030060700202b01b01303006070020200c0700b0400a01) + (.leaf 0xf7002020010400a01201b100d0300607002020010400a01201b0210300607)) (.node (.leaf + 0xb00000000000e0000000000020a0060762b01b00f0700e0100d030060) (.leaf + 0xf762b01b00f0700e0100d03006070000000001000000000100000000010000))) (.node (.node (.leaf + 0x6c0201c01c0c0181c0140ac62c01012806c00c29002020010402b02b01b0100) (.leaf + 0x3cc0181c0080ac06c04c0c0181c008080301c02c10028040240c0181c0080ac)) (.node (.leaf + 0x201b1009030060700202b01b01303006070020200c0700b0400a071201b10090) (.leaf + 0xf00f0700e01009030060700202b01b01303006070020200c0700b0400a01)))) (.node (.node (.node + (.leaf 0x140000000000005a0060700502b01b00f0700e01201b0260700502b01b) (.leaf + 0xf400a0100d03006070000000001000000000100000000010000000000060000)) (.node (.leaf + 0x40c0181c0080ac06c0201c01c0c0181c0140ac66c01012806c00c29002020010) (.leaf + 0x3c40240c0181c0080ac06c04c0c0181c008080301c02c100281c4806c402))) (.node (.node (.leaf + 0xb00f0700e01009030060700202b01b01303006070020200c0700b0400a01201b) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01)) (.node (.leaf + 0x1000000000100000000010000000000040000000000160000000000015a) (.leaf + 0x3dc0140ac6ac01012806c00c29002020010400a071201b100d03006070000))))) (.node (.node (.node + (.node (.leaf 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xfb01b00f0700e01201b0260762b01b00f0700e01009030060700202b01b0130)) (.node (.leaf + 0x100000000010000000000020000000000180000000000025a0060700502) (.leaf + 0x3c01012806c00c29002020010400a01201b100d030060700000000010000))) (.node (.node (.leaf + 0x260762b01b00f0700e01009030060700202b01b00807007030060700502b1bb) (.leaf + 0xf0060700502b01b00f0700e01201b)) (.node (.leaf + 0x10000000001000000000100000000000000000000001a0000000000035a) (.leaf + 0xf700502b01b00f0700e01201b0260762b01b00f0700e0100d03006070000)))) (.node (.node (.node + (.leaf 0x10000000001000000000100000000001a0010000000000000000000042a0060) (.leaf + 0x3cac06c0101002804806c0a00900b040270701a0762b01b00f0700000000)) (.node (.leaf + 0x607229002020200722901f06029030060700202b01b0080700703006070020) (.leaf + 0xf700b0400a01201b01a070220100d0300607229002020010400a01201b02103))) (.node (.node (.leaf + 0x229002020010400a0100d030060722900202001040250400a01201b024060230) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d0300607)) (.node (.leaf + 0x10000000001000000000100000000000a0010000000000000000000012a) (.leaf + 0x3c0300900b0400a01009030060700202b01b01303006072290020200c070000)))))))) (.node (.node + (.node (.node (.node (.node (.node (.leaf + 0xb0400a01201b01a0702201201b00d030060700202b01b013030060722900202) (.leaf + 0xf20010400a0100d030060722900202001040250400a01201b02406023070)) (.node (.leaf + 0x60700502b01b00f0700e010260700502b01b00f0700e0100d03006072290020) (.leaf 0xf0))) (.node + (.node (.leaf 0x10000000001000000000100000000000a0010000000000000000000012a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006072290020200c070000)) (.node (.leaf + 0x801c8a407c180780900e01009030060700202b01b01303006072290020200c0) (.leaf + 0x3dc08804806c40340c0181e8a4008080041002804806c0840c0181c8a400808)))) (.node (.node (.node + (.leaf 0x12806c00c2900202001040250400a01201b024060230700b0400a01201b01a0) (.leaf + 0x3c80301c02c10028040240c0181c0080ac06c0201c01c0c0181c0140ac3ac01)) (.node (.leaf + 0x700e010260700502b01b00f0700e01009030060700202b01b01303006070020) (.leaf + 0xf0060700502b01b00f))) (.node (.node (.leaf + 0x10000000001000000000100000000000200000000000c0000000000005a) (.leaf + 0x3cc0181c0140ac3ec01012806c00c29002020010400a0100d03006070000)) (.node (.leaf + 0x2b01b00f0700e010260762b01b00f0700e01009030060700202b01b008070070) (.leaf 0xf006070050))))) + (.node (.node (.node (.node (.leaf + 0x10000000001000000000100000000000000000000000e0000000000015a) (.leaf + 0xf0060700502b01b00f0700e010260762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x10000000001000000000100000000000e0010000000000000000000022a) (.leaf + 0x3d002804806c0e81c0681c0b00900b0402b02b01b0100762b01b00f070000))) (.node (.node (.leaf + 0x29002020200701f06029030060700202b01b00807007030060700202b02b0040) (.leaf + 0xf20010400a01202b100d0300607229002020010400a01201b02103006072)) (.node (.leaf + 0x10000000000000000000030a0060762b01b00f0700e0100d0300607a290020) (.leaf + 0xf3006072290020200c0700000000010000000001000000000100000000000f)))) (.node (.node (.node + (.leaf 0x80ac06c04c0c0181c8a4008080300900b0400a01009030060700202b01b0130) (.leaf + 0x3c0681c0e00c0181c0080ac06c04c0c0181e8a4008080741c0240c0181c0)) (.node (.leaf + 0x1d070090300607a290020201c02b01b0040400a01201b01b0700b0400a01201b) (.leaf + 0xf0060700502b01b00f0700e0100d030060700202b01b0130300607a29002020))) (.node (.node (.leaf + 0x1000000000100000000010000000000130010000000000000000000010a) (.leaf + 0xf00b0400a071201b1009030060700202b01b01303006072290020200c070000)) (.node (.leaf + 0x200c0700b0400a01201b1009030060700202b01b0130300607a290020200c07) (.leaf + 0x3c80801e8a407c180780900e01009030060700202b01b0130300607a29002)))))) (.node (.node (.node + (.node (.node (.leaf 0x1201b01a070220100d0300607a29002020010400a01201b0210300607a290020) + (.leaf 0x3ec5ac01012806c00c2900202001040250400a01201b024060230700b0400a0)) (.node (.leaf + 0x6070020200c0700b0400a01009030060700202b01b00807007030060700502) (.leaf + 0xf400a01201b0210300607002020200701f06029030060700202b01b01303))) (.node (.node (.leaf + 0xb00f0700e0100d03006070020200104a01b03c0703b0100d0300607002020010) (.leaf 0xf0060762b01)) + (.node (.leaf 0x1000000000100000000010000000000050000000000100000000000020a) (.leaf + 0x3cc0181c0140ac5ec01012806c00c29002020010400a0100d03006070000)))) (.node (.node (.node + (.leaf 0x1b00f0700e010260700502b01b00f0700e01009030060700202b01b008070070) (.leaf + 0xf0060700502b0)) (.node (.leaf + 0x1000000000100000000010000000000000000000000160000000000005a) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x1000000000100000000010000000000160010000000000000000000012a) (.leaf + 0x3dc0080ac06c0101002804806c0a00900b040270701a0762b01b00f070000)) (.node (.leaf + 0x210300607a290020202007a2901f06029030060700202b01b00807007030060) (.leaf + 0xf300607a29002020010400a01202b100d0300607a29002020010400a01201b))))) (.node (.node (.node + (.node (.leaf 0x10000000000170010000000000000000000030a0060762b01b00f0700e0100d0) (.leaf + 0xf700202b01b0130300607a290020200c0700000000010000000001000000000)) (.node (.leaf + 0xec0340c0181c0080ac06c04c0c0181e8a4008080300900b0400a01009030060) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181e8a40080800410028048))) (.node (.node (.leaf + 0x1000000000100000000010000000000170010000000000000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b0130300607a290020200c070000)) (.node (.leaf + 0x801e8a407c180780900e01009030060700202b01b0130300607a290020200c0) (.leaf + 0x3d00280480ec40340c0181e8a4008080041002804806c0840c0181e8a400808)))) (.node (.node (.node + (.leaf 0x40c0181c0080ac06c0201c01c0c0181c0140ac72c01012806c00c29002020010) (.leaf + 0x3dc0080ac06c04c0c0181c008080301c02c100a81d8ac06c03c1c0380402)) (.node (.leaf + 0xb01401009030060700202b01b01303006070020200c0700b0400a01009030060) (.leaf + 0xf006070160601502b01))) (.node (.node (.leaf + 0x1000000000100000000010000000000040000000000190000000000014a) (.leaf + 0xf0060762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x10000000001000000000100000000001b0010000000000000000000040a) (.leaf + 0x3c0981c0080ac06c0401c0b00900b0402b02b01b0100762b01b00f070000))))))) (.node (.node (.node + (.node (.node (.node (.leaf 0x180010000000020000000000005a0060700502b01b00f0700e01201b) + (.leaf 0xf2b01b0130300607a290020200c0700000000010000006001000000000100)) (.node (.leaf + 0x40c0181c0080ac06c04c0c0181e8a4008080300900b0400a0100903006070020) (.leaf + 0x3c8004100280480ac0340c0181c0080ac06c04c0c0181e8a4008080741c02))) (.node (.node (.leaf + 0x10000000000000000000020a0060762b01b00f0700e0100d0300607a290020) (.leaf + 0xf300607a290020200c0700000000010000000001000000000100000000001f)) (.node (.leaf + 0x1b0130300607a290020200c0700b0400a071201b1009030060700202b01b0130) (.leaf + 0xf2b01b0130300607a290020200c0700b0400a01201b1009030060700202b0)))) (.node (.node (.node + (.leaf 0x2804806c0840c0181e8a4008080801e8a407c180780900e0100903006070020) (.leaf + 0xfb24b00404a01b0030a400808004100280480ac40340c0181e8a40080800410)) (.node (.leaf + 0xb0402a0762b01b00f0700e01009030060700202b01b00807007030060700502) (.leaf + 0xf70020200c0700b0400a01009030060700202b01b01303006070020200c070))) (.node (.node (.leaf + 0x210000000000004a0060700202b01b02d030060700202b01b013030060) (.leaf + 0xf700e0100d03006070000000001000000000100000000010000000000040000)) (.node (.leaf + 0x100000000010000000000230010000000000000000000030a0060762b01b00f0) (.leaf + 0x3c0981c0b00900b0402b02b01b0100762b01b00f070000000001000000000))))) (.node (.node (.node + (.node (.leaf 0x200010000000010000000000005a0060700502b01b00f0700e01201b) (.leaf + 0xf2b01b0130300607a290020200c0700000000010000006001000000000100)) (.node (.leaf + 0x40c0181c0080ac06c04c0c0181e8a4008080300900b0400a0100903006070020) (.leaf + 0x3c80041002804806c0340c0181c0080ac06c04c0c0181e8a4008080741c02))) (.node (.node (.leaf + 0x10a0060700502b01b00f0700e0100d0300607a290020) (.leaf + 0xf7a290020200c07000000000100000000010000000001000000000027001)) (.node (.leaf + 0x300607a290020200c0700b0400a071201b1009030060700202b01b013030060) (.leaf + 0xf0130300607a290020200c0700b0400a01201b1009030060700202b01b013)))) (.node (.node (.node + (.leaf 0x806c0840c0181e8a4008080801e8a407c180780900e01009030060700202b01b) (.leaf + 0xf2b01b00807007030060700502b2bb00404a01b0030a4008080041002804)) (.node (.leaf + 0x30060700202b01b01303006070020200c0700b0400a01201b100903006070020) (.leaf + 0xf700b0400a01201b009030060700202b01b02e0700502b01b00f0700e010090))) (.node (.node (.leaf + 0xb0210300607002020200701f06029030060700202b01b01303006070020200c0) (.leaf + 0xf0060700502b01b00f0700e0100d0300607002020010400a01201)) (.node (.leaf + 0x1000000000100000000010000000000070000000000250000000000010a) (.leaf + 0x3dc0140acb2c01012806c00c29002020010400a01201b100d03006070000)))))) (.node (.node (.node + (.node (.node (.leaf 0xc0700b0402a0762b01b00f0700e01009030060700202b01b00807007030060) + (.leaf 0xf400a01201b00d030060700202012030060700202b01b013030060700202)) (.node (.leaf + 0x3006070020201102b01b0100700502b01b00f0700e0100d0300607002020010) (.leaf + 0xf400a01201b100d0300607002020010400a071201b00d030060700202012))) (.node (.node (.leaf + 0x240000000000020a0060762b01b00f0700e0100d0300607002020010) (.leaf + 0xf700e0100d030060700000000010000000001000000000100000000000800)) (.node (.leaf + 0x1000000000100000000002b0010000000000000000000020a0060762b01b00f0) (.leaf + 0xf700502b01b00f0700e01201b0260762b01b00f070000000001000000000)))) (.node (.node (.node + (.leaf 0x1000000600100000000010000000000280010000000000000000010005a0060) (.leaf + 0x3c0140ac06cac0ac01012806c00c19002020010400a0100d030060700000060)) (.node (.leaf + 0x6070020200c0700b0400a01201b1009030060700202b01b008070070300607) (.leaf + 0x3cc0181c8a4008080801c07c180780900e01009030060700202b01b01303))) (.node (.node (.leaf + 0xb0400a01201b00903006070220100d0300607229002020010400a01201b0210) (.leaf + 0xf00607229002020010401802b02b02e0700202b01b01007016060150200c070)) (.node (.leaf + 0x20390701a0700502b01b00f0700e0100d0300607229002020010400a0100d03) (.leaf + 0x3c0201c01c0c0181c0140ac26c01012806c00c29002020120300607229002))))) (.node (.node (.node + (.node (.leaf 0x700202b01b01303006070020200c0700b0400a01201b009030060700202b01b) (.leaf + 0xf00d0300607002020010400a01201b0210300607002020200701f0602903006)) (.node (.leaf + 0x700202001040250400a01201b024060230700b0400a01201b01a0702201201b1) (.leaf + 0xf700e010260762b01b00f0700e0100d0300607002020010400a0100d030060))) (.node (.node (.leaf + 0x10000000000060000000000020000000000022a0060700502b01b00f0) (.leaf + 0x3d2806c00c29002020010400a01201b00d03006070000000001000000000100)) (.node (.leaf + 0x502b01b00f0700e01009030060700202b01b00807007030060700502b0ab0040) (.leaf + 0xf7007030060700202b02b0040400a01201b03a0701a0700202b01b0100700)))) (.node (.node (.node + (.leaf 0x20010400a01201b0210300607002020200701f06029030060700202b01b0080) (.leaf + 0xf762b01b00f0700e0100d0300607002020010400a01202b100d0300607002)) (.node (.leaf + 0x1000000000100000000010000000000050000000000060000000000030a0060) (.leaf + 0x3c00c290020201102b01b0100700502b01b00f0700e0100d030060700000000))) (.node (.node (.leaf + 0x30060700202012030060700202b01b00807007030060700502b0bb00404a01b) (.leaf + 0xf7038030060700202b01b01303006070020201d07009030060700202b01b013)) (.node (.leaf + 0xd0700903006070020201c02b01b0040400a01201b01b0700b0400a01201b01a0) (.leaf + 0xf0060700502b01b00f0700e0100d030060700202b01b01303006070020201))))))))) (.node (.node + (.node (.node (.node (.node (.node (.node (.leaf + 0x1000000000100000000010000000000070000000000060000000000010a) (.leaf + 0x3ec06c0201c01c0c0181c0140ac32c01012806c00c290020201203006070000)) (.node (.leaf + 0x60700202b01b01303006070020200c0700b0400a071201b009030060700202) (.leaf + 0xf6029030060700202b01b01303006070020200c0700b0400a01201b00903))) (.node (.node (.leaf + 0xb01a070220100d0300607002020010400a01201b0210300607002020200701f0) (.leaf + 0xf00a0100d030060700202001040250400a01201b024060230700b0400a01201)) (.node (.leaf + 0x700502b01b00f0700e010260700502b01b00f0700e0100d03006070020200104) (.leaf 0xf0060)))) + (.node (.node (.node (.leaf 0x1000000000100000000010000000000080000000000040000000000012a) + (.leaf 0x3dc0140ac36c01012806c00c29002020010400a071201b00d03006070000)) (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xf400a01201b03a0701a0700502b01b00f0700e01009030060700202b01b0130))) (.node (.node (.leaf + 0x7002020200701f06029030060700202b01b00807007030060700202b01b0040) (.leaf + 0xf00607002020010400a01202b100d0300607002020010400a01201b02103006)) (.node (.leaf + 0x70000000000070000000000030a0060762b01b00f0700e0100d03) (.leaf + 0x3e9002020010400a01201b100d0300607000000000100000000010000000001))))) (.node (.node (.node + (.node (.leaf 0xf0700e01009030060700202b01b00807007030060700502b0eb00404a01b0030) (.leaf + 0xf012030060700202b01b01303006070020200c0700b040270701a0762b01b00)) (.node (.leaf + 0x100d0300607002020010400a01203b00d030060700202b01b013030060700202) (.leaf + 0xf0060762b01b00f0700e0))) (.node (.node (.leaf + 0x10000000001000000000100000000000500000000000a0000000000030a) (.leaf + 0x3d2806c00c2900202001040270701a0762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x200c0700b0400a01009030060700202b01b00807007030060700502b0fb0040) (.leaf + 0xf3006070020200c0700b0400a01201b009030060700202b01b0130300607002)))) (.node (.node (.node + (.leaf 0x20010400a01201b0210300607002020200701f06029030060700202b01b0130) (.leaf + 0xf762b01b00f0700e0100d0300607002020010400a01203b100d0300607002)) (.node (.leaf + 0x1000000000100000000010000000000070000000000080000000000040a0060) (.leaf + 0x3c0181c0140ac42c01012806c00c29002020010400a0100d030060700000000))) (.node (.node (.leaf + 0x1303006070020200c0700b0400a01201b1009030060700202b01b0080700703) (.leaf + 0xf2b01b0100700202b01b0100700502b01b00f0700e01009030060700202b01b)) (.node (.leaf + 0x20000000000100000000000005a0060700502b01b00f0700e01201b026070020) (.leaf + 0xf400a01201b100d030060700000000010000000001000000000100000000000)))))) (.node (.node (.node + (.node (.node (.leaf 0x40c0181c0080ac06c0201c01c0c0181c0140ac46c01012806c00c29002020010) + (.leaf 0x3ec06c04c0c0181c008080301c02c100ac0ac06c0401d8ac06c03c1c0380402)) (.node (.leaf + 0x6070020201d07009030060700202b01b013030060700202012030060700202) (.leaf + 0xf700e0100d0300607002020010400a01202b00d030060700202b01b01303))) (.node (.node (.leaf + 0x1000000000100000000000700000000000c0000000000020a0060762b01b00f0) (.leaf + 0xf402b02b01b0100762b01b00f0700e0100d03006070000000001000000000)) (.node (.leaf + 0x40c0181c0080ac06c0201c01c0c0181c0140ac4ac01012806c00c29002020010) (.leaf + 0x3c0281c4806c0240c0181c0080ac06c04c0c0181c008080301c02c100280402)))) (.node (.node (.node + (.leaf 0x200c0700b0400a01201b009030060700202b01b01303006070020200c0700b04) (.leaf + 0xf201b0210300607002020200701f06029030060700202b01b01303006070020)) (.node (.leaf + 0xf0700e0100d0300607002020010400a01202b100d0300607002020010400a01) (.leaf 0xf0060762b01b0))) + (.node (.node (.leaf 0x10000000001000000000100000000000900000000000a0000000000030a) (.leaf + 0x3cc0181c0140ac4ec01012806c00c29002020010400a0100d03006070000)) (.node (.leaf + 0x1303006070020200c0700b0400a071201b1009030060700202b01b008070070) (.leaf + 0xf2b01b01303006070020200c0700b0400a01201b1009030060700202b01b))))) (.node (.node (.node + (.node (.leaf 0xf0700e01201b0260700202b01b0100700502b01b00f0700e0100903006070020) (.leaf + 0xf0060700502b01b00)) (.node (.leaf + 0x1000000000100000000010000000000040000000000110000000000005a) (.leaf + 0x3dc0140ac52c01012806c00c29002020010400a071201b100d03006070000))) (.node (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xf700b0402b02b01b0100762b01b00f0700e01009030060700202b01b0130)) (.node (.leaf + 0x700202b01b013030060700202012030060700202b01b01303006070020200c0) (.leaf + 0xf20010400a01201b00d030060700202b01b01303006070020201d0700903006)))) (.node (.node (.node + (.leaf 0xe0000000000010a0060700502b01b00f0700e0100d03006070020) (.leaf + 0xf00a01201b100d0300607000000000100000000010000000001000000000009)) (.node (.leaf + 0xc0181c0080ac06c0201c01c0c0181c0140ac56c01012806c00c290020200104) (.leaf + 0x3c04c0c0181c008080301c02c100ac0ac06c0401d8ac06c03c1c03804024))) (.node (.node (.leaf + 0x30060700202b01b01303006070020200c0700b0400a01009030060700202b01b) (.leaf + 0xf201b009030060700202b01b01303006070020200c0700b0400a071201b0090)) (.node (.leaf + 0x2020200701f06029030060700202b01b01303006070020200c0700b0400a01) (.leaf + 0xf7002020010400a01201b100d0300607002020010400a01201b0210300607))))))) (.node (.node (.node + (.node (.node (.node (.leaf 0xb00000000000c0000000000020a0060762b01b00f0700e0100d030060) + (.leaf 0xf762b01b00f0700e0100d03006070000000001000000000100000000010000)) (.node (.leaf + 0x6c0201c01c0c0181c0140ac5ac01012806c00c29002020010402b02b01b0100) (.leaf + 0x3cc0181c0080ac06c04c0c0181c008080301c02c10028040240c0181c0080ac))) (.node (.node (.leaf + 0x201b1009030060700202b01b01303006070020200c0700b0400a071201b10090) (.leaf + 0xf00f0700e01009030060700202b01b01303006070020200c0700b0400a01)) (.node (.leaf + 0x120000000000005a0060700502b01b00f0700e01201b0260700502b01b) (.leaf + 0xf400a0100d03006070000000001000000000100000000010000000000060000)))) (.node (.node (.node + (.leaf 0x40c0181c0080ac06c0201c01c0c0181c0140ac5ec01012806c00c29002020010) (.leaf + 0x3c40240c0181c0080ac06c04c0c0181c008080301c02c100281c4806c402)) (.node (.leaf + 0xb00f0700e01009030060700202b01b01303006070020200c0700b0400a01201b) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01))) (.node (.node (.leaf + 0x1000000000100000000010000000000040000000000140000000000015a) (.leaf + 0x3dc0140ac62c01012806c00c29002020010400a071201b100d03006070000)) (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xfb01b00f0700e01201b0260762b01b00f0700e01009030060700202b01b0130))))) (.node (.node (.node + (.node (.leaf 0x100000000010000000000020000000000160000000000025a0060700502) (.leaf + 0x3c01012806c00c29002020010400a01201b100d030060700000000010000)) (.node (.leaf + 0x260762b01b00f0700e01009030060700202b01b00807007030060700502b19b) (.leaf + 0xf0060700502b01b00f0700e01201b))) (.node (.node (.leaf + 0x1000000000100000000010000000000000000000000180000000000035a) (.leaf + 0xf700502b01b00f0700e01201b0260762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x1000000000100000000010000000000180010000000000000000000042a0060) (.leaf + 0x3cac06c0101002804806c0a00900b040270701a0762b01b00f0700000000)))) (.node (.node (.node + (.leaf 0x10300607229002020200701f06029030060700202b01b0080700703006070020) (.leaf + 0xf700b0400a01201b01a070220100d0300607229002020010400a01201b02)) (.node (.leaf + 0x229002020010400a0100d030060722900202001040250400a01201b024060230) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d0300607))) (.node (.node (.leaf + 0x1000000000100000000010000000000080010000000000000000000012a) (.leaf + 0x3c80300900b0400a01009030060700202b01b01303006070020200c070000)) (.node (.leaf + 0xb0400a01201b01a0702201201b00d030060700202b01b01303006072290020) (.leaf + 0xf002020010400a0100d030060722900202001040250400a01201b0240602307)))))) (.node (.node (.node + (.node (.node (.leaf 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d0300607229) + (.leaf 0x0)) (.node (.leaf 0x1000000000100000000010000000000080010000000000000000000012a) + (.leaf 0xf700b0400a01201b1009030060700202b01b01303006072290020200c070000))) (.node (.node + (.leaf 0x801c8a407c180780900e01009030060700202b01b01303006072290020200c0) (.leaf + 0x3dc08804806c40340c0181c8a4008080041002804806c0840c0181c8a400808)) (.node (.leaf + 0xd0300607a2900202001040250400a01201b024060230700b0400a01201b01a0) (.leaf + 0x3cac06c0201c01c0c0181c0140ac36c01012806c00c29002020010400a010)))) (.node (.node (.node + (.leaf 0xf0060700502b01b00f0700e010260762b01b00f0700e0100903006070020) (.leaf 0x0)) (.node + (.leaf 0x10000000001000000000100000000000000000000000c0000000000015a) (.leaf + 0xf0060700502b01b00f0700e010260762b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x10000000001000000000100000000000c0010000000000000000000022a) (.leaf + 0x3d002804806c0e81c0681c0b00900b0402b02b01b0100762b01b00f070000)) (.node (.leaf + 0x29002020200701f06029030060700202b01b00807007030060700202b02b0040) (.leaf + 0xf20010400a01202b100d0300607229002020010400a01201b02103006072))))) (.node (.node (.node + (.node (.leaf 0x10000000000000000000030a0060762b01b00f0700e0100d03006072290020) (.leaf + 0xf3006072290020200c0700000000010000000001000000000100000000000d)) (.node (.leaf + 0x80ac06c04c0c0181c8a4008080300900b0400a01009030060700202b01b0130) (.leaf + 0x3c0681c0e00c0181c0080ac06c04c0c0181c8a4008080741c0240c0181c0))) (.node (.node (.leaf + 0x1d070090300607a290020201c02b01b0040400a01201b01b0700b0400a01201b) (.leaf + 0xf0060700502b01b00f0700e0100d030060700202b01b0130300607a29002020)) (.node (.leaf + 0x1000000000100000000010000000000110010000000000000000000010a) (.leaf + 0xf00b0400a071201b1009030060700202b01b01303006072290020200c070000)))) (.node (.node (.node + (.leaf 0x200c0700b0400a01201b1009030060700202b01b01303006072290020200c07) (.leaf + 0x3c80801e8a407c180780900e01009030060700202b01b0130300607a29002)) (.node (.leaf + 0x1201b01a070220100d0300607a29002020010400a01201b0210300607a290020) (.leaf + 0x3ec52c01012806c00c2900202001040250400a01201b024060230700b0400a0))) (.node (.node (.leaf + 0x6070020200c0700b0400a01009030060700202b01b00807007030060700502) (.leaf + 0xf400a01201b0210300607002020200701f06029030060700202b01b01303)) (.node (.leaf + 0xb00f0700e0100d03006070020200104a01b03c0703b0100d0300607002020010) (.leaf + 0xf0060762b01)))))))) (.node (.node (.node (.node (.node (.node (.node (.leaf + 0x10000000001000000000100000000000500000000000e0000000000020a) (.leaf + 0x3cc0181c0140ac56c01012806c00c29002020010400a0100d03006070000)) (.node (.leaf + 0x1b00f0700e010260700502b01b00f0700e01009030060700202b01b008070070) (.leaf + 0xf0060700502b0))) (.node (.node (.leaf + 0x1000000000100000000010000000000000000000000140000000000005a) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d03006070000)) (.node (.leaf + 0x1000000000100000000010000000000140010000000000000000000012a) (.leaf + 0x3dc0080ac06c0101002804806c0a00900b040270701a0762b01b00f070000)))) (.node (.node (.node + (.leaf 0x210300607a290020202007a2901f06029030060700202b01b00807007030060) (.leaf + 0xf300607a29002020010400a01202b100d0300607a29002020010400a01201b)) (.node (.leaf + 0x10000000000150010000000000000000000030a0060762b01b00f0700e0100d0) (.leaf + 0xf700202b01b0130300607a290020200c0700000000010000000001000000000))) (.node (.node (.leaf + 0xec0340c0181c0080ac06c04c0c0181e8a4008080300900b0400a01009030060) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181e8a40080800410028048)) (.node (.leaf + 0x1000000000100000000010000000000150010000000000000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b0130300607a290020200c070000))))) (.node (.node (.node + (.node (.leaf 0x801e8a407c180780900e01009030060700202b01b0130300607a290020200c0) (.leaf + 0x3d00280480ec40340c0181e8a4008080041002804806c0840c0181e8a400808)) (.node (.leaf + 0x40a0060762b01b00f0700e0100d0300607a29002020010) (.leaf + 0xf762b01b00f0700000000010000000001000000000100000000001900100))) (.node (.node (.leaf + 0x140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0402b02b01b0100) (.leaf 0x3c0181c0)) + (.node (.leaf 0x1000000600100000000010000000000160010000000020000000000005a) (.leaf + 0x3c0300900b0400a01009030060700202b01b0130300607a290020200c070000)))) (.node (.node (.node + (.leaf 0xb01b0130300607a290020201d07009030060700202b01b0130300607a2900202) (.leaf + 0xf2b01b00f0700e0100d0300607a29002020010400a01202b00d030060700202)) (.node (.leaf + 0x1000000000100000000001d0010000000000000000000020a006076) (.leaf + 0xf71201b1009030060700202b01b0130300607a290020200c070000000001))) (.node (.node (.leaf + 0xb0400a01201b1009030060700202b01b0130300607a290020200c0700b0400a0) (.leaf + 0xfa407c180780900e01009030060700202b01b0130300607a290020200c0700)) (.node (.leaf + 0x80480ac40340c0181e8a4008080041002804806c0840c0181e8a4008080801e8) (.leaf + 0xf700202b01b00807007030060700502b22b00404a01b0030a4008080041002)))))) (.node (.node (.node + (.node (.node (.leaf 0x202b01b01303006070020200c0700b0402a0762b01b00f0700e01009030060) + (.leaf 0xf02d030060700202b01b01303006070020200c0700b0400a010090300607)) (.node (.leaf + 0x1000000000100000000000400000000001f0000000000004a0060700202b01b) (.leaf + 0xf0060762b01b00f0700e0100d0300607000000000100000000))) (.node (.node (.leaf + 0x1000000000100000000010000000000210010000000000000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000)) (.node (.leaf + 0x1000000000100000000001e0010000000010000000000005a0060700502b01b) (.leaf + 0xf1009030060700202b01b0130300607a290020200c07000000000100000060)))) (.node (.node (.node + (.leaf 0x8a4008080741c0240c0181c0080ac06c04c0c0181e8a4008080300900b0400a0) (.leaf + 0x3c0340c0181e8a4008080041002804806c0340c0181c0080ac06c04c0c0181e)) (.node (.leaf + 0x10000000000250010000000000000000000010a0060700502b01b00f0700e01) (.leaf + 0xf700202b01b0130300607a290020200c070000000001000000000100000000))) (.node (.node (.leaf + 0x30060700202b01b0130300607a290020200c0700b0400a071201b1009030060) (.leaf + 0xf1009030060700202b01b0130300607a290020200c0700b0400a01201b1009)) (.node (.leaf + 0x1e8a4008080041002804806c0840c0181e8a4008080801e8a407c180780900e0) (.leaf + 0xf007030060700502b2ab00404a01b0030a4008080041002804806c40340c018))))) (.node (.node (.node + (.node (.leaf 0x6070020200c0700b0402a0762b01b00f0700e01009030060700202b01b00807) (.leaf + 0xf7002020010400a01201b00d030060700202012030060700202b01b013030)) (.node (.leaf + 0x70020201203006070020201102b01b0100700502b01b00f0700e0100d030060) (.leaf + 0xf7002020010400a01201b100d0300607002020010400a071201b00d03006))) (.node (.node (.leaf + 0x80000000000220000000000020a0060762b01b00f0700e0100d030060) (.leaf + 0xf762b01b00f0700e0100d03006070000000001000000000100000000010000)) (.node (.leaf + 0x1000000000100000000010000000000290010000000000000000000020a0060) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f0700000000)))) (.node (.node (.node (.leaf + 0x6001000000600100000000010000000000260010000000000000000010005a) (.leaf + 0x3cac06cac0ec01012806c00c19002020010400a01201b100d03006070000)) (.node (.leaf + 0x270701a0762b01b00f0700e01009030060700202b01b0080700703006070050) (.leaf + 0x3dc0080ac06c0201c01c0c0181c0080ac06c0101002804806c0a00900b04))) (.node (.node (.leaf + 0x100d0300607002020010400a01201b0210300607002020200701f06029030060) (.leaf + 0xf722900202001040250400a01201b024060230700b0400a01201b01a070220)) (.node (.leaf + 0xe010260700502b01b00f0700e0100d0300607229002020010400a0100d030060) (.leaf + 0xf0060700502b01b00f0700))))))) (.node (.node (.node (.node (.node (.node (.node (.leaf + 0x1000000000100000000010000000000060010000000000000000000012a) (.leaf + 0x3c80300900b0400a01009030060700202b01b01303006070020200c070000)) (.node (.leaf + 0x30700b0400a01201b01a0702201201b00d030060700202b01b01303006070020) (.leaf + 0xf7229002020010400a0100d030060700202001040250400a01201b0240602))) (.node (.node (.leaf + 0x12a0060700502b01b00f0700e010260700502b01b00f0700e0100d030060) (.leaf + 0xf70000000001000000000100000000010000000000060010000000000000000)) (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b01303006070020200c0) (.leaf + 0x3dc8a4008080801c8a407c180780900e01009030060700202b01b013030060)))) (.node (.node (.node + (.leaf 0xa01201b01a0702201201b100d0300607229002020010400a01201b021030060) (.leaf + 0xf400a0100d030060722900202001040250400a01201b024060230700b040)) (.node (.leaf + 0x40c0181c0080ac06c0201c01c0c0181c0140ac2ec01012806c00c29002020010) (.leaf + 0x3c0181c0140ac06c03c1c038040981d8ac06c03c1c0380402))) (.node (.node (.leaf + 0x10000000001000000000100000000000000000000000a0000000000015a) (.leaf + 0xf0060700502b01b00f0700e010260762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x10000000001000000000100000000000a0010000000000000000000022a) (.leaf + 0x3d002804806c0e81c0681c0b00900b0402b02b01b0100762b01b00f070000))))) (.node (.node (.node + (.node (.leaf 0x29002020200701f06029030060700202b01b00807007030060700202b02b0040) (.leaf + 0xf20010400a01202b100d0300607229002020010400a01201b02103006072)) (.node (.leaf + 0x10000000000000000000030a0060762b01b00f0700e0100d03006072290020) (.leaf + 0xf3006072290020200c0700000000010000000001000000000100000000000b))) (.node (.node (.leaf + 0x80ac06c04c0c0181c8a4008080300900b0400a01009030060700202b01b0130) (.leaf + 0x3c0681c0e00c0181c0080ac06c04c0c0181c8a4008080741c0240c0181c0)) (.node (.leaf + 0x1d0700903006072290020201c02b01b0040400a01201b01b0700b0400a01201b) (.leaf + 0xf0060700502b01b00f0700e0100d030060700202b01b0130300607a29002020)))) (.node (.node (.node + (.leaf 0x10000000001000000000100000000000f0010000000000000000000010a) (.leaf + 0xf00b0400a071201b1009030060700202b01b01303006072290020200c070000)) (.node (.leaf + 0x200c0700b0400a01201b1009030060700202b01b01303006072290020200c07) (.leaf + 0x3c80801e8a407c180780900e01009030060700202b01b0130300607229002))) (.node (.node (.leaf + 0x1201b01a070220100d0300607a29002020010400a01201b0210300607a290020) (.leaf + 0x3ec4ac01012806c00c2900202001040250400a01201b024060230700b0400a0)) (.node (.leaf + 0x6070020200c0700b0400a01009030060700202b01b00807007030060700502) (.leaf + 0xf400a01201b0210300607002020200701f06029030060700202b01b01303)))))) (.node (.node (.node + (.node (.node (.leaf 0xb00f0700e0100d03006070020200104a01b03c0703b0100d0300607002020010) + (.leaf 0xf0060762b01)) (.node (.leaf + 0x10000000001000000000100000000000500000000000c0000000000020a) (.leaf + 0x3cc0181c0140ac4ec01012806c00c29002020010400a0100d03006070000))) (.node (.node (.leaf + 0x1b00f0700e010260700502b01b00f0700e01009030060700202b01b008070070) (.leaf 0xf0060700502b0)) + (.node (.leaf 0x1000000000100000000010000000000000000000000120000000000005a) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d03006070000)))) (.node (.node (.node + (.leaf 0x1000000000100000000010000000000120010000000000000000000012a) (.leaf + 0x3dc0080ac06c0101002804806c0a00900b040270701a0762b01b00f070000)) (.node (.leaf + 0x210300607a290020202007a2901f06029030060700202b01b00807007030060) (.leaf + 0xf300607a29002020010400a01202b100d0300607a29002020010400a01201b))) (.node (.node (.leaf + 0x10000000000130010000000000000000000030a0060762b01b00f0700e0100d0) (.leaf + 0xf700202b01b0130300607a290020200c0700000000010000000001000000000)) (.node (.leaf + 0xec0340c0181c0080ac06c04c0c0181e8a4008080300900b0400a01009030060) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181e8a40080800410028048))))) (.node (.node (.node (.node + (.leaf 0x1000000000100000000010000000000130010000000000000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b0130300607a290020200c070000)) (.node (.leaf + 0x801e8a407c180780900e01009030060700202b01b0130300607a290020200c0) (.leaf + 0x3d00280480ec40340c0181e8a4008080041002804806c0840c0181e8a400808))) (.node (.node (.leaf + 0x40a0060762b01b00f0700e0100d0300607a29002020010) (.leaf + 0xf762b01b00f0700000000010000000001000000000100000000001700100)) (.node (.leaf + 0x140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0402b02b01b0100) (.leaf 0x3c0181c0)))) + (.node (.node (.node (.leaf 0x1000000600100000000010000000000140010000000020000000000005a) + (.leaf 0x3c0300900b0400a01009030060700202b01b0130300607a290020200c070000)) (.node (.leaf + 0xb01b0130300607a290020201d07009030060700202b01b0130300607a2900202) (.leaf + 0xf2b01b00f0700e0100d0300607a29002020010400a01202b00d030060700202))) (.node (.node (.leaf + 0x1000000000100000000001b0010000000000000000000020a006076) (.leaf + 0xf71201b1009030060700202b01b0130300607a290020200c070000000001)) (.node (.leaf + 0xb0400a01201b1009030060700202b01b0130300607a290020200c0700b0400a0) (.leaf + 0xfa407c180780900e01009030060700202b01b0130300607a290020200c0700))))))) (.node (.node (.node + (.node (.node (.node (.leaf + 0x80480ac40340c0181e8a4008080041002804806c0840c0181e8a4008080801e8) (.leaf + 0xf700202b01b00807007030060700502b20b00404a01b0030a4008080041002)) (.node (.leaf + 0x202b01b01303006070020200c0700b0402a0762b01b00f0700e01009030060) (.leaf + 0xf02d030060700202b01b01303006070020200c0700b0400a010090300607))) (.node (.node (.leaf + 0x1000000000100000000000400000000001d0000000000004a0060700202b01b) (.leaf + 0xf0060762b01b00f0700e0100d0300607000000000100000000)) (.node (.leaf + 0x10000000001000000000100000000001f0010000000000000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000)))) (.node (.node (.node + (.leaf 0x1000000000100000000001c0010000000010000000000005a0060700502b01b) (.leaf + 0xf1009030060700202b01b0130300607a290020200c07000000000100000060)) (.node (.leaf + 0x8a4008080741c0240c0181c0080ac06c04c0c0181e8a4008080300900b0400a0) (.leaf + 0x3c0340c0181e8a4008080041002804806c0340c0181c0080ac06c04c0c0181e))) (.node (.node (.leaf + 0x10000000000230010000000000000000000010a0060700502b01b00f0700e01) (.leaf + 0xf700202b01b0130300607a290020200c070000000001000000000100000000)) (.node (.leaf + 0x30060700202b01b0130300607a290020200c0700b0400a071201b1009030060) (.leaf + 0xf1009030060700202b01b0130300607a290020200c0700b0400a01201b1009))))) (.node (.node (.node + (.node (.leaf 0x1e8a4008080041002804806c0840c0181e8a4008080801e8a407c180780900e0) (.leaf + 0xf007030060700502b28b00404a01b0030a4008080041002804806c40340c018)) (.node (.leaf + 0x6070020200c0700b0402a0762b01b00f0700e01009030060700202b01b00807) (.leaf + 0xf7002020010400a01201b00d030060700202012030060700202b01b013030))) (.node (.node (.leaf + 0x70020201203006070020201102b01b0100700502b01b00f0700e0100d030060) (.leaf + 0xf7002020010400a01201b100d0300607002020010400a071201b00d03006)) (.node (.leaf + 0x80000000000200000000000020a0060762b01b00f0700e0100d030060) (.leaf + 0xf762b01b00f0700e0100d03006070000000001000000000100000000010000)))) (.node (.node (.node + (.leaf 0x1000000000100000000010000000000270010000000000000000000020a0060) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f0700000000)) (.node (.leaf + 0x6001000000600100000000010000000000240010000000000000000010005a) (.leaf + 0x3d2806c00c1900202001040270701a0762b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x900b0400a01009030060700202b01b00807007030060700502b01b2b04b0040) (.leaf + 0x3d002804806c0681c08804806c0340c0181c0080ac06c04c0c0181c00808030)) (.node (.leaf + 0x7002020010400a0100d030060700202001040250400a01201b024060230700b0) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d030060)))))) (.node (.node (.node + (.node (.node (.leaf 0x1000000000100000040010000000000040010000000010000000000012a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006070020200c070000)) (.node (.leaf + 0xc008080801c07c180780900e01009030060700202b01b01303006070020200c0) (.leaf + 0x3c4806c0681c08804806c40340c0181c8a4008080041002804806c0840c0181))) (.node (.node (.leaf + 0x10400a0100d030060722900202001040250400a01201b024060230700b0400a0) (.leaf + 0xf700502b01b00f0700e010260762b01b00f0700e0100d03006072290020200)) (.node (.leaf + 0x1000000000100000000010000000000080010000000000000000000022a0060) (.leaf + 0x3c4806c0e81c0681c0b00900b0402b02b01b0100762b01b00f0700000000)))) (.node (.node (.node + (.leaf 0x20200701f06029030060700202b01b00807007030060700202b02b0040400a0) (.leaf + 0xf002020010400a01202b100d0300607002020010400a01201b0210300607002)) (.node (.leaf + 0x90010000000000000000000030a0060762b01b00f0700e0100d0300607229) (.leaf + 0xfb01b01303006070020200c0700000000010000000001000000000100000000))) (.node (.node (.leaf + 0x240c0181c0080ac06c04c0c0181c008080300900b0400a01009030060700202) (.leaf + 0x3c02c1002804806c0681c0e00c0181c0080ac06c04c0c0181c8a4008080741c)) (.node (.leaf + 0x6072290020201d0700903006072290020201c02b01b0040400a01201b01b07) (.leaf + 0xf0060700502b01b00f0700e0100d030060700202b01b01303))))) (.node (.node (.node (.node (.leaf + 0x10000000001000000000100000000000d0010000000000000000000010a) (.leaf + 0xf700b0400a071201b1009030060700202b01b01303006070020200c070000)) (.node (.leaf + 0x20200c0700b0400a01201b1009030060700202b01b01303006072290020200c0) (.leaf + 0x3c80801c8a407c180780900e01009030060700202b01b013030060722900))) (.node (.node (.leaf + 0x1201b01a070220100d0300607a29002020010400a01201b0210300607a290020) (.leaf + 0xf400a0100d0300607a2900202001040250400a01201b024060230700b0400a0)) (.node (.leaf + 0x40c0181c0080ac06c0201c01c0c0181c0140ac46c01012806c00c29002020010) (.leaf + 0x3c0181c0140ac06c03c1c038040981c0140ac06c03c1c0380402)))) (.node (.node (.node (.leaf + 0x1000000000100000000010000000000000000000000100000000000005a) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d03006070000)) (.node (.leaf + 0x1000000000100000000010000000000100010000000000000000000012a) (.leaf + 0x3dc0080ac06c0101002804806c0a00900b040270701a0762b01b00f070000))) (.node (.node (.leaf + 0x210300607a29002020200722901f06029030060700202b01b00807007030060) (.leaf + 0xf300607a29002020010400a01202b100d0300607a29002020010400a01201b)) (.node (.leaf + 0x10000000000110010000000000000000000030a0060762b01b00f0700e0100d0) (.leaf + 0xf700202b01b01303006072290020200c0700000000010000000001000000000))))))))))) (.node (.node + (.node (.node (.node (.node (.node (.node (.node (.leaf + 0xec0340c0181c0080ac06c04c0c0181e8a4008080300900b0400a01009030060) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181e8a40080800410028048)) (.node (.leaf + 0x1000000000100000000010000000000110010000000000000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b0130300607a290020200c070000))) (.node (.node (.leaf + 0x801e8a407c180780900e01009030060700202b01b0130300607a290020200c0) (.leaf + 0x3d00280480ec40340c0181e8a4008080041002804806c0840c0181e8a400808)) (.node (.leaf + 0x40a0060762b01b00f0700e0100d0300607a29002020010) (.leaf + 0xf762b01b00f0700000000010000000001000000000100000000001500100)))) (.node (.node (.node + (.leaf 0x140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0402b02b01b0100) (.leaf + 0x3c0181c0)) (.node (.leaf 0x1000000600100000000010000000000120010000000020000000000005a) + (.leaf 0x3c0300900b0400a01009030060700202b01b0130300607a290020200c070000))) (.node (.node + (.leaf 0xb01b0130300607a290020201d07009030060700202b01b0130300607a2900202) (.leaf + 0xf2b01b00f0700e0100d0300607a29002020010400a01202b00d030060700202)) (.node (.leaf + 0x100000000010000000000190010000000000000000000020a006076) (.leaf + 0xf71201b1009030060700202b01b0130300607a290020200c070000000001))))) (.node (.node (.node + (.node (.leaf 0xb0400a01201b1009030060700202b01b0130300607a290020200c0700b0400a0) (.leaf + 0xfa407c180780900e01009030060700202b01b0130300607a290020200c0700)) (.node (.leaf + 0x80480ac40340c0181e8a4008080041002804806c0840c0181e8a4008080801e8) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181e8a4008080041002))) (.node (.node (.leaf + 0x10000000001000000000100000000001d0010000000000000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000)) (.node (.leaf + 0x1000000000100000000001a0010000000010000000000005a0060700502b01b) (.leaf + 0xf1009030060700202b01b0130300607a290020200c07000000000100000060)))) (.node (.node (.node + (.leaf 0x8a4008080741c0240c0181c0080ac06c04c0c0181e8a4008080300900b0400a0) (.leaf + 0x3c0340c0181e8a4008080041002804806c0340c0181c0080ac06c04c0c0181e)) (.node (.leaf + 0x10000000000210010000000000000000000010a0060700502b01b00f0700e01) (.leaf + 0xf700202b01b0130300607a290020200c070000000001000000000100000000))) (.node (.node (.leaf + 0x30060700202b01b0130300607a290020200c0700b0400a071201b1009030060) (.leaf + 0xf1009030060700202b01b0130300607a290020200c0700b0400a01201b1009)) (.node (.leaf + 0x1e8a4008080041002804806c0840c0181e8a4008080801e8a407c180780900e0) (.leaf + 0xf007030060700502b26b00404a01b0030a4008080041002804806c40340c018)))))) (.node (.node (.node + (.node (.node (.leaf 0x6070020200c0700b0402a0762b01b00f0700e01009030060700202b01b00807) + (.leaf 0xf7002020010400a01201b00d030060700202012030060700202b01b013030)) (.node (.leaf + 0x70020201203006070020201102b01b0100700502b01b00f0700e0100d030060) (.leaf + 0xf7002020010400a01201b100d0300607002020010400a071201b00d03006))) (.node (.node (.leaf + 0x800000000001e0000000000020a0060762b01b00f0700e0100d030060) (.leaf + 0xf762b01b00f0700e0100d03006070000000001000000000100000000010000)) (.node (.leaf + 0x1000000000100000000010000000000250010000000000000000000020a0060) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f0700000000)))) (.node (.node (.node (.leaf + 0x6001000000600100000000010000000000220010000000000000000010005a) (.leaf + 0x3dc0140ac06cac16c01012806c00c19002020010400a0100d03006070000)) (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0x3c0840c0181c008080801c07c180780900e01009030060700202b01b0130))) (.node (.node (.leaf + 0x60230700b0400a01201b01a0702201201b100d0300607002020010400a01201b) (.leaf + 0xf300607229002020010400a0100d030060700202001040250400a01201b0240)) (.node (.leaf + 0x22a0060700502b01b00f0700e010260762b01b00f0700e0100d0) (.leaf + 0xfb01b00f0700000000010000000001000000000100000000000600100000000))))) (.node (.node (.node + (.node (.leaf 0x181c0080ac0ac0101002804806c0e81c0681c0b00900b0402b02b01b0100762) (.leaf + 0x3c4806c0840c0181c008080801c07c180a40c0181c0080ac06c0201c01c0c)) (.node (.leaf + 0xf0700e0100d0300607002020010400a01202b100d0300607002020010400a0) (.leaf 0xf0060762b01b))) + (.node (.node (.leaf 0x1000000000100000000010000000000070010000000010000000000030a) (.leaf + 0x3c80300900b0400a01009030060700202b01b01303006070020200c070000)) (.node (.leaf + 0x700202b01b01303006070020201d07009030060700202b01b01303006070020) (.leaf + 0xf70020201c02b01b0040400a01201b01b0700b0400a01201b01a0703803006)))) (.node (.node (.node + (.leaf 0x1b00f0700e0100d030060700202b01b01303006072290020201d07009030060) (.leaf + 0xf0060700502b)) (.node (.leaf + 0x10000000001000000000100000000000b0010000000000000000000010a) (.leaf + 0xf700b0400a071201b1009030060700202b01b01303006070020200c070000))) (.node (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b01303006070020200c0) (.leaf + 0x3dc8a4008080801c8a407c180780900e01009030060700202b01b013030060)) (.node (.leaf + 0xb0400a01201b01a070220100d0300607a29002020010400a01201b021030060) (.leaf + 0xf20010400a0100d0300607a2900202001040250400a01201b02406023070))))))) (.node (.node (.node + (.node (.node (.node (.leaf + 0x8040240c0181c0080ac06c0201c01c0c0181c0140ac3ec01012806c00c290020) (.leaf + 0x3c0181c0140ac06c03c1c038040981c0140ac06c03c1c03)) (.node (.leaf + 0x10000000001000000000100000000000000000000000e0000000000005a) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x10000000001000000000100000000000e0010000000000000000000012a) (.leaf + 0x3dc0080ac06c0101002804806c0a00900b040270701a0762b01b00f070000)) (.node (.leaf + 0x210300607229002020200722901f06029030060700202b01b00807007030060) (.leaf + 0xf300607a29002020010400a01202b100d0300607a29002020010400a01201b)))) (.node (.node (.node + (.leaf 0x100000000000f0010000000000000000000030a0060762b01b00f0700e0100d0) (.leaf + 0xf700202b01b01303006072290020200c0700000000010000000001000000000)) (.node (.leaf + 0xec0340c0181c0080ac06c04c0c0181c8a4008080300900b0400a01009030060) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181e8a40080800410028048))) (.node (.node (.leaf + 0x10000000001000000000100000000000f0010000000000000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006072290020200c070000)) (.node (.leaf + 0x801e8a407c180780900e01009030060700202b01b0130300607a290020200c0) (.leaf + 0x3d00280480ec40340c0181e8a4008080041002804806c0840c0181e8a400808))))) (.node (.node (.node + (.node (.leaf 0x40a0060762b01b00f0700e0100d0300607a29002020010) (.leaf + 0xf762b01b00f0700000000010000000001000000000100000000001300100)) (.node (.leaf + 0x140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0402b02b01b0100) (.leaf 0x3c0181c0))) + (.node (.node (.leaf 0x1000000600100000000010000000000100010000000020000000000005a) (.leaf + 0x3c0300900b0400a01009030060700202b01b0130300607a290020200c070000)) (.node (.leaf + 0xb01b0130300607a290020201d07009030060700202b01b0130300607a2900202) (.leaf + 0xf2b01b00f0700e0100d0300607a29002020010400a01202b00d030060700202)))) (.node (.node (.node + (.leaf 0x100000000010000000000170010000000000000000000020a006076) (.leaf + 0xf71201b1009030060700202b01b0130300607a290020200c070000000001)) (.node (.leaf + 0xb0400a01201b1009030060700202b01b0130300607a290020200c0700b0400a0) (.leaf + 0xfa407c180780900e01009030060700202b01b0130300607a290020200c0700))) (.node (.node (.leaf + 0x80480ac40340c0181e8a4008080041002804806c0840c0181e8a4008080801e8) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181e8a4008080041002)) (.node (.leaf + 0x10000000001000000000100000000001b0010000000000000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000)))))) (.node (.node (.node + (.node (.node (.leaf 0x100000000010000000000180010000000010000000000005a0060700502b01b) + (.leaf 0xf1009030060700202b01b0130300607a290020200c07000000000100000060)) (.node (.leaf + 0x8a4008080741c0240c0181c0080ac06c04c0c0181e8a4008080300900b0400a0) (.leaf + 0x3c0340c0181e8a4008080041002804806c0340c0181c0080ac06c04c0c0181e))) (.node (.node (.leaf + 0x100000000001f0010000000000000000000010a0060700502b01b00f0700e01) (.leaf + 0xf700202b01b0130300607a290020200c070000000001000000000100000000)) (.node (.leaf + 0x30060700202b01b0130300607a290020200c0700b0400a071201b1009030060) (.leaf + 0xf1009030060700202b01b0130300607a290020200c0700b0400a01201b1009)))) (.node (.node (.node + (.leaf 0x1e8a4008080041002804806c0840c0181e8a4008080801e8a407c180780900e0) (.leaf + 0x3dd8ac06c03c1c038040340c0181e8a4008080041002804806c40340c018)) (.node (.leaf + 0x1000000000100000000010000000000230010000000000000000000020a0060) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f0700000000))) (.node (.node (.leaf + 0x6001000000600100000000010000000000200010000000000000000010005a) (.leaf + 0x3cac06cac1ac01012806c00c19002020010400a01201b100d03006070000)) (.node (.leaf + 0x2b01b0100762b01b00f0700e01009030060700202b01b0080700703006070050) (.leaf + 0x3dc01c0c0181c0080ac0ac0101002804806c0e81c0681c0b00900b0402b0))))) (.node (.node (.node + (.node (.leaf 0x20010400a01201b0210300607002020200701f06029030060700202b01b0080) (.leaf + 0xf762b01b00f0700e0100d0300607002020010400a01202b100d0300607002)) (.node (.leaf + 0x1000000000100000000010000000000050010000000030000000000030a0060) (.leaf + 0x3c900b0400a01009030060700202b01b01303006070020200c0700000000))) (.node (.node (.leaf + 0x2b01b01303006070020201d07009030060700202b01b01303006070020200c0) (.leaf + 0xf201c02b01b0040400a01201b01b0700b0400a01201b01a070380300607002)) (.node (.leaf + 0xb00f0700e0100d030060700202b01b01303006070020201d0700903006070020) (.leaf + 0xf0060700502b01)))) (.node (.node (.node (.leaf + 0x1000000000100000000010000000000090010000000010000000000010a) (.leaf + 0xf700b0400a071201b1009030060700202b01b01303006070020200c070000)) (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b01303006070020200c0) (.leaf + 0x3cc0181c008080801c07c180780900e01009030060700202b01b013030060))) (.node (.node (.leaf + 0x230700b0400a01201b01a070220100d0300607229002020010400a01201b0210) (.leaf + 0x3e9002020010400a0100d0300607a2900202001040250400a01201b024060)) (.node (.leaf + 0xf0700e01009030060700202b01b00807007030060700502b0db00404a01b0030) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00)))))))) (.node (.node (.node (.node (.node + (.node (.node (.leaf 0x10000000001000000000100000000000000000000000c0000000000005a) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d03006070000)) (.node (.leaf + 0x10000000001000000000100000000000c0010000000000000000000012a) (.leaf + 0x3dc0080ac06c0101002804806c0a00900b040270701a0762b01b00f070000))) (.node (.node (.leaf + 0x1201b0210300607002020200701f06029030060700202b01b00807007030060) (.leaf + 0xf100d0300607a29002020010400a01202b100d0300607229002020010400a)) (.node (.leaf + 0x100000000000d0010000000000000000000030a0060762b01b00f0700e0) (.leaf + 0xf30060700202b01b01303006070020200c07000000000100000000010000)))) (.node (.node (.node + (.leaf 0x100280480ec0340c0181c0080ac06c04c0c0181c008080300900b0400a010090) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181c8a400808004)) (.node (.leaf + 0x10000000001000000000100000000000d0010000000000000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006070020200c070000))) (.node (.node (.leaf + 0x801e8a407c180780900e01009030060700202b01b01303006072290020200c0) (.leaf + 0x3d00280480ec40340c0181e8a4008080041002804806c0840c0181e8a400808)) (.node (.leaf + 0x40a0060762b01b00f0700e0100d0300607a29002020010) (.leaf + 0xf762b01b00f0700000000010000000001000000000100000000001100100))))) (.node (.node (.node + (.node (.leaf 0x140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0402b02b01b0100) (.leaf + 0x3c0181c0)) (.node (.leaf 0x10000006001000000000100000000000e0010000000020000000000005a) + (.leaf 0x3c0300900b0400a01009030060700202b01b0130300607a290020200c070000))) (.node (.node + (.leaf 0xb01b0130300607a290020201d07009030060700202b01b0130300607a2900202) (.leaf + 0xf2b01b00f0700e0100d0300607a29002020010400a01202b00d030060700202)) (.node (.leaf + 0x100000000010000000000150010000000000000000000020a006076) (.leaf + 0xf71201b1009030060700202b01b0130300607a290020200c070000000001)))) (.node (.node (.node + (.leaf 0xb0400a01201b1009030060700202b01b0130300607a290020200c0700b0400a0) (.leaf + 0xfa407c180780900e01009030060700202b01b0130300607a290020200c0700)) (.node (.leaf + 0x80480ac40340c0181e8a4008080041002804806c0840c0181e8a4008080801e8) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181e8a4008080041002))) (.node (.node (.leaf + 0x1000000000100000000010000000000190010000000000000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000)) (.node (.leaf + 0x100000000010000000000160010000000010000000000005a0060700502b01b) (.leaf + 0xf1009030060700202b01b0130300607a290020200c07000000000100000060)))))) (.node (.node (.node + (.node (.node (.leaf 0x8a4008080741c0240c0181c0080ac06c04c0c0181e8a4008080300900b0400a0) + (.leaf 0x3c0340c0181e8a4008080041002804806c0340c0181c0080ac06c04c0c0181e)) (.node (.leaf + 0x100000000001d0010000000000000000000010a0060700502b01b00f0700e01) (.leaf + 0xf700202b01b0130300607a290020200c070000000001000000000100000000))) (.node (.node (.leaf + 0x30060700202b01b0130300607a290020200c0700b0400a071201b1009030060) (.leaf + 0xf1009030060700202b01b0130300607a290020200c0700b0400a01201b1009)) (.node (.leaf + 0x1e8a4008080041002804806c0840c0181e8a4008080801e8a407c180780900e0) (.leaf + 0x3dd8ac06c03c1c038040340c0181e8a4008080041002804806c40340c018)))) (.node (.node (.node + (.leaf 0x1000000000100000000010000000000210010000000000000000000020a0060) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f0700000000)) (.node (.leaf + 0x60010000006001000000000100000000001e0010000000000000000010005a) (.leaf + 0x3c00c19002020010402b02b01b0100762b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x400a01009030060700202b01b00807007030060700502b01b2b07b00404a01b) (.leaf + 0x3cc0181c008080741c0240c0181c0080ac06c04c0c0181c008080300900b)) (.node (.leaf + 0x1b0040400a01201b01b0700b0400a01201b01a07038030060700202b01b0130) (.leaf + 0xf100d030060700202b01b01303006070020201d0700903006070020201c02b))))) (.node (.node (.node + (.node (.leaf 0x10000000000070010000000030000000000010a0060700502b01b00f0700e0) (.leaf + 0xf30060700202b01b01303006070020200c07000000000100000000010000000)) (.node (.leaf + 0x201b1009030060700202b01b01303006070020200c0700b0400a071201b10090) (.leaf + 0x3d80780900e01009030060700202b01b01303006070020200c0700b0400a01))) (.node (.node (.leaf + 0xb01a070220100d0300607002020010400a01201b0210300607002020200701f0) (.leaf + 0xf00a0100d030060700202001040250400a01201b024060230700b0400a01201)) (.node (.leaf + 0x502b01b00f0700e010260700502b01b00f0700e0100d0300607a290020200104) (.leaf 0xf0060700)))) + (.node (.node (.node (.leaf 0x10000000001000000000100000000000a0010000000000000000000012a) + (.leaf 0x3dc0080ac06c0101002804806c0a00900b040270701a0762b01b00f070000)) (.node (.leaf + 0x1201b0210300607002020200701f06029030060700202b01b00807007030060) (.leaf + 0xf700e0100d0300607002020010400a01202b100d0300607002020010400a))) (.node (.node (.leaf + 0x1000000000100000000000b0010000000000000000000030a0060762b01b00f0) (.leaf + 0xf1009030060700202b01b01303006070020200c070000000001000000000)) (.node (.leaf + 0x8004100280480ec0340c0181c0080ac06c04c0c0181c008080300900b0400a0) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181c008))))))) (.node (.node (.node (.node (.node (.node + (.leaf 0x10000000001000000000100000000000b0010000000010000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006070020200c070000)) (.node (.leaf + 0x4008080801c07c180780900e01009030060700202b01b01303006070020200c0) (.leaf + 0x3c8004100280480ec40340c0181e8a4008080041002804806c0840c0181e8a))) (.node (.node (.leaf + 0x10000000000000000000040a0060762b01b00f0700e0100d0300607a290020) (.leaf + 0xfb01b0100762b01b00f0700000000010000000001000000000100000000000f)) (.node (.leaf + 0x3c0181c0140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0402b02) (.leaf 0x0)))) (.node + (.node (.node (.leaf 0x10000000001000000000100000000000c0010000000030000000000005a) (.leaf + 0x3c80300900b0400a01009030060700202b01b01303006070020200c070000)) (.node (.leaf + 0x2b01b0130300607a290020201d07009030060700202b01b0130300607a290020) (.leaf + 0xf62b01b00f0700e0100d0300607a29002020010400a01202b00d03006070020))) (.node (.node (.leaf + 0x1000000000100000000010000000000130010000000000000000000020a00607) (.leaf + 0xf00a071201b1009030060700202b01b0130300607a290020200c07000000000)) (.node (.leaf + 0x700b0400a01201b1009030060700202b01b0130300607a290020200c0700b04) (.leaf + 0x3de8a407c180780900e01009030060700202b01b0130300607a290020200c))))) (.node (.node (.node + (.node (.leaf 0xa01202b100d0300607a29002020010400a01201b0210300607a29002020200) (.leaf + 0xf0060762b01b00f0700e0100d0300607a290020200104)) (.node (.leaf + 0x1000000000100000000010000000000170010000000000000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000))) (.node (.node (.leaf + 0x100000000010000000000140010000000010000000000005a0060700502b01b) (.leaf + 0xf1009030060700202b01b0130300607a290020200c07000000000100000060)) (.node (.leaf + 0x8a4008080741c0240c0181c0080ac06c04c0c0181e8a4008080300900b0400a0) (.leaf + 0x3c0340c0181e8a4008080041002804806c0340c0181c0080ac06c04c0c0181e)))) (.node (.node (.node + (.leaf 0x100000000001b0010000000000000000000010a0060700502b01b00f0700e01) (.leaf + 0xf700202b01b0130300607a290020200c070000000001000000000100000000)) (.node (.leaf + 0x30060700202b01b0130300607a290020200c0700b0400a071201b1009030060) (.leaf + 0xf1009030060700202b01b0130300607a290020200c0700b0400a01201b1009))) (.node (.node (.leaf + 0x1e8a4008080041002804806c0840c0181e8a4008080801e8a407c180780900e0) (.leaf + 0x3dd8ac06c03c1c038040340c0181e8a4008080041002804806c40340c018)) (.node (.leaf + 0x10000000001000000000100000000001f0010000000000000000000020a0060) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f0700000000)))))) (.node (.node (.node (.node + (.node (.leaf 0x60010000006001000000000100000000001c0010000000000000000010005a) (.leaf + 0x3dc0140ac06cac22c01012806c00c19002020010400a0100d03006070000)) (.node (.leaf + 0x6070020200c0700b0400a071201b1009030060700202b01b00807007030060) (.leaf + 0xf01303006070020200c0700b0400a01201b1009030060700202b01b01303))) (.node (.node (.leaf + 0x2804806c0840c0181c008080801c07c180780900e01009030060700202b01b) (.leaf + 0x3c4806c0901808c1c02c1002804806c0681c088040340c0181c008080041)) (.node (.leaf + 0xf0700e0100d0300607002020010400a0100d030060700202001040250400a0) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b)))) (.node (.node (.node (.leaf + 0x1000000000100000000010000000000080010000000010000000000012a) (.leaf + 0x3dc0080ac06c0101002804806c0a00900b040270701a0762b01b00f070000)) (.node (.leaf + 0x1201b0210300607002020200701f06029030060700202b01b00807007030060) (.leaf + 0xf700e0100d0300607002020010400a01202b100d0300607002020010400a))) (.node (.node (.leaf + 0x100000000010000000000090010000000020000000000030a0060762b01b00f0) (.leaf + 0xf1009030060700202b01b01303006070020200c070000000001000000000)) (.node (.leaf + 0x8004100280480ec0340c0181c0080ac06c04c0c0181c008080300900b0400a0) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181c008))))) (.node (.node (.node (.node (.leaf + 0x1000000000100000000010000000000090010000000030000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006070020200c070000)) (.node (.leaf + 0xc008080801c07c180780900e01009030060700202b01b01303006070020200c0) (.leaf + 0x3e8a400808004100280480ec40340c0181c008080041002804806c0840c0181))) (.node (.node (.leaf + 0xd0010000000000000000000040a0060762b01b00f0700e0100d0300607) (.leaf + 0xf402b02b01b0100762b01b00f0700000000010000000001000000000100000)) (.node (.leaf + 0x1680181c0140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0) (.leaf + 0x3dc000000000400000000040000000004000000000028004000000014000000)))) (.node (.node (.node + (.leaf 0xc0181c008080300900b0400a01009030060700202b01b01303006070020200c0) (.leaf + 0x3cc0181c0080ac06c04c0c0181c008080741c0240c0181c0080ac06c04c0)) (.node (.leaf + 0x20a0060762b01b00f0700e0100d0300607a29002020010400a01202b00d0) (.leaf + 0xf70000000001000000000100000000010000000000110010000000000000000))) (.node (.node (.leaf + 0x20200c0700b0400a071201b1009030060700202b01b01303006070020200c0) (.leaf + 0xf00607a290020200c0700b0400a01201b1009030060700202b01b0130300607)) (.node (.leaf + 0x840c0181e8a4008080801e8a407c180780900e01009030060700202b01b01303) (.leaf + 0x3c0181e8a400808004100280480ac40340c0181e8a4008080041002804806c0))))))))) (.node (.node + (.node (.node (.node (.node (.node (.node (.leaf + 0x150010000000000000000000030a0060762b01b00f0700e0100d03) (.leaf + 0x3c900b0402b02b01b0100762b01b00f07000000000100000000010000000001)) (.node (.leaf + 0x20010000000010000000000005a0060700502b01b00f0700e01201b0260702c0) (.leaf + 0xf300607a290020200c0700000000010000006001000000000100000000001))) (.node (.node (.leaf + 0x80ac06c04c0c0181e8a4008080300900b0400a01009030060700202b01b0130) (.leaf + 0x3c4806c0340c0181c0080ac06c04c0c0181e8a4008080741c0240c0181c0)) (.node (.leaf + 0x10a0060700502b01b00f0700e0100d0300607a29002020010400a0) (.leaf + 0xf200c070000000001000000000100000000010000000000190010000000000)))) (.node (.node (.node + (.leaf 0x290020200c0700b0400a071201b1009030060700202b01b0130300607a290020) (.leaf + 0xf7a290020200c0700b0400a01201b1009030060700202b01b0130300607a)) (.node (.leaf + 0x181e8a4008080801e8a407c180780900e01009030060700202b01b013030060) (.leaf + 0x3de8a4008080041002804806c40340c0181e8a4008080041002804806c0840c))) (.node (.node (.leaf + 0x1d0010000000000000000000020a0060762b01b00f0700e0100d030060) (.leaf + 0xf700e01201b0260762b01b00f070000000001000000000100000000010000)) (.node (.leaf + 0x100000000001a0010000000000000000010005a0060700502b01b00f0) (.leaf + 0x3c00c19002020010400a071201b100d03006070000006001000000600100))))) (.node (.node (.node + (.node (.leaf 0x1201b1009030060700202b01b00807007030060700502b01b2b09b00404a01b) (.leaf + 0xf2b01b00f0700e01009030060700202b01b01303006070020200c0700b0400a)) (.node (.leaf + 0xac06c0201c01c0c0181c0080ac06c0101002804806c0a00900b040270701a076) (.leaf + 0x3dc008080041002804806c0840c0181c008080801c07c180a40c0181c0080))) (.node (.node (.leaf + 0xf0060762b01b00f0700e0100d0300607002020010400a01202b100d030060) (.leaf 0x0)) (.node (.leaf + 0x1000000000100000000010000000000070010000000040000000000030a) (.leaf + 0x3c80300900b0400a01009030060700202b01b01303006070020200c070000)))) (.node (.node (.node + (.leaf 0x100d0300607002020010400a01203b00d030060700202b01b01303006070020) (.leaf + 0xf0060762b01b00f0700e)) (.node (.leaf + 0x1000000000100000000010000000000070010000000050000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006070020200c070000))) (.node (.node (.leaf + 0xc008080801c07c180780900e01009030060700202b01b01303006070020200c0) (.leaf + 0x3dc00808004100280480ec40340c0181c008080041002804806c0840c0181)) (.node (.leaf + 0xb0010000000010000000000040a0060762b01b00f0700e0100d030060) (.leaf + 0xf402b02b01b0100762b01b00f070000000001000000000100000000010000)))))) (.node (.node (.node + (.node (.node (.leaf 0x1680181c0140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0) (.leaf + 0x3dc00000000040000000004000000000400000000002000400000001c000000)) (.node (.leaf + 0xc0181c008080300900b0400a01009030060700202b01b01303006070020200c0) (.leaf + 0x3cc0181c0080ac06c04c0c0181c008080741c0240c0181c0080ac06c04c0))) (.node (.node (.leaf + 0x20a0060762b01b00f0700e0100d0300607002020010400a01202b00d0) (.leaf + 0xf700000000010000000001000000000100000000000f0010000000010000)) (.node (.leaf + 0x20200c0700b0400a071201b1009030060700202b01b01303006070020200c0) (.leaf + 0xf3006070020200c0700b0400a01201b1009030060700202b01b0130300607)))) (.node (.node (.node + (.leaf 0x6c0840c0181e8a4008080801c07c180780900e01009030060700202b01b0130) (.leaf + 0x3cc0181e8a400808004100280480ac40340c0181e8a40080800410028048)) (.node (.leaf + 0x10000000000130010000000000000000000030a0060762b01b00f0700e0100d0) (.leaf + 0x3c900b0402b02b01b0100762b01b00f0700000000010000000001000000000))) (.node (.node (.leaf + 0x10000000020000000000005a0060700502b01b00f0700e01201b0260702c0) (.leaf + 0xf01303006070020200c0700000000010000006001000000000100000000001)) (.node (.leaf + 0x81c0080ac06c04c0c0181e8a4008080300900b0400a01009030060700202b01b) (.leaf + 0x3d002804806c0340c0181c0080ac06c04c0c0181e8a4008080741c0240c01))))) (.node (.node (.node + (.node (.leaf 0x10a0060700502b01b00f0700e0100d0300607a29002020010) (.leaf + 0x3e90020200c0700000000010000000001000000000100000000001700100000)) (.node (.leaf + 0x181e8a4008080301c02c100281c4806c40240c0181c0080ac06c04c0c0181e8) (.leaf + 0x3cc0181e8a4008080301c02c1002804806c40240c0181c0080ac06c04c0c))) (.node (.node (.leaf + 0x840c0181e8a4008080801e8a407c180780900e01009030060700202b01b0130) (.leaf + 0x3cc0181e8a4008080041002804806c40340c0181e8a4008080041002804806c)) (.node (.leaf + 0x100000000001b0010000000000000000000020a0060762b01b00f0700e0100d0) (.leaf + 0xf00f0700e01201b0260762b01b00f0700000000010000000001000000000)))) (.node (.node (.node + (.leaf 0x100000000010000000000180010000000000000000010005a0060700502b01b) (.leaf + 0x3d2806c00c19002020010400a01201b100d0300607000000600100000060)) (.node (.leaf + 0x1b00f0700e01009030060700202b01b00807007030060700502b01b2b0ab0040) (.leaf + 0xf1009030060700202b01b01303006070020200c0700b040270701a0762b0))) (.node (.node (.leaf + 0x8004100280480ec0340c0181c0080ac06c04c0c0181c008080300900b0400a0) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181c008)) (.node (.leaf + 0x1000000000100000000010000000000050010000000070000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006070020200c070000))))))) (.node (.node (.node + (.node (.node (.node (.leaf + 0xc008080801c07c180780900e01009030060700202b01b01303006070020200c0) (.leaf + 0x3dc00808004100280480ec40340c0181c008080041002804806c0840c0181)) (.node (.leaf + 0x90010000000030000000000040a0060762b01b00f0700e0100d030060) (.leaf + 0xf402b02b01b0100762b01b00f070000000001000000000100000000010000))) (.node (.node (.leaf + 0x1680181c0140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0) (.leaf + 0x3dc000000000400000000040000000004000000000018004000000024000000)) (.node (.leaf + 0xc0181c008080300900b0400a01009030060700202b01b01303006070020200c0) (.leaf + 0x3cc0181c0080ac06c04c0c0181c008080741c0240c0181c0080ac06c04c0)))) (.node (.node (.node + (.leaf 0x20a0060762b01b00f0700e0100d0300607002020010400a01202b00d0) (.leaf + 0xf700000000010000000001000000000100000000000d0010000000030000)) (.node (.leaf + 0x20200c0700b0400a071201b1009030060700202b01b01303006070020200c0) (.leaf + 0xf3006070020200c0700b0400a01201b1009030060700202b01b0130300607))) (.node (.node (.leaf + 0x4806c0840c0181c008080801c07c180780900e01009030060700202b01b0130) (.leaf + 0x3c038040340c0181e8a400808004100280480ac40340c0181c0080800410028)) (.node (.leaf + 0x10000000000110010000000000000000000030a0060762b01b00f07) (.leaf + 0x3c0981c0b00900b0402b02b01b0100762b01b00f0700000000010000000001))))) (.node (.node (.node + (.node (.leaf 0xe0010000000040000000000005a0060700502b01b00f0700e01201b) (.leaf + 0xf700202b01b01303006070020200c0700000000010000000001000000000100)) (.node (.leaf + 0x80741c0240c0181c0080ac06c04c0c0181c008080300900b0400a01009030060) (.leaf + 0x3cc0181e8a4008080041002804806c0340c0181c0080ac06c04c0c0181c0080))) (.node (.node (.leaf + 0x150010000000000000000000010a0060700502b01b00f0700e0100d0) (.leaf + 0xf700202b01b01303006070020200c0700000000010000000001000000000100)) (.node (.leaf + 0x9030060700202b01b01303006070020200c0700b0400a071201b1009030060) (.leaf + 0xf00e01009030060700202b01b0130300607a290020200c0700b0400a01201b1)))) (.node (.node (.node + (.leaf 0xc0181e8a4008080041002804806c0840c0181e8a4008080801e8a407c1807809) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181e8a4008080041002804806c40340)) (.node (.leaf + 0x1000000000100000000010000000000190010000000000000000000020a) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f070000))) (.node (.node (.leaf + 0x6001000000600100000000010000000000160010000000000000000010005a) (.leaf + 0x3d2806c00c1900202001040270701a0762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x700b0400a01009030060700202b01b00807007030060700502b01b2b0bb0040) (.leaf + 0xf0020200c0700b0400a01201b1009030060700202b01b01303006070020200c)))))) (.node (.node (.node + (.node (.node (.leaf 0x840c0181c008080801c07c180780900e01009030060700202b01b0130300607) + (.leaf 0x3c40340c0181c00808004100280480ec40340c0181c008080041002804806c)) (.node (.leaf + 0x10000000000070010000000050000000000040a0060762b01b00f0700e0) (.leaf + 0x3dc0b00900b0402b02b01b0100762b01b00f07000000000100000000010000))) (.node (.node (.leaf + 0xb0000000000005a0060700502b01b00f0700e01201b0260700202b01b0100) (.leaf + 0xf70020200c0700000000010000000001000000000100000000000400100000)) (.node (.leaf + 0xac06c04c0c0181c008080300900b0400a01009030060700202b01b013030060) (.leaf + 0x3c0280480ac0340c0181c0080ac06c04c0c0181c008080741c0240c0181c008)))) (.node (.node (.node + (.leaf 0x50000000000020a0060762b01b00f0700e0100d03006070020200104) (.leaf + 0xf3006070020200c0700000000010000000001000000000100000000000b001)) (.node (.leaf + 0x2b01b01303006070020200c0700b0400a071201b1009030060700202b01b0130) (.leaf + 0xf700202b01b01303006070020200c0700b0400a01201b100903006070020))) (.node (.node (.leaf + 0xc008080041002804806c0840c0181c008080801c07c180780900e01009030060) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181c00808004100280480ac40340c0181)) (.node (.leaf + 0x10000000001000000000100000000000f0010000000010000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000))))) (.node (.node (.node + (.node (.leaf 0x1000000000100000000000c0010000000060000000000005a0060700502b01b) (.leaf + 0xf00a01009030060700202b01b01303006070020200c07000000000100000000)) (.node (.leaf + 0x4c0c0181c008080741c0240c0181c0080ac06c04c0c0181c008080300900b04) (.leaf + 0x3c03c1c038040340c0181c008080041002804806c0340c0181c0080ac06c))) (.node (.node (.leaf + 0x100000000010000000000130010000000010000000000010a0060700502b01b) (.leaf + 0xf201b1009030060700202b01b01303006070020200c07000000000100000000)) (.node (.leaf + 0xb0400a01201b1009030060700202b01b01303006070020200c0700b0400a071) (.leaf + 0x3c80801c07c180780900e01009030060700202b01b01303006070020200c070)))) (.node (.node (.node + (.leaf 0x10400a01201b100d0300607a29002020010400a01201b0210300607a290020) (.leaf + 0xf0060762b01b00f0700e0100d0300607a2900202)) (.node (.leaf + 0x1000000000100000000010000000000170010000000000000000000020a) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f070000))) (.node (.node (.leaf + 0x6001000000600100000000010000000000140010000000010000000010005a) (.leaf + 0x3dc0140ac06cac32c01012806c00c19002020010400a0100d03006070000)) (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0x3c900b0402b02b01b0100762b01b00f0700e01009030060700202b01b0130)))))))) (.node (.node (.node + (.node (.node (.node (.node (.leaf 0x5a0060700502b01b00f0700e01201b0260700202b01b0100702c0) + (.leaf 0xf200c0700000000010000000001000000000100000000000200100000000d0)) (.node (.leaf + 0xc04c0c0181c008080300900b0400a01009030060700202b01b01303006070020) (.leaf + 0x3c80ac0340c0181c0080ac06c04c0c0181c008080741c0240c0181c0080ac06))) (.node (.node (.leaf + 0x70000000000020a0060762b01b00f0700e0100d0300607002020010400a01) (.leaf + 0xf70020200c0700000000010000000001000000000100000000000900100000)) (.node (.leaf + 0x1303006070020200c0700b0400a071201b1009030060700202b01b013030060) (.leaf + 0xf2b01b01303006070020200c0700b0400a01201b1009030060700202b01b)))) (.node (.node (.node + (.leaf 0x80041002804806c0840c0181c008080801c07c180780900e0100903006070020) (.leaf + 0x3dd8ac06c03c1c038040340c0181c00808004100280480ac40340c0181c0080)) (.node (.leaf + 0x10000000001000000000100000000000d0010000000030000000000030a0060) (.leaf + 0x3dc03804806c0981c0b00900b0402b02b01b0100762b01b00f0700000000))) (.node (.node (.leaf + 0x100000000000a0010000000080000000000005a0060700502b01b00f0) (.leaf + 0xf1009030060700202b01b01303006070020200c070000000001000000000100)) (.node (.leaf + 0xc0181c008080741c0240c0181c0080ac06c04c0c0181c008080300900b0400a0) (.leaf + 0x3dc038040340c0181c008080041002804806c0340c0181c0080ac06c04c0))))) (.node (.node (.node + (.node (.leaf 0x10000000000110010000000030000000000010a0060700502b01b00f0) (.leaf + 0xf1009030060700202b01b01303006070020200c070000000001000000000100)) (.node (.leaf + 0xa01201b1009030060700202b01b01303006070020200c0700b0400a071201b) (.leaf + 0x3dc07c180780900e01009030060700202b01b01303006070020200c0700b04))) (.node (.node (.leaf + 0x20010400a01201b100d0300607002020010400a01201b0210300607002020200) (.leaf + 0xf0060762b01b00f0700e0100d0300607a290020)) (.node (.leaf + 0x1000000000100000000010000000000150010000000000000000000020a) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f070000)))) (.node (.node (.node (.leaf + 0x6001000000600100000000010000000000120010000000030000000010005a) (.leaf + 0x3cac06cac36c01012806c00c19002020010400a01201b100d03006070000)) (.node (.leaf + 0x2b01b0100762b01b00f0700e01009030060700202b01b0080700703006070050) (.leaf + 0x3c900b0400a01009030060700202b01b01303006070020200c0700b0402b0))) (.node (.node (.leaf + 0x2b01b01303006070020201d07009030060700202b01b01303006070020200c0) (.leaf + 0xf762b01b00f0700e0100d0300607002020010400a01202b00d0300607002)) (.node (.leaf + 0x1000000000100000000010000000000070010000000090000000000020a0060) (.leaf + 0xf400a071201b1009030060700202b01b01303006070020200c0700000000)))))) (.node (.node (.node + (.node (.node (.leaf 0x200c0700b0400a01201b1009030060700202b01b01303006070020200c0700b0) + (.leaf 0x3dc008080801c07c180780900e01009030060700202b01b01303006070020)) (.node (.leaf + 0x300607002020010400a01202b100d0300607002020010400a01201b021030060) (.leaf + 0xf0060762b01b00f0700e0100d0))) (.node (.node (.leaf + 0x10000000001000000000100000000000b0010000000050000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000)) (.node (.leaf + 0x1000000000100000000000800100000000a0000000000005a0060700502b01b) (.leaf + 0xf00a01009030060700202b01b01303006070020200c07000000000100000000)))) (.node (.node (.node + (.leaf 0x4c0c0181c008080741c0240c0181c0080ac06c04c0c0181c008080300900b04) (.leaf + 0x3c03c1c038040340c0181c008080041002804806c0340c0181c0080ac06c)) (.node (.leaf + 0x1000000000100000000000f0010000000050000000000010a0060700502b01b) (.leaf + 0xf201b1009030060700202b01b01303006070020200c07000000000100000000))) (.node (.node (.leaf + 0xb0400a01201b1009030060700202b01b01303006070020200c0700b0400a071) (.leaf + 0x3c80801c07c180780900e01009030060700202b01b01303006070020200c070)) (.node (.leaf + 0x7002020010400a01201b100d0300607002020010400a01201b02103006070020) (.leaf + 0xf0060762b01b00f0700e0100d030060))))) (.node (.node (.node (.node (.leaf + 0x1000000000100000000010000000000130010000000010000000000020a) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f070000)) (.node (.leaf + 0x6001000000600100000000010000000000100010000000050000000010005a) (.leaf + 0x3c00c19002020010402b02b01b0100762b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x400a01009030060700202b01b00807007030060700502b01b2b0eb00404a01b) (.leaf + 0xf700b0400a071201b1009030060700202b01b01303006070020200c0700b)) (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b01303006070020200c0) (.leaf + 0x3cc0181c008080801c07c180780900e01009030060700202b01b013030060)))) (.node (.node (.node + (.leaf 0x100d0300607002020010400a01202b100d0300607002020010400a01201b0210) (.leaf + 0xf0060762b01b00f0700e0)) (.node (.leaf + 0x1000000000100000000010000000000090010000000070000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000))) (.node (.node (.leaf + 0x1000000000100000000000600100000000c0000000000005a0060700502b01b) (.leaf + 0xf00a01009030060700202b01b01303006070020200c07000000000100000000)) (.node (.leaf + 0x4c0c0181c008080741c0240c0181c0080ac06c04c0c0181c008080300900b04) (.leaf + 0x3c03c1c038040340c0181c008080041002804806c0340c0181c0080ac06c))))))) (.node (.node (.node + (.node (.node (.node (.node (.leaf + 0x1000000000100000000000d0010000000070000000000010a0060700502b01b) (.leaf + 0xf201b1009030060700202b01b01303006070020200c07000000000100000000)) (.node (.leaf + 0xb0400a01201b1009030060700202b01b01303006070020200c0700b0400a071) (.leaf + 0x3c80801c07c180780900e01009030060700202b01b01303006070020200c070))) (.node (.node (.leaf + 0x7002020010400a01201b100d0300607002020010400a01201b02103006070020) (.leaf + 0xf0060762b01b00f0700e0100d030060)) (.node (.leaf + 0x1000000000100000000010000000000110010000000030000000000020a) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f070000)))) (.node (.node (.node (.leaf + 0x60010000006001000000000100000000000e0010000000070000000010005a) (.leaf + 0x3dc0140ac06cac3ec01012806c00c19002020010400a0100d03006070000)) (.node (.leaf + 0x6070020200c0700b0400a071201b1009030060700202b01b00807007030060) (.leaf + 0xf01303006070020200c0700b0400a01201b1009030060700202b01b01303))) (.node (.node (.leaf + 0x981c0b00900b0402b02b01b0100762b01b00f0700e01009030060700202b01b) (.leaf + 0x3c0181c0140ac06c03c1c03804806c)) (.node (.leaf + 0x10000000001000000000100000000000400100000000e0000000000005a) (.leaf + 0x3c80300900b0400a01009030060700202b01b01303006070020200c070000))))) (.node (.node (.node + (.node (.leaf 0x700202b01b01303006070020201d07009030060700202b01b01303006070020) (.leaf + 0xf0060700502b01b00f0700e0100d0300607002020010400a01201b00d03006)) (.node (.leaf + 0x10000000001000000000100000000000b0010000000090000000000010a) (.leaf + 0xf700b0400a071201b1009030060700202b01b01303006070020200c070000))) (.node (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b01303006070020200c0) (.leaf + 0x3cc0181c008080801c07c180780900e01009030060700202b01b013030060)) (.node (.leaf + 0x100d0300607002020010400a01201b100d0300607002020010400a01201b0210) (.leaf + 0xf0060762b01b00f0700e0)))) (.node (.node (.node (.leaf + 0x10000000001000000000100000000000f0010000000050000000000020a) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f070000)) (.node (.leaf + 0x60010000006001000000000100000000000c0010000000090000000010005a) (.leaf + 0x3cac06cac42c01012806c00c19002020010400a071201b100d03006070000))) (.node (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b0080700703006070050) (.leaf + 0xf402b02b01b0100762b01b00f0700e01009030060700202b01b013030060)) (.node (.leaf + 0xc008080300900b0400a01009030060700202b01b01303006070020200c0700b0) (.leaf + 0x3dc0080ac06c04c0c0181c008080741c0240c0181c0080ac06c04c0c0181)))))) (.node (.node (.node + (.node (.node (.leaf 0xf0060700502b01b00f0700e0100d0300607002020010400a01201b00d030060) + (.leaf 0x0)) (.node (.leaf 0x10000000001000000000100000000000900100000000b0000000000010a) + (.leaf 0xf700b0400a071201b1009030060700202b01b01303006070020200c070000))) (.node (.node + (.leaf 0x70020200c0700b0400a01201b1009030060700202b01b01303006070020200c0) (.leaf + 0x3cc0181c008080801c07c180780900e01009030060700202b01b013030060)) (.node (.leaf + 0x100d0300607002020010400a01201b100d0300607002020010400a01201b0210) (.leaf + 0xf0060762b01b00f0700e0)))) (.node (.node (.node (.leaf + 0x10000000001000000000100000000000d0010000000070000000000020a) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f070000)) (.node (.leaf + 0x60010000006001000000000100000000000a00100000000b0000000010005a) (.leaf + 0x3cac06cac46c01012806c00c19002020010400a01201b100d03006070000))) (.node (.node (.leaf + 0x2b01b0100762b01b00f0700e01009030060700202b01b0080700703006070050) (.leaf + 0xf700b0400a01009030060700202b01b01303006070020200c0700b0402b0)) (.node (.leaf + 0x20200c0700b0400a071201b1009030060700202b01b01303006070020200c0) (.leaf + 0xf3006070020200c0700b0400a01201b1009030060700202b01b0130300607))))) (.node (.node (.node + (.node (.leaf 0x4806c0840c0181c008080801c07c180780900e01009030060700202b01b0130) (.leaf + 0x3dc038040340c0181c008080041002804806c40340c0181c0080800410028)) (.node (.leaf + 0x1000000000100000000000b0010000000090000000000020a0060762b01b00f0) (.leaf + 0xf700502b01b00f0700e01201b0260762b01b00f070000000001000000000))) (.node (.node (.leaf + 0x10000006001000000000100000000000800100000000d0000000010005a0060) (.leaf + 0x3d9002020010402b02b01b0100762b01b00f0700e0100d030060700000060)) (.node (.leaf + 0xa01009030060700202b01b00807007030060700502b01b2b12b00404a01b0030) (.leaf + 0xf00b0400a071201b1009030060700202b01b01303006070020200c0700b0400)))) (.node (.node (.node + (.leaf 0x20200c0700b0400a01201b1009030060700202b01b01303006070020200c07) (.leaf + 0xf700e01201b0260762b01b00f0700e01009030060700202b01b0130300607)) (.node (.leaf + 0x100000000000600100000000f0000000010005a0060700502b01b00f0) (.leaf + 0x3c01012806c00c19002020010400a0100d03006070000006001000000600100))) (.node (.node (.leaf + 0xb0400a071201b1009030060700202b01b00807007030060700502b01b2b13b) (.leaf + 0xf200c0700b0400a01201b1009030060700202b01b01303006070020200c07)) (.node (.leaf + 0x700e01201b0260762b01b00f0700e01009030060700202b01b01303006070020) (.leaf + 0xf0060700502b01b00f0))))))) (.node (.node (.node (.node (.node (.node (.leaf + 0x6001000000600100000000010000000000040010000000110000000010015a) (.leaf + 0x3cac06cac52c01012806c00c19002020010400a071201b100d03006070000)) (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b0080700703006070050) (.leaf + 0xf700e01201b0260762b01b00f0700e01009030060700202b01b013030060))) (.node (.node (.leaf + 0x10000000000020010000000130000000010025a0060700502b01b00f0) (.leaf + 0x3e806c00c19002020010400a01201b100d03006070000006001000000600100)) (.node (.leaf + 0xb00f0700e01009030060700202b01b00807007030060700502b01b2b15b00404) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01)))) (.node (.node (.node (.leaf + 0x6001000000600100000000010000000000000010000000150000000010035a) (.leaf + 0xf700502b01b00f0700e01201b0260762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x1000000000100000000010010000000150000010000000000000010042a0060) (.leaf 0x60))) (.node + (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))))) (.node (.node (.node + (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) + (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))) (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) + (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) + (.leaf 0x0)))))) (.node (.node (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf + 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))) + (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node + (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))))) (.node (.node (.node (.node + (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf + 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))) (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node + (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf + 0x0))))))))))) + +def fuelMode4 : ℕ := 1122 +noncomputable def streamMode4 : WordRLE.BTree ℕ := + .node (.node (.node (.node (.node (.node (.leaf + 0x181d86400808054080301c02c1002804806c0240c0f40900b0401802b01b0170) (.leaf + 0x3c0181c0080ac06c0401c0f80c0)) (.node (.leaf + 0x4001000000000100000040010010000000010000010000000000000000011a) (.leaf + 0x3c0640900b0400a01009030060700202b01b01303006076190020200c070000))) (.node (.node (.leaf + 0x903006076190020201c02b01b0040400a01201b01b0700b0400a01201b01a07) (.leaf + 0xf00502b01b00f0700e0100d030060700202b01b01303006076190020201d070)) (.node (.leaf + 0x1000000000100000040010010000000050000010000000000000000010a00607) (.leaf + 0x3c0780900e01009030060700202b01b01303006076190020200c07000000000)))) (.node (.node (.node + (.leaf 0x100d0300607619002020010400a01201b0210300607619002020200761901f06) (.leaf + 0xf761900202001040250400a01201b024060230700b0400a01201b01a070220)) (.node (.leaf + 0x1c01c0c0181c0140ac06cac22c01012806c00c19002020010400a0100d030060) (.leaf + 0x3cac06c03c1c038040981c0140ac06c03c1c038040240c0181c0080ac06c020))) (.node (.node (.leaf + 0x100000000010000000000000010000000080000000000005a006070050) (.leaf + 0xf2b01b00f0700e010260700502b01b00f0700e0100d03006070000000001000)) (.node (.leaf + 0x100000000010010000000080000010000000000000000012a006070050) (.leaf + 0x3c0101002804806c0a00900b040270701a0762b01b00f070000000001000))))) (.node (.node (.node + (.node (.leaf 0x619002020200761901f06029030060700202b01b00807007030060700202b01b) (.leaf + 0xf002020010400a01202b100d0300607619002020010400a01201b0210300607)) (.node (.leaf + 0x90000010000000000000000030a0060762b01b00f0700e0100d0300607619) (.leaf + 0xf01303006076190020200c0700000000010000000001000000000100100000))) (.node (.node (.leaf + 0x81c0080ac06c04c0c0181d864008080300900b0400a01009030060700202b01b) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181d86400808004100280480ec0340c01)) (.node (.leaf + 0x1000000000100000000010010000000090000010000000000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006076190020200c070000)))) (.node (.node (.node + (.leaf 0x801d86407c180780900e01009030060700202b01b01303006076190020200c0) (.leaf + 0x3d00280480ec40340c0181d864008080041002804806c0840c0181d86400808)) (.node (.leaf + 0x10000000000000000040a0060762b01b00f0700e0100d0300607619002020010) (.leaf + 0xf762b01b00f0700000000010000000001000000000100100000000d00000))) (.node (.node (.leaf + 0x140ac06c03c1c03804806c0981c0080ac06c0401c0b00900b0402b02b01b0100) (.leaf 0x3c0181c0)) + (.node (.leaf 0x10000005001000000000100100000000a0000010000020000000000005a) (.leaf + 0x3c0300900b0400a01009030060700202b01b01303006076190020200c070000)))))) (.node (.node (.node + (.node (.node (.leaf 0xb01b01303006076190020201d07009030060700202b01b013030060761900202) + (.leaf 0xf2b01b00f0700e0100d0300607619002020010400a01202b00d030060700202)) (.node (.leaf + 0x100000000010010000000110000010000000000000000020a006076) (.leaf + 0xf71201b1009030060700202b01b01303006076190020200c070000000001))) (.node (.node (.leaf + 0xb0400a01201b1009030060700202b01b01303006076190020200c0700b0400a0) (.leaf + 0xf6407c180780900e01009030060700202b01b01303006076190020200c0700)) (.node (.leaf + 0x80480ac40340c0181d864008080041002804806c0840c0181d864008080801d8) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181d864008080041002)))) (.node (.node (.node (.leaf + 0x1000000000100000000010010000000150000010000000000000000030a) (.leaf + 0x3c03c1c03804806c0981c0b00900b0402b02b01b0100762b01b00f070000)) (.node (.leaf + 0x100000000010010000000120000010000010000000000005a0060700502b01b) (.leaf + 0xf1009030060700202b01b01303006076190020200c07000000000100000050))) (.node (.node (.leaf + 0x864008080741c0240c0181c0080ac06c04c0c0181d864008080300900b0400a0) (.leaf + 0x3c0340c0181d864008080041002804806c0340c0181c0080ac06c04c0c0181d)) (.node (.leaf + 0x10010000000190000010000000000000000010a0060700502b01b00f0700e01) (.leaf + 0xf700202b01b01303006076190020200c070000000001000000000100000000))))) (.node (.node (.node + (.node (.leaf 0x30060700202b01b01303006076190020200c0700b0400a071201b1009030060) (.leaf + 0xf1009030060700202b01b01303006076190020200c0700b0400a01201b1009)) (.node (.leaf + 0x1d864008080041002804806c0840c0181d864008080801d86407c180780900e0) (.leaf + 0xf0060700502b01b2b1db00404a01b003064008080041002804806c40340c018))) (.node (.node (.leaf + 0x20200c0700b0402a0762b01b00f0700e01009030060700202b01b0080700703) (.leaf + 0xf20010400a01201b00d030060700202012030060700202b01b01303006070)) (.node (.leaf + 0x201203006070020201102b01b0100700502b01b00f0700e0100d03006070020) (.leaf + 0xf20010400a01201b100d0300607002020010400a071201b00d0300607002)))) (.node (.node (.node + (.leaf 0x80010000000160000000000020a0060762b01b00f0700e0100d03006070020) (.leaf + 0xf00f0700e0100d0300607000000000100000000010000000001000000000)) (.node (.leaf + 0x1000000000100100000001d0000010000000000000000020a0060762b01b) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01b00f07000000000100000))) (.node (.node (.leaf + 0x50010000005001000000000100100000001a0000010000000000000010005a) (.leaf 0x0)) (.node (.leaf + 0x0) (.leaf 0x0)))))) + +def fuelMode5 : ℕ := 3527 +noncomputable def streamMode5 : WordRLE.BTree ℕ := + .node (.node (.node (.node (.node (.node (.node (.leaf + 0x81c0080ac06c0201c01c0c0181c0080ac06c0101002804806c0a00900b0402f0) (.leaf + 0x3c40340c0181d864008080041002804806c0340c0181d864008080480c01)) (.node (.leaf + 0x806c00c190020201203006076190020201102b01b0100700502b01b00f0700e0) (.leaf + 0x3dc4806c0240c0181c0080ac06c0201c01c0c0181c0140ac06cac1ac01012))) (.node (.node (.leaf + 0x700b0400a01201b009030060700202b01b01303006070020200c0700b0400a0) (.leaf + 0xf0210300607002020200701f06029030060700202b01b01303006070020200c)) (.node (.leaf + 0x10a0060700502b01b00f0700e0100d0300607002020010400a01201b) (.leaf + 0xf00607000000000100000000010000000001000000000006001000000001000)))) (.node (.node (.node + (.leaf 0xc01c0c0181c0140ac06cac1ec01012806c00c19002020010400a071201b00d03) (.leaf + 0x3c04c0c0181c008080301c02c1002804806c40240c0181c0080ac06c0201)) (.node (.leaf + 0x1b009030060700202b01b02e0700502b01b00f0700e01009030060700202b01b) (.leaf + 0xf20200701f06029030060700202b01b01303006070020200c0700b0400a0120))) (.node (.node (.leaf + 0x700502b01b00f0700e0100d0300607002020010400a01201b02103006070020) (.leaf 0xf006)) (.node + (.leaf 0x1000000000100000000010000000000070010000000020000000000010a) (.leaf + 0x3cac06cac22c01012806c00c19002020010400a01201b100d03006070000))))) (.node (.node (.node + (.node (.leaf 0xb0402a0762b01b00f0700e01009030060700202b01b0080700703006070050) (.leaf + 0xf1201b00d030060700202012030060700202b01b01303006070020200c07)) (.node (.leaf + 0x70020201102b01b0100700502b01b00f0700e0100d0300607002020010400a0) (.leaf + 0xf1201b100d0300607002020010400a071201b00d03006070020201203006))) (.node (.node (.leaf + 0x10000000000020a0060762b01b00f0700e0100d0300607002020010400a0) (.leaf + 0xf100d03006070000000001000000000100000000010000000000080010000)) (.node (.leaf + 0x10010000000080000010000000000000000020a0060762b01b00f0700e0) (.leaf + 0xf30060700202b01b01303006076190020200c07000000000100000000010000)))) (.node (.node (.node + (.leaf 0x140ac06c0c00c0181c0080ac06c04c0c0181d864008080300900b0400a010090) (.leaf + 0x3c0340c0181d864008080480c0181d864008080c41c02c1002804806c0681c0)) (.node (.leaf + 0x1102b01b0100700502b01b00f0700e0100d0300607619002020010400a01201b) (.leaf + 0x3dc0080ac06c0201c01c0c0181c0140ac06cac22c01012806c00c19002020))) (.node (.node (.leaf + 0xb01303006070020201d07009030060700202b01b013030060700202012030060) (.leaf + 0xf0210300607002020200701f06029030060700202b01b013030060700202b01)) (.node (.leaf + 0x10a0060700502b01b00f0700e0100d0300607002020010400a01201b) (.leaf + 0xf00607000000000100000000010000000001000000000007001000000003000)))))) (.node (.node (.node + (.node (.node (.leaf 0x1c0080ac06c0201c01c0c0181c0140ac06cac26c01012806c00c190020201203) + (.leaf 0x3cc0181c0080ac06c04c0c0181c008080301c02c100281c4806c0240c018)) (.node (.leaf + 0x701f06029030060700202b01b01303006070020200c0700b0400a01201b0090) (.leaf + 0xf2b01b00f0700e0100d0300607002020010400a01201b021030060700202020))) (.node (.node (.leaf + 0x100000000010000000000060010000000040000000000010a006070050) (.leaf + 0x3ec2ac01012806c00c19002020010400a071201b00d03006070000000001000)) (.node (.leaf + 0xc0700b0400a01201b1009030060700202b01b00807007030060700502b01b2) (.leaf + 0xfb01b02e0700502b01b00f0700e01009030060700202b01b013030060700202)))) (.node (.node (.node + (.leaf 0x30060700202b01b01303006070020200c0700b0400a01201b009030060700202) (.leaf + 0xf100d0300607002020010400a01201b0210300607002020200701f060290)) (.node (.leaf + 0x10000000000070010000000050000000000010a0060700502b01b00f0700e0) (.leaf + 0x3d9002020010400a01201b100d0300607000000000100000000010000000))) (.node (.node (.leaf + 0xe01009030060700202b01b00807007030060700502b01b2b0bb00404a01b0030) (.leaf + 0xf012030060700202b01b01303006070020200c0700b0402a0762b01b00f0700)) (.node (.leaf + 0x700502b01b00f0700e0100d0300607002020010400a01201b00d030060700202) (.leaf + 0xf20010400a071201b00d03006070020201203006070020201102b01b0100))))) (.node (.node (.node + (.node (.leaf 0x60762b01b00f0700e0100d0300607002020010400a01201b100d03006070020) (.leaf + 0xf0)) (.node (.leaf 0x1000000000100000000010000000000080010000000040000000000020a) (.leaf + 0xf0060762b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x10000000001000000000100100000000b0000010000000000000000020a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006076190020200c070000)) (.node (.leaf + 0x801d86407c180780900e01009030060700202b01b01303006076190020200c0) (.leaf + 0x3d8ac06c0c8040340c0181d864008080041002804806c0840c0181d86400808)))) (.node (.node (.node + (.leaf 0x1c0140ac06cac26c01012806c00c1900202001040330700b0400a01201b01a07) (.leaf + 0x3cc0181c008080301c02c10028040240c0181c0080ac06c0201c01c0c018)) (.node (.leaf + 0x202b01b01303006070020200c0700b0400a01201b009030060700202b01b0130) (.leaf + 0xf300607002020010400a01201b0210300607002020200701f06029030060700))) (.node (.node (.leaf + 0x60010000000040000000000020a0060762b01b00f0700e01201b100d0) (.leaf + 0x3d9002020010400a0100d03006070000000001000000000100000000010000)) (.node (.leaf + 0x1b1009030060700202b01b00807007030060700502b01b2b0ab00404a01b0030) (.leaf + 0xf00f0700e01009030060700202b01b01303006070020200c0700b0400a0120))))))) (.node (.node (.node + (.node (.node (.node (.node (.leaf + 0xc0700b0400a01201b009030060700202b02b02e0700202b01b0100700502b01b) (.leaf + 0xf0210300607002020200701f06029030060700202b01b01303006070020200)) (.node (.leaf + 0x10a0060700502b01b00f0700e0100d0300607002020010400a01201b) (.leaf + 0xf00607000000000100000000010000000001000000000007001000000006000))) (.node (.node (.leaf + 0xc01c0c0181c0140ac06cac2ec01012806c00c19002020010400a01201b100d03) (.leaf + 0x3dc02c100ac0ac06c0401d8ac06c03c1c038040240c0181c0080ac06c0201)) (.node (.leaf + 0x700202b01b013030060700202012030060700202b01b01303006070020200c0) (.leaf + 0xf30060700202b01b013030060700202b01b01303006070020201d0700903006)))) (.node (.node (.node + (.leaf 0x700e0100d0300607002020010400a01201b0210300607002020200701f060290) (.leaf + 0xf0060700502b01b00f0)) (.node (.leaf + 0x1000000000100000000010000000000090010000000050000000000010a) (.leaf + 0x3c00c19002020010402b02b01b0100762b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x400a01009030060700202b01b00807007030060700502b01b2b0cb00404a01b) (.leaf + 0xf00c0700b0400a071201b009030060700202b01b01303006070020200c0700b)) (.node (.leaf + 0x3006070020200c0700b0400a01201b009030060700202b01b013030060700202) (.leaf + 0xf0010400a01201b0210300607002020200701f06029030060700202b01b0130))))) (.node (.node (.node + (.node (.leaf 0x10000000060000000000010a0060700502b01b00f0700e0100d030060700202) (.leaf + 0xf400a0100d03006070000000001000000000100000000010000000000080)) (.node (.leaf + 0x81c0080ac06c0201c01c0c0181c0140ac06cac36c01012806c00c19002020010) (.leaf + 0x3cc0181c0080ac06c04c0c0181c008080301c02c100281c4806c40240c01))) (.node (.node (.leaf + 0x700e01009030060700202b01b01303006070020200c0700b0400a01201b10090) (.leaf + 0xf70020200c0700b0400a01201b009030060700202b01b02e0700502b01b00f0)) (.node (.leaf + 0x400a01201b0210300607002020200701f06029030060700202b01b013030060) (.leaf + 0xf0060700502b01b00f0700e0100d030060700202001)))) (.node (.node (.node (.leaf + 0x1000000000100000000010000000000090010000000070000000000010a) (.leaf + 0x3cac06cac3ac01012806c00c19002020010400a071201b100d03006070000)) (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b0080700703006070050) (.leaf + 0xf200c0700b0402a0762b01b00f0700e01009030060700202b01b013030060))) (.node (.node (.leaf + 0x20010400a01201b00d030060700202012030060700202b01b01303006070020) (.leaf + 0xf201203006070020201102b01b0100700502b01b00f0700e0100d0300607002)) (.node (.leaf + 0x2020010400a01201b100d0300607002020010400a071201b00d03006070020) (.leaf + 0xf0060762b01b00f0700e0100d0300607)))))) (.node (.node (.node (.node (.node (.leaf + 0x10000000001000000000100000000000a0010000000060000000000020a) (.leaf + 0x3cac06cac3ec01012806c00c19002020010400a01201b100d03006070000)) (.node (.leaf + 0xb0402a0762b01b00f0700e01009030060700202b01b0080700703006070050) (.leaf + 0xf70020200c0700b0400a01009030060700202b01b01303006070020200c07))) (.node (.node (.leaf + 0xd0000000000004a0060700202b01b02d030060700202b01b013030060) (.leaf + 0xf700e0100d03006070000000001000000000100000000010000000000040010)) (.node (.leaf + 0x1000000000100100000000f0000010000000000000000030a0060762b01b00f0) (.leaf + 0x3c0101002804806c0a00900b040340762b01b00f070000000001000000000)))) (.node (.node (.node + (.leaf 0x4a0060700202b01b02d030060700202b01b00807007030060700202b01b) (.leaf + 0xf70000000001000000500100000000010010000000080000010000000000000)) (.node (.leaf + 0x864008080300900b0400a01009030060700202b01b01303006076190020200c0) (.leaf + 0x3c0340c0181d864008080041002804806c0340c0181c0080ac06c04c0c0181d))) (.node (.node (.leaf + 0x402b02b01b0100762b01b00f0700e0100d0300607619002020010400a01201b1) (.leaf + 0x3cac06cac3ac01012806c00c19002020010400a0100d0300607619002020010)) (.node (.leaf + 0x20200c0700b0400a071201b1009030060700202b01b0080700703006070050) (.leaf + 0xf3006070020200c0700b0400a01201b1009030060700202b01b0130300607))))) (.node (.node (.node + (.node (.leaf 0x9030060700202b01b02e0700502b01b00f0700e01009030060700202b01b0130) (.leaf + 0xf701f06029030060700202b01b01303006070020200c0700b0400a01201b00)) (.node (.leaf + 0x2b01b00f0700e0100d0300607002020010400a01201b0210300607002020200) (.leaf 0xf00607005))) + (.node (.node (.leaf 0x1000000000100000000010000000000090010000000080000000000010a) (.leaf + 0x3cac06cac3ec01012806c00c19002020010400a071201b100d03006070000)) (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b0080700703006070050) (.leaf + 0xf200c0700b0402a0762b01b00f0700e01009030060700202b01b013030060)))) (.node (.node (.node + (.leaf 0x20010400a01201b00d030060700202012030060700202b01b01303006070020) (.leaf + 0xf201203006070020201102b01b0100700502b01b00f0700e0100d0300607002)) (.node (.leaf + 0x2020010400a01201b100d0300607002020010400a071201b00d03006070020) (.leaf + 0xf0060762b01b00f0700e0100d0300607))) (.node (.node (.leaf + 0x10000000001000000000100000000000a0010000000070000000000020a) (.leaf + 0x3cac06cac42c01012806c00c19002020010400a01201b100d03006070000)) (.node (.leaf + 0xb0402a0762b01b00f0700e01009030060700202b01b0080700703006070050) (.leaf + 0xf70020200c0700b0400a01009030060700202b01b01303006070020200c07))))))) (.node (.node (.node + (.node (.node (.node (.leaf 0xe0000000000004a0060700202b01b02d030060700202b01b013030060) + (.leaf 0xf700e0100d03006070000000001000000000100000000010000000000040010)) (.node (.leaf + 0x100000000010010000000100000010000000000000000030a0060762b01b00f0) (.leaf + 0xf1009030060700202b01b01303006076190020200c070000000001000000000))) (.node (.node (.leaf + 0x80900e01009030060700202b01b01303006076190020200c0700b0400a01201b) (.leaf + 0x3cc0181d864008080041002804806c0840c0181d864008080801d86407c1807)) (.node (.leaf + 0x1c01c0c0181c0140ac06cac3ec01012806c00c19002020010400a01201b100d0) (.leaf + 0x3ec06c04c0c0181c008080301c02c1002804806c40240c0181c0080ac06c020)))) (.node (.node (.node + (.leaf 0x6070020200c0700b0402b02b01b0100762b01b00f0700e01009030060700202) (.leaf + 0xf7009030060700202b01b013030060700202012030060700202b01b013030)) (.node (.leaf + 0x701f06029030060700202b01b013030060700202b01b01303006070020201d0) (.leaf + 0xf2b01b00f0700e0100d0300607002020010400a01201b021030060700202020))) (.node (.node (.leaf + 0x1000000000100000000000b0010000000080000000000010a006070050) (.leaf + 0x3ec42c01012806c00c19002020010400a01201b100d03006070000000001000)) (.node (.leaf + 0x100762b01b00f0700e01009030060700202b01b00807007030060700502b01b2) (.leaf + 0xf400a01009030060700202b01b01303006070020200c0700b0402b02b01b0))))) (.node (.node (.node + (.node (.leaf 0x200c0700b0400a071201b009030060700202b01b01303006070020200c0700b0) (.leaf + 0xf006070020200c0700b0400a01201b009030060700202b01b01303006070020)) (.node (.leaf + 0x20010400a01201b0210300607002020200701f06029030060700202b01b01303) (.leaf + 0xf0060700502b01b00f0700e0100d03006070020))) (.node (.node (.leaf + 0x10000000001000000000100000000000a0010000000090000000000010a) (.leaf + 0x3c00c19002020010402b02b01b0100762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x400a01009030060700202b01b00807007030060700502b01b2b11b00404a01b) (.leaf + 0xf700b0400a071201b1009030060700202b01b01303006070020200c0700b)))) (.node (.node (.node + (.leaf 0x70020200c0700b0400a01201b1009030060700202b01b01303006070020200c0) (.leaf + 0xf700202b01b02e0700502b01b00f0700e01009030060700202b01b013030060)) (.node (.leaf + 0x6029030060700202b01b01303006070020200c0700b0400a01201b009030060) (.leaf + 0xf00f0700e0100d0300607002020010400a01201b0210300607002020200701f))) (.node (.node (.leaf + 0x1000000000100000000000b00100000000a0000000000010a0060700502b01b) (.leaf + 0x3ec4ac01012806c00c19002020010400a0100d0300607000000000100000000)) (.node (.leaf + 0xc0700b0400a071201b1009030060700202b01b00807007030060700502b01b2) (.leaf + 0xf70020200c0700b0400a01201b1009030060700202b01b0130300607002020)))))) (.node (.node (.node + (.node (.node (.leaf 0x20200c0700b0402a0762b01b00f0700e01009030060700202b01b013030060) + (.leaf 0xf20010400a01201b00d030060700202012030060700202b01b0130300607)) (.node (.leaf + 0x201203006070020201102b01b0100700502b01b00f0700e0100d03006070020) (.leaf + 0xf20010400a01201b100d0300607002020010400a071201b00d0300607002))) (.node (.node (.leaf + 0xc0010000000090000000000020a0060762b01b00f0700e0100d03006070020) (.leaf + 0xf400a071201b100d0300607000000000100000000010000000001000000000)) (.node (.leaf + 0x81c0080ac06c0201c01c0c0181c0140ac06cac4ec01012806c00c19002020010) (.leaf + 0x3c0240c0181c0080ac06c04c0c0181c008080301c02c1002804806c40240c01)))) (.node (.node (.node + (.leaf 0x9030060700202b01b01303006070020200c0700b0402a0762b01b00f0700e01) (.leaf + 0xf700202b01b02d030060700202b01b01303006070020200c0700b0400a010)) (.node (.leaf + 0x1000000000100000000010000000000060010000000100000000000004a0060) (.leaf + 0x3ec06cac52c01012806c00c19002020010400a01201b100d030060700000000))) (.node (.node (.leaf + 0xb0402a0762b01b00f0700e01009030060700202b01b00807007030060700502) (.leaf + 0xf70020200c0700b0400a01009030060700202b01b01303006070020200c070)) (.node (.leaf + 0x14a006070160601502b01b01401009030060700202b01b013030060) (.leaf + 0xf30060700000000010000000001000000000100000000000400100000001200))))) (.node (.node (.node + (.node (.leaf 0x10010000000140000010000000000000000040a0060762b01b00f0700e0100d0) (.leaf + 0xf0060700202b01b0350762b01b00f0700000000010000000001000000000)) (.node (.leaf + 0x50010000005001000000000100100000000c0000010000000000000010006a) (.leaf 0x0))) (.node + (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))) (.node (.node (.node + (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf + 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))))))) + +def fuelMode6 : ℕ := 6592 +noncomputable def streamMode6 : WordRLE.BTree ℕ := + .node (.node (.node (.node (.node (.node (.node (.node (.leaf + 0x6c0201c01c0c0181c0080ac06c010100281c4806c0a00900b0403702b02b0170) (.leaf + 0x3cac06c0101002804806c06c1c02c1002804806c0681c0e00c0181c0080ac0)) (.node (.leaf + 0xd030060700202b01b01303006076190020201d0700903006076190020201c0) (.leaf + 0xf0060700502b01b00f0700e01))) (.node (.node (.leaf + 0x1000000000100000040010010000000050000010000000000000000010a) (.leaf + 0x3c0300900b0400a01009030060700202b01b01303006076190020200c070000)) (.node (.leaf + 0xc0700b0400a01201b0090300607038030060700202b01b013030060761900202) (.leaf + 0xf201d0700903006076190020201c02b03b02e0700202b01b010070020200)))) (.node (.node (.node + (.leaf 0x2b01b01303006076190020201d07009030060700202b01b01303006076190020) (.leaf + 0x3cc0181c0140ac06cac2ac01012806c00c190020201d0700903006070020)) (.node (.leaf + 0x400a01201b0210300607002020200701f06029030060700202b01b008070070) (.leaf + 0xfb01b00f0700e0100d0300607002020010400a01202b100d030060700202001))) (.node (.node (.leaf + 0x100000000010000000000030010000000060000000000030a0060762) (.leaf + 0xf00d030060700202b01b013030060700202b01b013030060700000000010)) (.node (.leaf + 0x100000000c0000010000000000000000010a0060700502b01b00f0700e01201b) (.leaf + 0xf2b01b01303006076190020200c0700000000010000000001000000000100))))) (.node (.node (.node + (.node (.leaf 0x60700202b01b01303006076190020200c0700b0400a01201b100903006070020) (.leaf + 0x3d002804806c0840c0181d864008080801d86407c180780900e010090300)) (.node (.leaf + 0x6060150200c0700b0400a01201b00903006070220100d0300607619002020010) (.leaf + 0x3cac26c01012806c00c19002020010401802b02b02e0700202b01b0100701))) (.node (.node (.leaf + 0x70020200c0700b0400a01009030060700202b01b00807007030060700502b01b) (.leaf + 0xf00a01201b0210300607002020200701f06029030060700202b01b013030060)) (.node (.leaf + 0x16060150200c0700b0400a01201b00903006070220100d03006070020200104) (.leaf + 0xf20010400a0100d0300607002020010401802b02b02e0700202b01b01007)))) (.node (.node (.node + (.leaf 0x7002020120300607002020390701a0700502b01b00f0700e0100d03006070020) (.leaf + 0xf0100700502b01b00f0700e0100d0300607002020010400a01201b00d030060)) (.node (.leaf + 0x1c0c0181c0140ac32c01012806c00c29002020120300607a290020201102b01b) (.leaf + 0x3c04c0c0181c008080301c02c100281c4806c0240c0181c0080ac06c0201c0))) (.node (.node (.leaf + 0x700202b01b01303006070020200c0700b0400a01201b009030060700202b01b) (.leaf + 0xf00d0300607002020010400a01201b0210300607002020200701f0602903006)) (.node (.leaf + 0x30060700202001040250400a01201b024060230700b0400a01201b01a0702201) (.leaf + 0xf700e010260700502b01b00f0700e0100d0300607002020010400a0100d0)))))) (.node (.node (.node + (.node (.node (.leaf 0x10000000000080000000000040000000000012a0060700502b01b00f0) (.leaf + 0x3e806c00c29002020010400a071201b00d03006070000000001000000000100)) (.node (.leaf + 0x700b0400a01201b1009030060700202b01b00807007030060700502b0db00404) (.leaf + 0xf01a0700502b01b00f0700e01009030060700202b01b01303006070020200c0))) (.node (.node (.leaf + 0x6029030060700202b01b00807007030060700202b01b0040400a01201b03a07) (.leaf + 0xf00a01202b100d0300607002020010400a01201b0210300607002020200701f)) (.node (.leaf + 0x70000000000030a0060762b01b00f0700e0100d03006070020200104) (.leaf + 0xf1201b100d0300607000000000100000000010000000001000000000007000)))) (.node (.node (.node + (.leaf 0x81c0080ac06c0201c01c0c0181c0140ac3ac01012806c00c29002020010400a0) (.leaf + 0x3c04c0c0181c008080301c02c1009c1c0681d8ac06c03c1c038040240c01)) (.node (.leaf + 0x400a01203b00d030060700202b01b013030060700202012030060700202b01b) (.leaf + 0xf0060762b01b00f0700e0100d030060700202001))) (.node (.node (.leaf + 0x10000000001000000000100000000000500000000000a0000000000030a) (.leaf + 0x3d2806c00c2900202001040270701a0762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x200c0700b0400a01009030060700202b01b00807007030060700502b0fb0040) (.leaf + 0xf3006070020200c0700b0400a01201b009030060700202b01b0130300607002))))) (.node (.node (.node + (.node (.leaf 0x20010400a01201b0210300607002020200701f06029030060700202b01b0130) (.leaf + 0xf762b01b00f0700e0100d0300607002020010400a01203b100d0300607002)) (.node (.leaf + 0x1000000000100000000010000000000070000000000080000000000040a0060) (.leaf + 0x3c0181c0140ac42c01012806c00c29002020010400a0100d030060700000000))) (.node (.node (.leaf + 0x1303006070020200c0700b0400a01201b1009030060700202b01b0080700703) (.leaf + 0xf2b01b0100700202b01b0100700502b01b00f0700e01009030060700202b01b)) (.node (.leaf + 0x20000000000100000000000005a0060700502b01b00f0700e01201b026070020) (.leaf + 0xf400a01201b100d030060700000000010000000001000000000100000000000)))) (.node (.node (.node + (.leaf 0x40c0181c0080ac06c0201c01c0c0181c0140ac46c01012806c00c29002020010) (.leaf + 0x3ec06c04c0c0181c008080301c02c100ac0ac06c0401d8ac06c03c1c0380402)) (.node (.leaf + 0x6070020201d07009030060700202b01b013030060700202012030060700202) (.leaf + 0xf700e0100d0300607002020010400a01202b00d030060700202b01b01303))) (.node (.node (.leaf + 0x1000000000100000000000700000000000c0000000000020a0060762b01b00f0) (.leaf + 0xf402b02b01b0100762b01b00f0700e0100d03006070000000001000000000)) (.node (.leaf + 0x40c0181c0080ac06c0201c01c0c0181c0140ac4ac01012806c00c29002020010) (.leaf + 0x3c0281c4806c0240c0181c0080ac06c04c0c0181c008080301c02c100280402))))))) (.node (.node + (.node (.node (.node (.node (.node (.leaf + 0x200c0700b0400a01201b009030060700202b01b01303006070020200c0700b04) (.leaf + 0xf201b0210300607002020200701f06029030060700202b01b01303006070020)) (.node (.leaf + 0xf0700e0100d0300607002020010400a01202b100d0300607002020010400a01) (.leaf 0xf0060762b01b0))) + (.node (.node (.leaf 0x10000000001000000000100000000000900000000000a0000000000030a) (.leaf + 0x3cc0181c0140ac4ec01012806c00c29002020010400a0100d03006070000)) (.node (.leaf + 0x1303006070020200c0700b0400a071201b1009030060700202b01b008070070) (.leaf + 0xf2b01b01303006070020200c0700b0400a01201b1009030060700202b01b)))) (.node (.node (.node + (.leaf 0xf0700e01201b0260700202b01b0100700502b01b00f0700e0100903006070020) (.leaf + 0xf0060700502b01b00)) (.node (.leaf + 0x1000000000100000000010000000000040000000000110000000000005a) (.leaf + 0x3dc0140ac52c01012806c00c29002020010400a071201b100d03006070000))) (.node (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xf700b0402b02b01b0100762b01b00f0700e01009030060700202b01b0130)) (.node (.leaf + 0x700202b01b013030060700202012030060700202b01b01303006070020200c0) (.leaf + 0xf20010400a01201b00d030060700202b01b01303006070020201d0700903006))))) (.node (.node (.node + (.node (.leaf 0xe0000000000010a0060700502b01b00f0700e0100d03006070020) (.leaf + 0xf00a01201b100d0300607000000000100000000010000000001000000000009)) (.node (.leaf + 0xc0181c0080ac06c0201c01c0c0181c0140ac56c01012806c00c290020200104) (.leaf + 0x3c04c0c0181c008080301c02c100ac0ac06c0401d8ac06c03c1c03804024))) (.node (.node (.leaf + 0x30060700202b01b01303006070020200c0700b0400a01009030060700202b01b) (.leaf + 0xf201b009030060700202b01b01303006070020200c0700b0400a071201b0090)) (.node (.leaf + 0x2020200701f06029030060700202b01b01303006070020200c0700b0400a01) (.leaf + 0xf7002020010400a01201b100d0300607002020010400a01201b0210300607)))) (.node (.node (.node + (.leaf 0xb00000000000c0000000000020a0060762b01b00f0700e0100d030060) (.leaf + 0xf762b01b00f0700e0100d03006070000000001000000000100000000010000)) (.node (.leaf + 0x6c0201c01c0c0181c0140ac5ac01012806c00c29002020010402b02b01b0100) (.leaf + 0x3cc0181c0080ac06c04c0c0181c008080301c02c10028040240c0181c0080ac))) (.node (.node (.leaf + 0x201b1009030060700202b01b01303006070020200c0700b0400a071201b10090) (.leaf + 0xf00f0700e01009030060700202b01b01303006070020200c0700b0400a01)) (.node (.leaf + 0x120000000000005a0060700502b01b00f0700e01201b0260700502b01b) (.leaf + 0xf400a0100d03006070000000001000000000100000000010000000000060000)))))) (.node (.node (.node + (.node (.node (.leaf 0x40c0181c0080ac06c0201c01c0c0181c0140ac5ec01012806c00c29002020010) + (.leaf 0x3c40240c0181c0080ac06c04c0c0181c008080301c02c100281c4806c402)) (.node (.leaf + 0xb00f0700e01009030060700202b01b01303006070020200c0700b0400a01201b) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01))) (.node (.node (.leaf + 0x1000000000100000000010000000000040000000000140000000000015a) (.leaf + 0x3dc0140ac62c01012806c00c29002020010400a071201b100d03006070000)) (.node (.leaf + 0x3006070020200c0700b0400a01201b1009030060700202b01b00807007030060) (.leaf + 0xfb01b00f0700e01201b0260762b01b00f0700e01009030060700202b01b0130)))) (.node (.node (.node + (.leaf 0x100000000010000000000020000000000160000000000025a0060700502) (.leaf + 0x3c01012806c00c29002020010400a01201b100d030060700000000010000)) (.node (.leaf + 0x260762b01b00f0700e01009030060700202b01b00807007030060700502b19b) (.leaf + 0xf0060700502b01b00f0700e01201b))) (.node (.node (.leaf + 0x1000000000100000000010000000000000000000000180000000000035a) (.leaf + 0xf700502b01b00f0700e01201b0260762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x1000000000100000000010000000000180010000000000000000000042a0060) (.leaf + 0x3c0140ac06cac2ac01012806c00c19002020010400a0100d030060700000000))))) (.node (.node (.node + (.node (.leaf 0xb03a0701a0700502b01b00f0700e01009030060700202b01b008070070300607) (.leaf + 0xf701f06029030060700202b01b00807007030060700202b01b0040400a01201)) (.node (.leaf + 0x1201b01a070220100d0300607002020010400a01201b0210300607002020200) (.leaf + 0xf0010400a0100d030060700202001040250400a01201b024060230700b0400a))) (.node (.node (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d030060700202) (.leaf 0x0)) (.node + (.leaf 0x1000000000100000000010000000000060010000000050000000000012a) (.leaf + 0x3d2806c00c19002020390701a0700502b01b00f0700e0100d03006070000)))) (.node (.node (.node + (.leaf 0x30060700202012030060700202b01b00807007030060700502b01b2b0bb0040) (.leaf + 0xf024060230700b0400a01201b01a0702201201b00d030060700202b01b013)) (.node (.leaf + 0xe0100d0300607002020010400a0100d030060700202001040250400a01201b) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f07))) (.node (.node (.leaf + 0x1000000000100000000010000000000040010000000080000000000012a) (.leaf + 0x3dc01c0c0181c0140ac06cac32c01012806c00c190020201203006070000)) (.node (.leaf + 0x202b01b01303006070020200c0700b0400a01201b009030060700202b01b0080) (.leaf + 0xf300607002020010400a01201b0210300607002020200701f06029030060700))))))) (.node (.node + (.node (.node (.node (.node (.leaf + 0x2001040250400a01201b024060230700b0400a01201b01a0702201201b100d0) (.leaf + 0xf10260762b01b00f0700e0100d0300607002020010400a0100d0300607002)) (.node (.leaf + 0x10000000000060010000000060000000000022a0060700502b01b00f0700e0) (.leaf + 0x3c00c19002020010400a01201b00d0300607000000000100000000010000000))) (.node (.node (.leaf + 0x700e01009030060700202b01b00807007030060700502b01b2b0db00404a01b) (.leaf + 0xf700202b02b0040400a01201b03a0701a0700202b01b0100700502b01b00f)) (.node (.leaf + 0x1201b0210300607002020200701f06029030060700202b01b00807007030060) (.leaf + 0xf700e0100d0300607002020010400a01202b100d0300607002020010400a)))) (.node (.node (.node + (.leaf 0x1000000000100000000000500100000000a0000000000030a0060762b01b00f0) (.leaf + 0xf01102b01b0100700502b01b00f0700e0100d03006070000000001000000000)) (.node (.leaf + 0xc0181c0080ac06c0201c01c0c0181c0140ac06cac3ac01012806c00c1900202) (.leaf + 0x3ec06c04c0c0181c008080741c0240c0181c0080ac06c04c0c0181c00808048))) (.node (.node (.leaf + 0x201c02b01b0040400a01201b01b0700b0400a01201b01a07038030060700202) (.leaf + 0xf00f0700e0100d030060700202b01b01303006070020201d070090300607002)) (.node (.leaf + 0x1000000000100000000000700100000000a0000000000010a0060700502b01b) (.leaf + 0x3c0140ac06cac3ec01012806c00c19002020120300607000000000100000000))))) (.node (.node (.node + (.node (.leaf 0x6070020200c0700b0400a071201b009030060700202b01b008070070300607) (.leaf + 0xfb01b01303006070020200c0700b0400a01201b009030060700202b01b01303)) (.node (.leaf + 0x607002020010400a01201b0210300607002020200701f06029030060700202) (.leaf + 0xf2001040250400a01201b024060230700b0400a01201b01a070220100d03))) (.node (.node (.leaf + 0x10260700502b01b00f0700e0100d0300607002020010400a0100d03006070020) (.leaf + 0xf0060700502b01b00f0700e0)) (.node (.leaf + 0x1000000000100000000010000000000080010000000080000000000012a) (.leaf + 0x3cac06cac42c01012806c00c19002020010400a071201b00d03006070000)))) (.node (.node (.node + (.leaf 0x70020200c0700b0400a01201b1009030060700202b01b0080700703006070050) (.leaf + 0xf1201b03a0701a0700502b01b00f0700e01009030060700202b01b013030060)) (.node (.leaf + 0x20200701f06029030060700202b01b00807007030060700202b01b0040400a0) (.leaf + 0xf002020010400a01202b100d0300607002020010400a01201b0210300607002))) (.node (.node (.leaf + 0x700100000000b0000000000030a0060762b01b00f0700e0100d0300607) (.leaf + 0xf20010400a01201b100d030060700000000010000000001000000000100000)) (.node (.leaf + 0x40c0181c0080ac06c0201c01c0c0181c0140ac06cac46c01012806c00c190020) (.leaf + 0x3cac06c04c0c0181c008080301c02c1009c1c0681d8ac06c03c1c0380402)))))) (.node (.node (.node + (.node (.node (.leaf 0x20010400a01203b00d030060700202b01b01303006070020201203006070020) + (.leaf 0xf0060762b01b00f0700e0100d0300607002)) (.node (.leaf + 0x10000000001000000000100000000000500100000000e0000000000030a) (.leaf + 0x3d2806c00c1900202001040270701a0762b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x700b0400a01009030060700202b01b00807007030060700502b01b2b12b0040) (.leaf + 0xf70020200c0700b0400a01201b009030060700202b01b01303006070020200c)) (.node (.leaf + 0x400a01201b0210300607002020200701f06029030060700202b01b013030060) (.leaf + 0xfb01b00f0700e0100d0300607002020010400a01203b100d030060700202001)))) (.node (.node (.node + (.leaf 0x1000000000100000000000700100000000c0000000000040a0060762) (.leaf + 0x3cac06cac4ec01012806c00c19002020010400a0100d030060700000000010)) (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b0080700703006070050) (.leaf + 0xf700202b01b0100700502b01b00f0700e01009030060700202b01b013030060))) (.node (.node (.leaf + 0x140000000000005a0060700502b01b00f0700e01201b0260700202b01b0100) (.leaf + 0xf100d030060700000000010000000001000000000100000000000200100000)) (.node (.leaf + 0x6c0201c01c0c0181c0140ac06cac52c01012806c00c19002020010400a01201b) (.leaf + 0x3c80301c02c100ac0ac06c0401d8ac06c03c1c038040240c0181c0080ac0))))) (.node (.node (.node + (.node (.leaf 0x30060700202b01b013030060700202012030060700202b01b01303006070020) (.leaf + 0xf7002020010400a01202b00d030060700202b01b01303006070020201d07009)) (.node (.leaf + 0x70010000000100000000000020a0060762b01b00f0700e0100d030060) (.leaf + 0xf762b01b00f0700e0100d03006070000000001000000000100000000010000))) (.node (.node (.leaf + 0x1c01c0c0181c0140ac06cac56c01012806c00c19002020010402b02b01b0100) (.leaf + 0x3dc0080ac06c04c0c0181c008080301c02c10028040240c0181c0080ac06c02)) (.node (.leaf + 0xb009030060700202b01b01303006070020200c0700b0400a071201b009030060) (.leaf + 0xf0200701f06029030060700202b01b01303006070020200c0700b0400a01201)))) (.node (.node (.node + (.leaf 0x2020010400a01202b100d0300607002020010400a01201b021030060700202) (.leaf + 0xf0060762b01b00f0700e0100d0300607)) (.node (.leaf + 0x10000000001000000000100000000000900100000000e0000000000030a) (.leaf + 0x3dc0140ac06cac5ac01012806c00c19002020010400a0100d03006070000))) (.node (.node (.leaf + 0x6070020200c0700b0400a071201b1009030060700202b01b00807007030060) (.leaf + 0xf01303006070020200c0700b0400a01201b1009030060700202b01b01303)) (.node (.leaf + 0xe01201b0260700202b01b0100700502b01b00f0700e01009030060700202b01b) (.leaf + 0xf0060700502b01b00f0700))))))))) (.node (.node (.node (.node (.node (.node (.node (.leaf + 0x1000000000100000000010000000000040010000000150000000000005a) (.leaf + 0x3cac06cac5ec01012806c00c19002020010400a071201b100d03006070000)) (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b0080700703006070050) (.leaf + 0xf402b02b01b0100762b01b00f0700e01009030060700202b01b013030060))) (.node (.node (.leaf + 0x2b01b013030060700202012030060700202b01b01303006070020200c0700b0) (.leaf + 0xf400a01201b00d030060700202b01b01303006070020201d070090300607002)) (.node (.leaf + 0x120000000000010a0060700502b01b00f0700e0100d0300607002020010) (.leaf + 0xf201b100d030060700000000010000000001000000000100000000000900100)))) (.node (.node (.node + (.leaf 0xac06c0201c01c0c0181c0140ac06cac62c01012806c00c19002020010400a01) (.leaf + 0x3dc008080301c02c100ac0ac06c0401d8ac06c03c1c038040240c0181c008)) (.node (.leaf + 0x2b01b01303006070020200c0700b0400a01009030060700202b01b013030060) (.leaf + 0xf0060700202b01b01303006070020200c0700b0400a071201b0090300607002))) (.node (.node (.leaf + 0x701f06029030060700202b01b01303006070020200c0700b0400a01201b00903) (.leaf + 0xf400a01201b100d0300607002020010400a01201b0210300607002020200)) (.node (.leaf + 0x10000000100000000000020a0060762b01b00f0700e0100d0300607002020010) (.leaf + 0xf700e0100d030060700000000010000000001000000000100000000000b00))))) (.node (.node (.node + (.node (.leaf 0x1c0140ac06cac66c01012806c00c19002020010402b02b01b0100762b01b00f0) (.leaf + 0x3cc0181c008080301c02c10028040240c0181c0080ac06c0201c01c0c018)) (.node (.leaf + 0x2b01b01303006070020200c0700b0400a071201b1009030060700202b01b0130) (.leaf + 0xf700202b01b01303006070020200c0700b0400a01201b100903006070020))) (.node (.node (.leaf + 0xf0060700502b01b00f0700e01201b0260700502b01b00f0700e01009030060) (.leaf 0x0)) (.node (.leaf + 0x1000000000100000000010000000000060010000000160000000000005a) (.leaf + 0x3dc0140ac06cac6ac01012806c00c19002020010400a0100d03006070000)))) (.node (.node (.node + (.leaf 0x6070020200c0700b0400a071201b1009030060700202b01b00807007030060) (.leaf + 0xf01303006070020200c0700b0400a01201b1009030060700202b01b01303)) (.node (.leaf + 0x700502b01b00f0700e01201b0260762b01b00f0700e01009030060700202b01b) (.leaf 0xf0060))) (.node + (.node (.leaf 0x1000000000100000000010000000000040010000000180000000000015a) (.leaf + 0x3cac06cac6ec01012806c00c19002020010400a071201b100d03006070000)) (.node (.leaf + 0x70020200c0700b0400a01201b1009030060700202b01b0080700703006070050) (.leaf + 0xf700e01201b0260762b01b00f0700e01009030060700202b01b013030060)))))) (.node (.node (.node + (.node (.node (.leaf 0x100000000000200100000001a0000000000025a0060700502b01b00f0) (.leaf + 0x3e806c00c19002020010400a01201b100d03006070000000001000000000100)) (.node (.leaf + 0xb00f0700e01009030060700202b01b00807007030060700502b01b2b1cb00404) (.leaf + 0xf0060700502b01b00f0700e01201b0260762b01))) (.node (.node (.leaf + 0x10000000001000000000100000000000000100000001c0000000000035a) (.leaf + 0xf700502b01b00f0700e01201b0260762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x10000000001000000000100100000001c0000010000000000000000042a0060) (.leaf + 0x3cac06c0101002804806c0a00900b040270701a0762b01b00f0700000000)))) (.node (.node (.node + (.leaf 0x607619002020200761901f06029030060700202b01b0080700703006070020) (.leaf + 0xf700b0400a01201b01a070220100d0300607619002020010400a01201b02103)) (.node (.leaf + 0xc19002020010400a0100d030060761900202001040250400a01201b024060230) (.leaf + 0x3c40240c0181c0080ac06c0201c01c0c0181c0140ac06cac32c01012806c00))) (.node (.node (.leaf + 0xc0000000000005a0060700502b01b00f0700e010260700502b01b00f0700e0) (.leaf + 0xf100d0300607000000000100000000010000000001000000000000001000000)) (.node (.leaf + 0x12a0060700502b01b00f0700e010260700502b01b00f0700e0) (.leaf + 0xf0020200c0700000000010000000001000000000100100000000c000001000))))) (.node (.node (.node + (.node (.leaf 0x4c0c0181d864008080300900b0400a01009030060700202b01b0130300607619) (.leaf + 0x3c0901808c1c02c1002804806c0681c08804806c0340c0181c0080ac06c0)) (.node (.leaf + 0xd0300607619002020010400a0100d030060761900202001040250400a01201b) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e010))) (.node (.node (.leaf + 0x10000000001000000000100100000000c0000010000000000000000012a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006076190020200c070000)) (.node (.leaf + 0x801d86407c180780900e01009030060700202b01b01303006076190020200c0) (.leaf + 0x3dc08804806c40340c0181d864008080041002804806c0840c0181d86400808)))) (.node (.node (.node + (.leaf 0x12806c00c1900202001040250400a01201b024060230700b0400a01201b01a0) (.leaf + 0x3dc02c10028040240c0181c0080ac06c0201c01c0c0181c0140ac06cac3ec01)) (.node (.leaf + 0x10260700502b01b00f0700e01009030060700202b01b01303006070020200c0) (.leaf + 0xf0060700502b01b00f0700e))) (.node (.node (.leaf + 0x10000000001000000000100000000000200100000000e0000000000005a) (.leaf + 0x3dc0140ac06cac42c01012806c00c19002020010400a0100d03006070000)) (.node (.leaf + 0xf0700e010260762b01b00f0700e01009030060700202b01b00807007030060) (.leaf + 0xf0060700502b01b))))))) (.node (.node (.node (.node (.node (.node (.node (.leaf + 0x1000000000100000000010000000000000010000000100000000000015a) (.leaf + 0xf0060700502b01b00f0700e010260762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x1000000000100000000010010000000100000010000000000000000022a) (.leaf + 0x3d002804806c0e81c0681c0b00900b0402b02b01b0100762b01b00f070000))) (.node (.node (.leaf + 0x19002020200701f06029030060700202b01b00807007030060700202b02b0040) (.leaf + 0xf20010400a01202b100d0300607619002020010400a01201b02103006076)) (.node (.leaf + 0x10000000000000000030a0060762b01b00f0700e0100d03006076190020) (.leaf + 0xf3006076190020200c07000000000100000000010000000001001000000011)))) (.node (.node (.node + (.leaf 0x80ac06c04c0c0181d864008080300900b0400a01009030060700202b01b0130) (.leaf + 0x3c0681c0e00c0181c0080ac06c04c0c0181d864008080741c0240c0181c0)) (.node (.leaf + 0x1d0700903006076190020201c02b01b0040400a01201b01b0700b0400a01201b) (.leaf + 0xf0060700502b01b00f0700e0100d030060700202b01b0130300607619002020))) (.node (.node (.leaf + 0x1000000000100000000010010000000150000010000000000000000010a) (.leaf + 0xf00b0400a071201b1009030060700202b01b01303006076190020200c070000)) (.node (.leaf + 0x200c0700b0400a01201b1009030060700202b01b01303006076190020200c07) (.leaf + 0x3c80801d86407c180780900e01009030060700202b01b0130300607619002))))) (.node (.node (.node + (.node (.leaf 0x1201b01a070220100d0300607619002020010400a01201b02103006076190020) (.leaf + 0x3ec5ec01012806c00c1900202001040250400a01201b024060230700b0400a0)) (.node (.leaf + 0x20200c0700b0400a01009030060700202b01b00807007030060700502b01b2) (.leaf + 0xf1201b0210300607002020200701f06029030060700202b01b0130300607))) (.node (.node (.leaf + 0x700e0100d03006070020200104a01b03c0703b0100d0300607002020010400a0) (.leaf + 0xf0060762b01b00f0)) (.node (.leaf + 0x1000000000100000000010000000000050010000000120000000000020a) (.leaf + 0x3dc0140ac06cac62c01012806c00c19002020010400a0100d03006070000)))) (.node (.node (.node + (.leaf 0x700e010260700502b01b00f0700e01009030060700202b01b00807007030060) (.leaf + 0xf0060700502b01b00f)) (.node (.leaf + 0x1000000000100000000010000000000000010000000180000000000005a) (.leaf + 0xf0060700502b01b00f0700e010260700502b01b00f0700e0100d03006070000))) (.node (.node (.leaf + 0x1000000000100000000010010000000180000010000000000000000012a) (.leaf + 0x3dc0080ac06c0101002804806c0a00900b040270701a0762b01b00f070000)) (.node (.leaf + 0x210300607619002020200761901f06029030060700202b01b00807007030060) (.leaf + 0xf300607619002020010400a01202b100d0300607619002020010400a01201b)))))) (.node (.node (.node + (.node (.node (.leaf 0x10010000000190000010000000000000000030a0060762b01b00f0700e0100d0) + (.leaf 0xf700202b01b01303006076190020200c0700000000010000000001000000000)) (.node (.leaf + 0xec0340c0181c0080ac06c04c0c0181d864008080300900b0400a01009030060) (.leaf + 0x3c0181d8ac06c03c1c038040340c0181d8640080800410028048))) (.node (.node (.leaf + 0x1000000000100000000010010000000190000010000000000000000030a) (.leaf + 0xf700b0400a01201b1009030060700202b01b01303006076190020200c070000)) (.node (.leaf + 0x801d86407c180780900e01009030060700202b01b01303006076190020200c0) (.leaf + 0x3d00280480ec40340c0181d864008080041002804806c0840c0181d86400808)))) (.node (.node (.node + (.leaf 0x81c0080ac06c0201c01c0c0181c0140ac06cac76c01012806c00c19002020010) (.leaf + 0x3cac06c04c0c0181c008080301c02c100a81d8ac06c03c1c038040240c01)) (.node (.leaf + 0x1009030060700202b01b01303006070020200c0700b0400a0100903006070020) (.leaf + 0xf006070160601502b01b0140))) (.node (.node (.leaf + 0x10000000001000000000100000000000400100000001b0000000000014a) (.leaf + 0xf0060762b01b00f0700e0100d03006070000)) (.node (.leaf + 0x10000000001000000000100100000001d0000010000000000000000040a) (.leaf + 0x3c0981c0080ac06c0401c0b00900b0402b02b01b0100762b01b00f070000))))) (.node (.node (.node + (.node (.leaf 0x100000001a0000010000020000000000005a0060700502b01b00f0700e01201b) (.leaf + 0xf2b01b01303006076190020200c0700000000010000005001000000000100)) (.node (.leaf + 0x40c0181c0080ac06c04c0c0181d864008080300900b0400a0100903006070020) (.leaf + 0x3c8004100280480ac0340c0181c0080ac06c04c0c0181d864008080741c02))) (.node (.node (.leaf + 0x10000000000000000020a0060762b01b00f0700e0100d03006076190020) (.leaf + 0xf3006076190020200c07000000000100000000010000000001001000000021)) (.node (.leaf + 0x1b01303006076190020200c0700b0400a071201b1009030060700202b01b0130) (.leaf + 0xf2b01b01303006076190020200c0700b0400a01201b1009030060700202b0)))) (.node (.node (.node + (.leaf 0x2804806c0840c0181d864008080801d86407c180780900e0100903006070020) (.leaf + 0xfb25b00404a01b00306400808004100280480ac40340c0181d8640080800410)) (.node (.leaf + 0x2a0762b01b00f0700e01009030060700202b01b00807007030060700502b01b2) (.leaf + 0xf200c0700b0400a01009030060700202b01b01303006070020200c0700b040))) (.node (.node (.leaf + 0x230000000000004a0060700202b01b02d030060700202b01b01303006070020) (.leaf + 0xf100d0300607000000000100000000010000000001000000000004001000000)) (.node (.leaf + 0x10010000000250000010000000000000000030a0060762b01b00f0700e0) (.leaf + 0x3dc0b00900b0402b02b01b0100762b01b00f07000000000100000000010000))))))) (.node (.node (.node + (.node (.node (.node (.leaf 0x220000010000010000000000005a0060700502b01b00f0700e01201b0260) + (.leaf 0xf01303006076190020200c07000000000100000050010000000001001000)) (.node (.leaf + 0x81c0080ac06c04c0c0181d864008080300900b0400a01009030060700202b01b) (.leaf + 0x3d002804806c0340c0181c0080ac06c04c0c0181d864008080741c0240c01))) (.node (.node (.leaf + 0x10a0060700502b01b00f0700e0100d0300607619002020010) (.leaf + 0x3d90020200c0700000000010000000001000000000100100000002900000100)) (.node (.leaf + 0x181d864008080301c02c100281c4806c40240c0181c0080ac06c04c0c0181d8) (.leaf + 0x3cc0181d864008080301c02c1002804806c40240c0181c0080ac06c04c0c)))) (.node (.node (.node + (.leaf 0x840c0181d864008080801d86407c180780900e01009030060700202b01b0130) (.leaf + 0xf7007030060700502b01b2b2cb00404a01b003064008080041002804806c)) (.node (.leaf + 0x2b01b01303006070020200c0700b0400a01201b1009030060700202b01b0080) (.leaf + 0xf1201b009030060700202b01b02e0700502b01b00f0700e010090300607002))) (.node (.node (.leaf + 0x7002020200701f06029030060700202b01b01303006070020200c0700b0400a0) (.leaf + 0xf0060700502b01b00f0700e0100d0300607002020010400a01201b021030060)) (.node (.leaf + 0x1000000000100000000010000000000070010000000270000000000010a) (.leaf + 0x3cac06cacb6c01012806c00c19002020010400a01201b100d03006070000))))) (.node (.node (.node + (.node (.leaf 0xb0402a0762b01b00f0700e01009030060700202b01b0080700703006070050) (.leaf + 0xf1201b00d030060700202012030060700202b01b01303006070020200c07)) (.node (.leaf + 0x70020201102b01b0100700502b01b00f0700e0100d0300607002020010400a0) (.leaf + 0xf1201b100d0300607002020010400a071201b00d03006070020201203006))) (.node (.node (.leaf + 0x260000000000020a0060762b01b00f0700e0100d0300607002020010400a0) (.leaf + 0xf100d03006070000000001000000000100000000010000000000080010000)) (.node (.leaf + 0x100100000002d0000010000000000000000020a0060762b01b00f0700e0) (.leaf + 0xf2b01b00f0700e01201b0260762b01b00f07000000000100000000010000)))) (.node (.node (.node + (.leaf 0x5001000000000100100000002a0000010000000000000010005a006070050) (.leaf 0x5001000)) + (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) + (.leaf 0x0)))))) (.node (.node (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf + 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))) + (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node + (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))))) (.node (.node (.node (.node + (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf + 0x0)) (.node (.leaf 0x0) (.leaf 0x0)))) (.node (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node + (.leaf 0x0) (.leaf 0x0))) (.node (.node (.leaf 0x0) (.leaf 0x0)) (.node (.leaf 0x0) (.leaf + 0x0))))))))) + + +/-! ### Bit-Packed Zipper Cache and Bytecode Stream Interpreter -/ + +noncomputable def zipLookup (id : ℕ) : Option ℕ := + zipCache.find? id + + +theorem zipCache_ok : WordRLE.NatTrie.checkAll checkZipPacked 0 1 zipCache = true := by + decide +kernel + +theorem zipLookup_sound {id p : ℕ} (h : zipLookup id = some p) : + let e := unpackZip p + 1 ≤ e.steps ∧ + simZipNat e.steps e.qIn e.dirIn e.kL e.lB e.kR e.rB = + some (e.qOut, e.dirOut, e.kLOut, e.lOut, e.kROut, e.rOut) := by + unfold zipLookup at h + have hchk : checkZipPacked id p = true := WordRLE.NatTrie.checkAll_sound zipCache_ok h + unfold checkZipPacked at hchk + simp only [Bool.and_eq_true] at hchk + exact ⟨Nat.le_of_ble_eq_true hchk.1, eq_of_beq hchk.2⟩ + +noncomputable def stepOp (op : SymOp) (g : SymCfg) : Option SymCfg := + match op with + | .zip id => + match zipLookup id with + | none => none + | some p => + let e := unpackZip p + if Nat.beq g.q e.qIn && (g.dir == e.dirIn) then + match popBits (unpackBits e.kL e.lB) g.left, popBits (unpackBits e.kR e.rB) g.right with + | some lRem, some rRem => + some ⟨e.qOut, e.dirOut, true, + pushBits (unpackBits e.kLOut e.lOut) lRem, + pushBits (unpackBits e.kROut e.rOut) rRem⟩ + | _, _ => none + else none + | .shiftWaL => + if !g.dir && Nat.beq g.q 1 then + match g.left with + | ⟨2, cnt⟩ :: rest => + some ⟨1, false, g.prog || Nat.ble 1 cnt.c0, rest, pushSym 2 cnt g.right⟩ + | _ => none + else none + | .shiftWbR => + if g.dir && Nat.beq g.q 1 then + match g.right with + | ⟨3, cnt⟩ :: rest => + some ⟨1, true, g.prog || Nat.ble 1 cnt.c0, pushSym 4 cnt g.left, rest⟩ + | _ => none + else none + | .shiftWcL => + if !g.dir && Nat.beq g.q 5 then + match g.left with + | ⟨4, cnt⟩ :: rest => + some ⟨5, false, g.prog || Nat.ble 1 cnt.c0, rest, pushSym 3 cnt g.right⟩ + | _ => none + else none + | .shiftWaR0 => + if g.dir && Nat.beq g.q 0 then + match g.right with + | ⟨2, cnt⟩ :: rest => + if peekBit true rest == some 0 then + some ⟨0, true, g.prog || Nat.ble 1 cnt.c0, pushSym 2 cnt g.left, rest⟩ + else none + | _ => none + else none + | .splitWaLast => + if g.dir && Nat.beq g.q 0 then + match g.right with + | ⟨2, cnt⟩ :: rest => + if Nat.ble 1 cnt.c0 then + let r' := pushSym 2 cnt.sub1 (pushBits [0, 1, 0] rest) + some ⟨0, true, g.prog, g.left, r'⟩ + else none + | _ => none + else none + | .bounce => + let ac := if g.dir then g.right else g.left + match peekBit g.dir ac with + | none => none + | some b => + match stepCode g.q b with + | some (w, nd, q') => + if (w == b) && (nd == !g.dir) then + some ⟨q', nd, true, g.left, g.right⟩ + else none + | none => none + | .unroll => + let ac := if g.dir then g.right else g.left + match ac with + | ⟨sym, cnt⟩ :: rest => + if Nat.ble 2 sym && Nat.ble 1 cnt.c0 then + let wd := if g.dir then symWord sym else (symWord sym).reverse + let ac' := pushBits wd (pushSym sym cnt.sub1 rest) + if g.dir then some ⟨g.q, true, g.prog, g.left, ac'⟩ + else some ⟨g.q, false, g.prog, ac', g.right⟩ + else none + | [] => none + | .fold side sym k => + let wd := if side then symWord sym else (symWord sym).reverse + let ac := if side then g.right else g.left + match popBits (wd ^ k) ac with + | none => none + | some rem => + let ac' := pushSym sym (Aff3.const k) rem + if side then some ⟨g.q, g.dir, g.prog, g.left, ac'⟩ + else some ⟨g.q, g.dir, g.prog, ac', g.right⟩ + +theorem stepOp_sound (op : SymOp) (g g' : SymCfg) (u v w : ℕ) + (h : stepOp op g = some g') : + ∃ dp : Bool, g'.prog = (g.prog || dp) ∧ + StepRel dp (evalSymCfg u v w g) (evalSymCfg u v w g') := by + cases op with + | zip id => + simp only [stepOp] at h + rcases hz : zipLookup id with _ | p + · simp [hz] at h + · rw [hz] at h + simp only at h + set e := unpackZip p + cases hqd : Nat.beq g.q e.qIn && (g.dir == e.dirIn) + · simp [hqd] at h + · rw [hqd] at h + simp only [↓reduceIte] at h + rcases hpl : popBits (unpackBits e.kL e.lB) g.left with _ | lRem + · simp [hpl] at h + · rw [hpl] at h + rcases hpr : popBits (unpackBits e.kR e.rB) g.right with _ | rRem + · simp [hpr] at h + · rw [hpr] at h + simp only [Option.some.injEq] at h + subst h + simp only [Bool.and_eq_true] at hqd + have hqEq : g.q = e.qIn := Nat.eq_of_beq_eq_true hqd.1 + have hdEq : g.dir = e.dirIn := eq_of_beq hqd.2 + obtain ⟨hpos, hsim⟩ := zipLookup_sound hz + refine ⟨true, by simp, ?_⟩ + apply StepRel.of_reachesIn _ (fun _ ↦ hpos) + simp only [evalSymCfg, hqEq, hdEq, + popBits_sound false u v w (unpackBits e.kL e.lB) g.left lRem hpl, + popBits_sound true u v w (unpackBits e.kR e.rB) g.right rRem hpr, + evalStk_pushBits] + exact simZipNat_sound e.steps e.qIn e.dirIn e.kL e.lB e.kR e.rB + e.qOut e.dirOut e.kLOut e.lOut e.kROut e.rOut + (evalStk false u v w lRem) (evalStk true u v w rRem) hsim + | shiftWaL => + simp only [stepOp] at h + cases hcond : !g.dir && Nat.beq g.q 1 + · simp [hcond] at h + · rw [hcond] at h + simp only [↓reduceIte] at h + rcases hl : g.left with _ | ⟨⟨sym, cnt⟩, rest⟩ + · simp [hl] at h + · rw [hl] at h + match sym with + | 2 => + simp only [Option.some.injEq] at h + subst h + simp only [Bool.and_eq_true, Bool.not_eq_true'] at hcond + have hq1 : g.q = 1 := Nat.eq_of_beq_eq_true hcond.2 + refine ⟨Nat.ble 1 cnt.c0, rfl, ?_⟩ + have hex := WordRLE.sweepWord_sound exit_waL (cnt.eval u v w) + (evalStk false u v w rest) (evalStk true u v w g.right) + simp only [WordRLE.placeSide, Bool.false_eq_true, ↓reduceIte, Bool.not_false, + WordRLE.reverse_pow] at hex + apply StepRel.of_reachesIn + · simp only [evalSymCfg, hl, hcond.1, hq1, evalStk, Bool.false_eq_true, ↓reduceIte, + evalStk_pushSym, symWord] + exact hex + · intro hp + have hge := Aff3.ge1_eval hp u v w + omega + | 0 | 1 | _ + 3 => simp at h + | shiftWbR => + simp only [stepOp] at h + cases hcond : g.dir && Nat.beq g.q 1 + · simp [hcond] at h + · rw [hcond] at h + simp only [↓reduceIte] at h + rcases hr : g.right with _ | ⟨⟨sym, cnt⟩, rest⟩ + · simp [hr] at h + · rw [hr] at h + match sym with + | 3 => + simp only [Option.some.injEq] at h + subst h + simp only [Bool.and_eq_true] at hcond + have hq1 : g.q = 1 := Nat.eq_of_beq_eq_true hcond.2 + refine ⟨Nat.ble 1 cnt.c0, rfl, ?_⟩ + have hex := WordRLE.sweepWord_sound exit_wbR (cnt.eval u v w) + (evalStk false u v w g.left) (evalStk true u v w rest) + simp only [WordRLE.placeSide, Bool.false_eq_true, ↓reduceIte, Bool.not_true, + WordRLE.reverse_pow] at hex + apply StepRel.of_reachesIn + · simp only [evalSymCfg, hr, hcond.1, hq1, evalStk, Bool.false_eq_true, ↓reduceIte, + evalStk_pushSym, symWord] + exact hex + · intro hp + have hge := Aff3.ge1_eval hp u v w + omega + | 0 | 1 | 2 | _ + 4 => simp at h + | shiftWcL => + simp only [stepOp] at h + cases hcond : !g.dir && Nat.beq g.q 5 + · simp [hcond] at h + · rw [hcond] at h + simp only [↓reduceIte] at h + rcases hl : g.left with _ | ⟨⟨sym, cnt⟩, rest⟩ + · simp [hl] at h + · rw [hl] at h + match sym with + | 4 => + simp only [Option.some.injEq] at h + subst h + simp only [Bool.and_eq_true, Bool.not_eq_true'] at hcond + have hq5 : g.q = 5 := Nat.eq_of_beq_eq_true hcond.2 + refine ⟨Nat.ble 1 cnt.c0, rfl, ?_⟩ + have hex := WordRLE.sweepWord_sound exit_wcL (cnt.eval u v w) + (evalStk false u v w rest) (evalStk true u v w g.right) + simp only [WordRLE.placeSide, Bool.false_eq_true, ↓reduceIte, Bool.not_false, + WordRLE.reverse_pow] at hex + apply StepRel.of_reachesIn + · simp only [evalSymCfg, hl, hcond.1, hq5, evalStk, Bool.false_eq_true, ↓reduceIte, + evalStk_pushSym, symWord] + exact hex + · intro hp + have hge := Aff3.ge1_eval hp u v w + omega + | 0 | 1 | 2 | 3 | _ + 5 => simp at h + | shiftWaR0 => + simp only [stepOp] at h + cases hcond : g.dir && Nat.beq g.q 0 + · simp [hcond] at h + · rw [hcond] at h + simp only [↓reduceIte] at h + rcases hr : g.right with _ | ⟨⟨sym, cnt⟩, rest⟩ + · simp [hr] at h + · rw [hr] at h + match sym with + | 2 => + simp only at h + cases hpk : peekBit true rest == some 0 + · simp [hpk] at h + · rw [hpk] at h + simp only [↓reduceIte, Option.some.injEq] at h + subst h + simp only [Bool.and_eq_true] at hcond + have hq0 : g.q = 0 := Nat.eq_of_beq_eq_true hcond.2 + obtain ⟨rTail, hrTail⟩ := peekBit_sound true u v w rest 0 (eq_of_beq hpk) + refine ⟨Nat.ble 1 cnt.c0, rfl, ?_⟩ + apply StepRel.of_reachesIn (dt := 9 * cnt.eval u v w) + · simp only [evalSymCfg, hr, hcond.1, hq0, evalStk, Bool.false_eq_true, ↓reduceIte, + evalStk_pushSym, symWord, hrTail] + exact sweep_waR0_sound (cnt.eval u v w) (evalStk false u v w g.left) rTail + · intro hp + have hge := Aff3.ge1_eval hp u v w + omega + | 0 | 1 | _ + 3 => simp at h + | splitWaLast => + simp only [stepOp] at h + cases hcond : g.dir && Nat.beq g.q 0 + · simp [hcond] at h + · rw [hcond] at h + simp only [↓reduceIte] at h + rcases hr : g.right with _ | ⟨⟨sym, cnt⟩, rest⟩ + · simp [hr] at h + · rw [hr] at h + match sym with + | 2 => + simp only at h + cases hc : Nat.ble 1 cnt.c0 + · simp [hc] at h + · rw [hc] at h + simp only [↓reduceIte, Option.some.injEq] at h + subst h + simp only [Bool.and_eq_true] at hcond + have hq0 : g.q = 0 := Nat.eq_of_beq_eq_true hcond.2 + refine ⟨false, by simp, ?_⟩ + have heq : evalSymCfg u v w g = + evalSymCfg u v w + ⟨0, true, g.prog, g.left, pushSym 2 cnt.sub1 (pushBits [0, 1, 0] rest)⟩ := by + simp only [evalSymCfg, hr, hcond.1, hq0, evalStk, ↓reduceIte, evalStk_pushSym, + evalStk_pushBits, Aff3.sub1_eval hc u v w, symWord] + rw [list_pow_succ', ListBlank.append_assoc] + rw [heq] + exact StepRel.refl _ + | 0 | 1 | _ + 3 => simp at h + | bounce => + simp only [stepOp] at h + rcases hp : peekBit g.dir (if g.dir then g.right else g.left) with _ | b + · simp [hp] at h + · rw [hp] at h + simp only at h + rcases hsc : stepCode g.q b with _ | ⟨wb, nd, q'⟩ + · simp [hsc] at h + · rw [hsc] at h + simp only at h + cases hchk : (wb == b) && (nd == !g.dir) + · simp [hchk] at h + · rw [hchk] at h + simp only [↓reduceIte, Option.some.injEq] at h + subst h + simp only [Bool.and_eq_true] at hchk + have hwb : wb = b := eq_of_beq hchk.1 + have hnd : nd = !g.dir := eq_of_beq hchk.2 + rw [hwb] at hsc + subst hnd + refine ⟨true, by simp, ?_⟩ + cases hd : g.dir + · rw [hd] at hp hsc + simp only [Bool.false_eq_true, ↓reduceIte] at hp + obtain ⟨lTail, hlTail⟩ := peekBit_sound false u v w g.left b hp + have hst := step_headLeft_right (stepCode_agrees g.q b b true q' hsc) + lTail (evalStk true u v w g.right) + rw [← hlTail] at hst + simp only [evalSymCfg, hd, WordRLE.dirCfg, Bool.false_eq_true, ↓reduceIte, + Bool.not_false] + exact ReachesPlus.single hst + · rw [hd] at hp hsc + simp only [↓reduceIte] at hp + obtain ⟨rTail, hrTail⟩ := peekBit_sound true u v w g.right b hp + have hst := step_headRight_left (stepCode_agrees g.q b b false q' hsc) + (evalStk false u v w g.left) rTail + rw [← hrTail] at hst + simp only [evalSymCfg, hd, WordRLE.dirCfg, Bool.false_eq_true, ↓reduceIte, + Bool.not_true] + exact ReachesPlus.single hst + | unroll => + simp only [stepOp] at h + cases hd : g.dir + · rw [hd] at h + simp only [Bool.false_eq_true, ↓reduceIte] at h + rcases hl : g.left with _ | ⟨⟨sym, cnt⟩, rest⟩ + · simp [hl] at h + · rw [hl] at h + simp only at h + cases hc : Nat.ble 2 sym && Nat.ble 1 cnt.c0 + · simp [hc] at h + · rw [hc] at h + simp only [↓reduceIte, Option.some.injEq] at h + subst h + simp only [Bool.and_eq_true] at hc + refine ⟨false, by simp, ?_⟩ + have heq : evalSymCfg u v w g = + evalSymCfg u v w + ⟨g.q, false, g.prog, + pushBits (symWord sym).reverse (pushSym sym cnt.sub1 rest), g.right⟩ := by + simp only [evalSymCfg, hd, hl, evalStk, Bool.false_eq_true, ↓reduceIte, + evalStk_pushBits, evalStk_pushSym, Aff3.sub1_eval hc.2 u v w] + rw [ListBlank.append_pow_succ] + rw [heq] + exact StepRel.refl _ + · rw [hd] at h + simp only [↓reduceIte] at h + rcases hr : g.right with _ | ⟨⟨sym, cnt⟩, rest⟩ + · simp [hr] at h + · rw [hr] at h + simp only at h + cases hc : Nat.ble 2 sym && Nat.ble 1 cnt.c0 + · simp [hc] at h + · rw [hc] at h + simp only [↓reduceIte, Option.some.injEq] at h + subst h + simp only [Bool.and_eq_true] at hc + refine ⟨false, by simp, ?_⟩ + have heq : evalSymCfg u v w g = + evalSymCfg u v w + ⟨g.q, true, g.prog, g.left, + pushBits (symWord sym) (pushSym sym cnt.sub1 rest)⟩ := by + simp only [evalSymCfg, hd, hr, evalStk, ↓reduceIte, + evalStk_pushBits, evalStk_pushSym, Aff3.sub1_eval hc.2 u v w] + rw [ListBlank.append_pow_succ] + rw [heq] + exact StepRel.refl _ + | fold side sym k => + simp only [stepOp] at h + cases side + · simp only [Bool.false_eq_true, ↓reduceIte] at h + rcases hp : popBits ((symWord sym).reverse ^ k) g.left with _ | rem + · simp [hp] at h + · rw [hp] at h + simp only [Option.some.injEq] at h + subst h + refine ⟨false, by simp, ?_⟩ + have heq : evalSymCfg u v w g = + evalSymCfg u v w + ⟨g.q, g.dir, g.prog, pushSym sym (Aff3.const k) rem, g.right⟩ := by + simp only [evalSymCfg, popBits_sound false u v w _ g.left rem hp, + evalStk_pushSym, Bool.false_eq_true, ↓reduceIte, Aff3.const_eval] + rw [heq] + exact StepRel.refl _ + · simp only [↓reduceIte] at h + rcases hp : popBits (symWord sym ^ k) g.right with _ | rem + · simp [hp] at h + · rw [hp] at h + simp only [Option.some.injEq] at h + subst h + refine ⟨false, by simp, ?_⟩ + have heq : evalSymCfg u v w g = + evalSymCfg u v w + ⟨g.q, g.dir, g.prog, g.left, pushSym sym (Aff3.const k) rem⟩ := by + simp only [evalSymCfg, popBits_sound true u v w _ g.right rem hp, + evalStk_pushSym, ↓reduceIte, Aff3.const_eval] + rw [heq] + exact StepRel.refl _ + +def GoodCfg (cfg : Cfg (Fin 2) (Fin 6)) : Prop := + ∃ m a b c, HubInv m a b c ∧ cfg = evalHub m a b c + +structure Frame where + a : Aff3 + b : Aff3 + c : Aff3 + g : SymCfg + +def FrameOk (m : ℕ) (fr : Frame) : Prop := + ∀ u v w : ℕ, + HubInv m (fr.a.eval u v w) (fr.b.eval u v w) (fr.c.eval u v w) → + ∃ cfg', StepRel (!fr.g.prog) (evalSymCfg u v w fr.g) cfg' ∧ GoodCfg cfg' + +def TodoOk (m : ℕ) : List Frame → Prop + | [] => True + | fr :: rest => FrameOk m fr ∧ TodoOk m rest + +theorem frameOk_of_stepOp {m : ℕ} {op : SymOp} {fr : Frame} {g' : SymCfg} + (hs : stepOp op fr.g = some g') + (hnext : FrameOk m ⟨fr.a, fr.b, fr.c, g'⟩) : + FrameOk m fr := by + intro u v w hinv + obtain ⟨dp, hpEq, hstep⟩ := stepOp_sound op fr.g g' u v w hs + obtain ⟨cfg', hs2, hg2⟩ := hnext u v w hinv + dsimp only at hs2 + rw [hpEq] at hs2 + exact ⟨cfg', StepRel.chain hstep hs2, hg2⟩ + +theorem frameOk_of_split {m : ℕ} (sv : Var3) (fr : Frame) + (h0 : FrameOk m ⟨fr.a.substZero sv, fr.b.substZero sv, fr.c.substZero sv, + ⟨fr.g.q, fr.g.dir, fr.g.prog, substStk sv false fr.g.left, substStk sv false fr.g.right⟩⟩) + (h1 : FrameOk m ⟨fr.a.substSucc sv, fr.b.substSucc sv, fr.c.substSucc sv, + ⟨fr.g.q, fr.g.dir, fr.g.prog, substStk sv true fr.g.left, substStk sv true fr.g.right⟩⟩) : + FrameOk m fr := by + intro u v w hinv + cases sv with + | va => + cases u with + | zero => + rw [← Aff3.substZero_va fr.a v w, ← Aff3.substZero_va fr.b v w, + ← Aff3.substZero_va fr.c v w] at hinv + obtain ⟨cfg', hs, hg⟩ := h0 0 v w hinv + simp only [evalSymCfg, substStk_zero_va] at hs + exact ⟨cfg', hs, hg⟩ + | succ u' => + rw [← Aff3.substSucc_va fr.a u' v w, ← Aff3.substSucc_va fr.b u' v w, + ← Aff3.substSucc_va fr.c u' v w] at hinv + obtain ⟨cfg', hs, hg⟩ := h1 u' v w hinv + simp only [evalSymCfg, substStk_succ_va] at hs + exact ⟨cfg', hs, hg⟩ + | vb => + cases v with + | zero => + rw [← Aff3.substZero_vb fr.a u w, ← Aff3.substZero_vb fr.b u w, + ← Aff3.substZero_vb fr.c u w] at hinv + obtain ⟨cfg', hs, hg⟩ := h0 u 0 w hinv + simp only [evalSymCfg, substStk_zero_vb] at hs + exact ⟨cfg', hs, hg⟩ + | succ v' => + rw [← Aff3.substSucc_vb fr.a u v' w, ← Aff3.substSucc_vb fr.b u v' w, + ← Aff3.substSucc_vb fr.c u v' w] at hinv + obtain ⟨cfg', hs, hg⟩ := h1 u v' w hinv + simp only [evalSymCfg, substStk_succ_vb] at hs + exact ⟨cfg', hs, hg⟩ + | vc => + cases w with + | zero => + rw [← Aff3.substZero_vc fr.a u v, ← Aff3.substZero_vc fr.b u v, + ← Aff3.substZero_vc fr.c u v] at hinv + obtain ⟨cfg', hs, hg⟩ := h0 u v 0 hinv + simp only [evalSymCfg, substStk_zero_vc] at hs + exact ⟨cfg', hs, hg⟩ + | succ w' => + rw [← Aff3.substSucc_vc fr.a u v w', ← Aff3.substSucc_vc fr.b u v w', + ← Aff3.substSucc_vc fr.c u v w'] at hinv + obtain ⟨cfg', hs, hg⟩ := h1 u v w' hinv + simp only [evalSymCfg, substStk_succ_vc] at hs + exact ⟨cfg', hs, hg⟩ + +noncomputable def decodeAff (p0 : ℕ) : Aff3 × ℕ := + forceNat (p0 % 4096) fun c0 ↦ + forceNat (p0 / 4096) fun p1 ↦ + forceNat (p1 % 4096) fun ca ↦ + forceNat (p1 / 4096) fun p2 ↦ + forceNat (p2 % 4096) fun cb ↦ + forceNat (p2 / 4096) fun p3 ↦ + forceNat (p3 % 4096) fun cc ↦ + forceNat (p3 / 4096) fun p4 ↦ + (⟨c0, ca, cb, cc⟩, p4) + +noncomputable def decodeFWit (p0 : ℕ) : FWit × ℕ := + forceNat (p0 % 4096) fun k ↦ + forceNat (p0 / 4096) fun p1 ↦ + forceNat (p1 % 4) fun i1 ↦ + forceNat (p1 / 4) fun p2 ↦ + forceNat (p2 % 4096) fun l1 ↦ + forceNat (p2 / 4096) fun p3 ↦ + forceNat (p3 % 4) fun i2 ↦ + forceNat (p3 / 4) fun p4 ↦ + forceNat (p4 % 4096) fun l2 ↦ + forceNat (p4 / 4096) fun p5 ↦ + (⟨k, i1, l1, i2, l2⟩, p5) + +def decodeVar : ℕ → Var3 + | 0 => .va + | 1 => .vb + | _ => .vc + +def decodeUnitOp : ℕ → SymOp + | 1 => .shiftWaL + | 2 => .shiftWbR + | 3 => .shiftWcL + | 4 => .shiftWaR0 + | 5 => .splitWaLast + | 6 => .bounce + | _ => .unroll + +noncomputable def decodeFoldOp (arg : ℕ) : SymOp := + forceNat (arg % 256) fun fk ↦ + forceNat ((arg / 256) % 8) fun fsym ↦ + .fold (Nat.beq (arg / 2048) 1) fsym fk + +noncomputable def checkDoneLeaf (m : ℕ) (fr : Frame) (dm : ℕ) (da db dc : Aff3) + (w0 w1 w2 : FWit) : Bool := + let hs := modeIneqs m fr.a fr.b fr.c + let dhs := modeIneqs dm da db dc + Nat.ble (dm + 1) 7 && + checkHubEq fr.g dm da db dc && + checkFarkas hs dhs.1 w0 && + checkFarkas hs dhs.2.1 w1 && + checkFarkas hs dhs.2.2 w2 + +theorem checkDoneLeaf_sound {m : ℕ} (hm : m < 7) {fr : Frame} {dm : ℕ} {da db dc : Aff3} + {w0 w1 w2 : FWit} (hc : checkDoneLeaf m fr dm da db dc w0 w1 w2 = true) : + FrameOk m fr := by + intro u v w hinv + simp only [checkDoneLeaf, Bool.and_eq_true] at hc + rcases hc with ⟨⟨⟨⟨hdmLe, hhub⟩, hf0⟩, hf1⟩, hf2⟩ + have hdm : dm < 7 := by + have := Nat.le_of_ble_eq_true hdmLe + omega + obtain ⟨hgProg, hgHub⟩ := checkHubEq_sound hhub u v w + have hh := (modeIneqs_iff hm fr.a fr.b fr.c u v w).mpr hinv + have hd0 := checkFarkas_sound hf0 hh + have hd1 := checkFarkas_sound hf1 hh + have hd2 := checkFarkas_sound hf2 hh + have hdInv := (modeIneqs_iff hdm da db dc u v w).mp ⟨hd0, hd1, hd2⟩ + refine ⟨evalHub dm (da.eval u v w) (db.eval u v w) (dc.eval u v w), ?_, + ⟨dm, da.eval u v w, db.eval u v w, dc.eval u v w, hdInv, rfl⟩⟩ + rw [← hgHub, hgProg] + exact StepRel.refl _ + +noncomputable def checkStream (m : ℕ) : ℕ → ℕ → List ℕ → List Frame → Bool + | _, _, _, [] => true + | 0, _, _, _ :: _ => false + | fuel + 1, cur, chunks, fr :: rest => + forceNat (cur % 16) fun tag ↦ + forceNat (cur / 16) fun cur1 ↦ + if Nat.beq tag 15 then + match chunks with + | [] => false + | nextW :: chunks' => checkStream m fuel nextW chunks' (fr :: rest) + else if Nat.beq tag 0 then + forceNat (cur1 % 4096) fun id ↦ + forceNat (cur1 / 4096) fun cur2 ↦ + match stepOp (.zip id) fr.g with + | none => false + | some g' => checkStream m fuel cur2 chunks (⟨fr.a, fr.b, fr.c, g'⟩ :: rest) + else if Nat.ble tag 7 then + match stepOp (decodeUnitOp tag) fr.g with + | none => false + | some g' => checkStream m fuel cur1 chunks (⟨fr.a, fr.b, fr.c, g'⟩ :: rest) + else if Nat.beq tag 8 then + forceNat (cur1 % 4) fun idx ↦ + forceNat (cur1 / 4) fun cur2 ↦ + isDeadIneq (selIneq (modeIneqs m fr.a fr.b fr.c) idx) && + checkStream m fuel cur2 chunks rest + else if Nat.beq tag 9 then + forceNat (cur1 % 4) fun svCode ↦ + forceNat (cur1 / 4) fun cur2 ↦ + let sv := decodeVar svCode + let g0 : SymCfg := ⟨fr.g.q, fr.g.dir, fr.g.prog, + substStk sv false fr.g.left, substStk sv false fr.g.right⟩ + let g1 : SymCfg := ⟨fr.g.q, fr.g.dir, fr.g.prog, + substStk sv true fr.g.left, substStk sv true fr.g.right⟩ + let fr0 : Frame := ⟨fr.a.substZero sv, fr.b.substZero sv, fr.c.substZero sv, g0⟩ + let fr1 : Frame := ⟨fr.a.substSucc sv, fr.b.substSucc sv, fr.c.substSucc sv, g1⟩ + checkStream m fuel cur2 chunks (fr0 :: fr1 :: rest) + else if Nat.beq tag 10 then + forceNat (cur1 % 16) fun dm ↦ + forceNat (cur1 / 16) fun c2 ↦ + let pA := decodeAff c2 + let pB := decodeAff pA.2 + let pC := decodeAff pB.2 + let pW0 := decodeFWit pC.2 + let pW1 := decodeFWit pW0.2 + let pW2 := decodeFWit pW1.2 + checkDoneLeaf m fr dm pA.1 pB.1 pC.1 pW0.1 pW1.1 pW2.1 && + checkStream m fuel pW2.2 chunks rest + else if Nat.beq tag 11 then + forceNat (cur1 % 4096) fun arg ↦ + forceNat (cur1 / 4096) fun cur2 ↦ + match stepOp (decodeFoldOp arg) fr.g with + | none => false + | some g' => checkStream m fuel cur2 chunks (⟨fr.a, fr.b, fr.c, g'⟩ :: rest) + else + false + +theorem checkStream_sound {m : ℕ} (hm : m < 7) : + ∀ (fuel cur : ℕ) (chunks : List ℕ) (todo : List Frame), + checkStream m fuel cur chunks todo = true → + TodoOk m todo + | _, _, _, [], _ => trivial + | 0, _, _, _ :: _, hc => by simp [checkStream] at hc + | fuel + 1, cur, chunks, fr :: rest, hc => by + simp only [checkStream, forceNat_eq] at hc + cases h15 : Nat.beq (cur % 16) 15 + · rw [h15] at hc + simp only [Bool.false_eq_true, ↓reduceIte] at hc + cases h0 : Nat.beq (cur % 16) 0 + · rw [h0] at hc + simp only [Bool.false_eq_true, ↓reduceIte] at hc + cases h7 : Nat.ble (cur % 16) 7 + · rw [h7] at hc + simp only [Bool.false_eq_true, ↓reduceIte] at hc + cases h8 : Nat.beq (cur % 16) 8 + · rw [h8] at hc + simp only [Bool.false_eq_true, ↓reduceIte] at hc + cases h9 : Nat.beq (cur % 16) 9 + · rw [h9] at hc + simp only [Bool.false_eq_true, ↓reduceIte] at hc + cases h10 : Nat.beq (cur % 16) 10 + · rw [h10] at hc + simp only [Bool.false_eq_true, ↓reduceIte] at hc + cases h11 : Nat.beq (cur % 16) 11 + · rw [h11] at hc + simp at hc + · rw [h11] at hc + simp only [↓reduceIte] at hc + rcases hs : stepOp (decodeFoldOp ((cur / 16) % 4096)) fr.g with _ | g' + · simp [hs] at hc + · rw [hs] at hc + have ih := checkStream_sound hm fuel ((cur / 16) / 4096) chunks _ hc + exact ⟨frameOk_of_stepOp hs ih.1, ih.2⟩ + · rw [h10] at hc + simp only [↓reduceIte, Bool.and_eq_true] at hc + exact ⟨checkDoneLeaf_sound hm hc.1, + checkStream_sound hm fuel _ chunks rest hc.2⟩ + · rw [h9] at hc + simp only [↓reduceIte] at hc + have ih := checkStream_sound hm fuel ((cur / 16) / 4) chunks _ hc + exact ⟨frameOk_of_split _ fr ih.1 ih.2.1, ih.2.2⟩ + · rw [h8] at hc + simp only [↓reduceIte, Bool.and_eq_true] at hc + refine ⟨fun u v w hinv ↦ ?_, + checkStream_sound hm fuel ((cur / 16) / 4) chunks rest hc.2⟩ + have hh := (modeIneqs_iff hm fr.a fr.b fr.c u v w).mpr hinv + exact False.elim (isDeadIneq_sound hc.1 (selIneq_holds hh ((cur / 16) % 4))) + · rw [h7] at hc + simp only [↓reduceIte] at hc + rcases hs : stepOp (decodeUnitOp (cur % 16)) fr.g with _ | g' + · simp [hs] at hc + · rw [hs] at hc + have ih := checkStream_sound hm fuel (cur / 16) chunks _ hc + exact ⟨frameOk_of_stepOp hs ih.1, ih.2⟩ + · rw [h0] at hc + simp only [↓reduceIte] at hc + rcases hs : stepOp (.zip ((cur / 16) % 4096)) fr.g with _ | g' + · simp [hs] at hc + · rw [hs] at hc + have ih := checkStream_sound hm fuel ((cur / 16) / 4096) chunks _ hc + exact ⟨frameOk_of_stepOp hs ih.1, ih.2⟩ + · rw [h15] at hc + simp only [↓reduceIte] at hc + rcases chunks with _ | ⟨nextW, chunks'⟩ + · simp at hc + · exact checkStream_sound hm fuel nextW chunks' (fr :: rest) hc + +def varA : Aff3 := ⟨0, 1, 0, 0⟩ +def varB : Aff3 := ⟨0, 0, 1, 0⟩ +def varC : Aff3 := ⟨0, 0, 0, 1⟩ + +def twoPow256 : ℕ := + 0x10000000000000000000000000000000000000000000000000000000000000000 + +noncomputable def unpackSuperList : List ℕ → List ℕ + | lo :: hi :: rest => + forceNat (lo + twoPow256 * hi) fun w ↦ w :: unpackSuperList rest + | [w] => [w] + | [] => [] + +noncomputable def checkModeStream (m fuel : ℕ) (tree : WordRLE.BTree ℕ) : Bool := + match unpackSuperList tree.toList with + | [] => false + | w0 :: ws => + checkStream m fuel w0 ws [⟨varA, varB, varC, mkSymCfg m varA varB varC⟩] + +theorem modeStream_sound {m fuel : ℕ} (hm : m < 7) {tree : WordRLE.BTree ℕ} + (hc : checkModeStream m fuel tree = true) {a b c : ℕ} (hinv : HubInv m a b c) : + ∃ cfg', ReachesPlus target_tm (evalHub m a b c) cfg' ∧ GoodCfg cfg' := by + unfold checkModeStream at hc + rcases hlist : unpackSuperList tree.toList with _ | ⟨w0, ws⟩ + · simp [hlist] at hc + · rw [hlist] at hc + have htodo := checkStream_sound hm fuel w0 ws _ hc + have hfr := htodo.1 a b c + have hva : varA.eval a b c = a := by simp [varA, Aff3.eval] + have hvb : varB.eval a b c = b := by simp [varB, Aff3.eval] + have hvc : varC.eval a b c = c := by simp [varC, Aff3.eval] + rw [hva, hvb, hvc] at hfr + obtain ⟨cfg', hs, hg⟩ := hfr hinv + rw [evalSymCfg_mkSymCfg, hva, hvb, hvc] at hs + exact ⟨cfg', hs, hg⟩ + +/-! ### Blank-Tape Stem Entry (`init_reaches_entry`, `1,614` Steps) -/ + +theorem init_zip_ok : + simZipNat 1614 0 true initKL 0 initKR 0 = + some (initQOut, initDirOut, initKLOut, initLBOut, initKROut, initRBOut) := by + decide +kernel + +theorem init_hub_ok : + checkHubEq ⟨initQOut, initDirOut, true, + pushBits (unpackBits initKLOut initLBOut) [], + pushBits (unpackBits initKROut initRBOut) []⟩ + 0 (Aff3.const 1) (Aff3.const 0) (Aff3.const 7) = true := by + decide +kernel + +theorem init_reaches_entry : + ReachesStar target_tm (init []) (evalHub 0 1 0 7) ∧ HubInv 0 1 0 7 := by + refine ⟨?_, by simp [HubInv]⟩ + have hsim := simZipNat_sound 1614 0 true initKL 0 initKR 0 + initQOut initDirOut initKLOut initLBOut initKROut initRBOut + default default init_zip_ok + rw [unpackBits_zero_append, unpackBits_zero_append] at hsim + have hinit : (init ([] : List (Fin 2)) : Cfg (Fin 2) (Fin 6)) = + WordRLE.dirCfg qOf 0 true default default := rfl + rw [← hinit] at hsim + have hhub := (checkHubEq_sound init_hub_ok 0 0 0).2 + simp only [evalSymCfg, evalStk_pushBits, evalStk, Aff3.const_eval] at hhub + rw [← hhub] + exact ⟨1614, hsim⟩ + +theorem closed_mode0 : checkModeStream 0 fuelMode0 streamMode0 = true := by + decide +kernel + +theorem closed_mode1 : checkModeStream 1 fuelMode1 streamMode1 = true := by + decide +kernel + +theorem closed_mode2 : checkModeStream 2 fuelMode2 streamMode2 = true := by + decide +kernel + +theorem closed_mode3 : checkModeStream 3 fuelMode3 streamMode3 = true := by + decide +kernel + +theorem closed_mode4 : checkModeStream 4 fuelMode4 streamMode4 = true := by + decide +kernel + +theorem closed_mode5 : checkModeStream 5 fuelMode5 streamMode5 = true := by + decide +kernel + +theorem closed_mode6 : checkModeStream 6 fuelMode6 streamMode6 = true := by + decide +kernel + +theorem goodCfg_closed : + ∀ c, GoodCfg c → ∃ c', ReachesPlus target_tm c c' ∧ GoodCfg c' := by + intro c ⟨m, a, b, c0, hinv, hEq⟩ + subst hEq + have hm : m < 7 := hinv.1 + match m with + | 0 => exact modeStream_sound hm closed_mode0 hinv + | 1 => exact modeStream_sound hm closed_mode1 hinv + | 2 => exact modeStream_sound hm closed_mode2 hinv + | 3 => exact modeStream_sound hm closed_mode3 hinv + | 4 => exact modeStream_sound hm closed_mode4 hinv + | 5 => exact modeStream_sound hm closed_mode5 hinv + | 6 => exact modeStream_sound hm closed_mode6 hinv + | _ + 7 => omega + + + +public section + +theorem is_not_halt : IsNotHalt target := by + obtain ⟨hreach, hinv0⟩ := init_reaches_entry + exact IsNotHalt.of_reachesPlus_invariant hreach ⟨0, 1, 0, 7, hinv0, rfl⟩ goodCfg_closed + +end + +end BusyBeaver.M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD diff --git a/BusyBeaver/BB6/NonHalt/M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD.lean b/BusyBeaver/BB6/NonHalt/M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD.lean new file mode 100644 index 00000000..20d263d7 --- /dev/null +++ b/BusyBeaver/BB6/NonHalt/M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD.lean @@ -0,0 +1,46 @@ +/- +Copyright (c) 2026 Google LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +-/ +module + +import BusyBeaver.Basic +public import BusyBeaver.Bridge +import BusyBeaver.Calculi.Counter +import BusyBeaver.BB6.NonHalt.M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH + +open Mathlib Relation Nat Turing BusyBeaver SixState + +namespace BusyBeaver.M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD + +@[expose] public section + +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD" + +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB + +end + +def stateMap_m0638 : Fin 6 → Fin 6 + | 0 => 1 + | 1 => 2 + | 2 => 3 + | 3 => 4 + | 4 => 5 + | 5 => 0 + +public section + +theorem is_not_halt : IsNotHalt target := by + exact Counter.does_not_halt_of_conj_stem + (M_tgt := target) + (M_src := BusyBeaver.M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH.target) + (σ := stateMap_m0638) (f := true) + (c₁ := (default : ListBlank (Fin 2)) {{5}}> default) + (by decide) (Counter.init_reaches_conjCfg_default rfl) + BusyBeaver.M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH.is_not_halt_from_0638 + +end + +end BusyBeaver.M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD diff --git a/BusyBeaver/BB6/README.md b/BusyBeaver/BB6/README.md index 15830e7f..37256a0b 100644 --- a/BusyBeaver/BB6/README.md +++ b/BusyBeaver/BB6/README.md @@ -1,6 +1,6 @@ # Busy Beaver 6 Holdouts (`BusyBeaver/BB6/`) -This directory contains formal Lean 4 specifications and kernel-verified Collatz-like reductions for 54 Busy Beaver 6 (`BB(6)`, 6-state 2-symbol) holdout Turing machines (the [A6 nonhalting certificate](../../artifacts/a6/README.md) and 53 closed-pattern holdouts, including a Baker-free 2-adic Laurent-determinant non-halting proof for `1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RB---`), together with 35 stacked, odometer, and transducer holdouts (15 machines formalized under `HasStackReduction`, `HasOdometerReduction`, and `HasTransducerReduction`—12 `bbchallenge` Wiki machines and 3 Halving Tower holdouts—plus 20 open acceleration problems under `IsValidAcceleration`, 13 with higher-level accelerations) in **[`BusyBeaver/BB6/Accelerations/`](./Accelerations/README.md)** (89 `BB(6)` holdouts total), alongside 180 resolved `BB(6)` holdouts categorized under **[`BusyBeaver/BB6/Halt/`](./Halt/)** (31 kernel-verified halting machines, `IsHalt`) and **[`BusyBeaver/BB6/NonHalt/`](./NonHalt/)** (149 kernel-verified non-halting machines, `IsNotHalt`), resolving machines from the `bbchallenge` holdout set and `busycoq` formalizations (269 distinct `BB(6)` machines overall). Each machine module in `BusyBeaver/BB6/` below exposes both **Level A** (`ps`, `is_closed_pattern_set`, `has_collatz_reduction`) and **Level B** (`State`, `start`, `encode`, `next`, `is_valid_acceleration`, `isHalt_iff_acceleration`), and 33 modules (all 20 novel discovery modules together with 13 multi-family or multi-counter wiki/busycoq holdouts) additionally expose a higher-level Collatz-like acceleration (`HighLevelState`, `highLevelStart`, `highLevelEncode`, `highLevelNext`, `is_valid_highLevel_acceleration`, `isHalt_iff_highLevel_acceleration`, `acceleration_iff_highLevel_acceleration`); see [`BusyBeaver/README.md`](../README.md) for definitions of the behavioral predicates and [`BusyBeaver/BB6/Accelerations/README.md`](./Accelerations/README.md) for the stacked, odometer, and transducer formalizations and open problem statements. +This directory contains formal Lean 4 specifications and kernel-verified Collatz-like reductions for 54 Busy Beaver 6 (`BB(6)`, 6-state 2-symbol) holdout Turing machines (the [A6 nonhalting certificate](../../artifacts/a6/README.md) and 53 closed-pattern holdouts, including a Baker-free 2-adic Laurent-determinant non-halting proof for `1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RB---`), together with 35 stacked, odometer, and transducer holdouts (15 machines formalized under `HasStackReduction`, `HasOdometerReduction`, and `HasTransducerReduction`—12 `bbchallenge` Wiki machines and 3 Halving Tower holdouts—plus 20 open acceleration problems under `IsValidAcceleration`, 13 with higher-level accelerations) in **[`BusyBeaver/BB6/Accelerations/`](./Accelerations/README.md)** (89 `BB(6)` holdouts total), alongside 191 resolved `BB(6)` holdouts categorized under **[`BusyBeaver/BB6/Halt/`](./Halt/)** (32 kernel-verified halting machines, `IsHalt`) and **[`BusyBeaver/BB6/NonHalt/`](./NonHalt/)** (159 kernel-verified non-halting machines, `IsNotHalt`), resolving machines from the `bbchallenge` holdout set and `busycoq` formalizations (280 distinct `BB(6)` machines overall). Each machine module in `BusyBeaver/BB6/` below exposes both **Level A** (`ps`, `is_closed_pattern_set`, `has_collatz_reduction`) and **Level B** (`State`, `start`, `encode`, `next`, `is_valid_acceleration`, `isHalt_iff_acceleration`), and 33 modules (all 20 novel discovery modules together with 13 multi-family or multi-counter wiki/busycoq holdouts) additionally expose a higher-level Collatz-like acceleration (`HighLevelState`, `highLevelStart`, `highLevelEncode`, `highLevelNext`, `is_valid_highLevel_acceleration`, `isHalt_iff_highLevel_acceleration`, `acceleration_iff_highLevel_acceleration`); see [`BusyBeaver/README.md`](../README.md) for definitions of the behavioral predicates and [`BusyBeaver/BB6/Accelerations/README.md`](./Accelerations/README.md) for the stacked, odometer, and transducer formalizations and open problem statements. The A6 module exports a closed blank-tape `IsNotHalt` proof using a checked entry certificate and a universal return family; it has a separate @@ -1024,12 +1024,12 @@ Under $(a, d) = (c, b + 1)$ (for $d \ge 1$), this map is identical to that of [` ## Resolved `BB(6)` Machines -This directory formalizes 181 resolved `BB(6)` Turing machines reproducing community proofs and `busycoq` results directly verified in Lean 4 without axioms (`sorry`-free and `native_decide`-free kernel verification): +This directory formalizes 192 resolved `BB(6)` Turing machines reproducing community proofs and `busycoq` results directly verified in Lean 4 without axioms (`sorry`-free and `native_decide`-free kernel verification): -- **[`BusyBeaver/BB6/Halt/`](./Halt/)**: 31 resolved halting machines (`IsHalt`), each reaching a halting configuration from `init []` with verified multi-step traces. -- **[`BusyBeaver/BB6/NonHalt/`](./NonHalt/)**: 150 resolved non-halting machines (`IsNotHalt`), verified via inductive invariants, simulated cycles, or closed-set reachability certificates. +- **[`BusyBeaver/BB6/Halt/`](./Halt/)**: 32 resolved halting machines (`IsHalt`), each reaching a halting configuration from `init []` with verified multi-step traces. +- **[`BusyBeaver/BB6/NonHalt/`](./NonHalt/)**: 160 resolved non-halting machines (`IsNotHalt`), verified via inductive invariants, simulated cycles, or closed-set reachability certificates. -### Resolved BB(6) Halt Machines (31 machines) +### Resolved BB(6) Halt Machines (32 machines) | Machine (`bbchallenge` RLE) | States | Symbols | Proved Property | Origin / Wiki | Lean 4 Proof | | :--- | :--- | :--- | :--- | :--- | :--- | @@ -1051,6 +1051,7 @@ This directory formalizes 181 resolved `BB(6)` Turing machines reproducing commu | `1RB0RD_1LC0RA_---1RD_1RA1LE_1RC0LF_1LE0LB` | `6` | `2` | `IsHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RD_1LC0RA_---1RD_1RA1LE_1RC0LF_1LE0LB) | [`M_1RB0RD_1LC0RA_HHH1RD_1RA1LE_1RC0LF_1LE0LB.lean`](./Halt/M_1RB0RD_1LC0RA_HHH1RD_1RA1LE_1RC0LF_1LE0LB.lean) | | `1RB0RD_1LC1RE_1LA0LD_0RE0RF_1LC1RA_0LE---` | `6` | `2` | `IsHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RD_1LC1RE_1LA0LD_0RE0RF_1LC1RA_0LE---) | [`M_1RB0RD_1LC1RE_1LA0LD_0RE0RF_1LC1RA_0LEHHH.lean`](./Halt/M_1RB0RD_1LC1RE_1LA0LD_0RE0RF_1LC1RA_0LEHHH.lean) | | `1RB0RD_1RC0LC_1RE1RA_0LD1LA_0LF0LD_0RE---` | `6` | `2` | `IsHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RD_1RC0LC_1RE1RA_0LD1LA_0LF0LD_0RE---) | [`M_1RB0RD_1RC0LC_1RE1RA_0LD1LA_0LF0LD_0REHHH.lean`](./Halt/M_1RB0RD_1RC0LC_1RE1RA_0LD1LA_0LF0LD_0REHHH.lean) | +| `1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LC---` | `6` | `2` | `IsHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LC---) | [`M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH.lean`](./Halt/M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH.lean) | | `1RB0RF_0RC1RD_0LD---_1LE1RA_1LA0LF_0RD0RC` | `6` | `2` | `IsHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_0RC1RD_0LD---_1LE1RA_1LA0LF_0RD0RC) | [`M_1RB0RF_0RC1RD_0LDHHH_1LE1RA_1LA0LF_0RD0RC.lean`](./Halt/M_1RB0RF_0RC1RD_0LDHHH_1LE1RA_1LA0LF_0RD0RC.lean) | | `1RB0RF_1LC1RE_1LD0LC_0LE0RE_1RA1LD_1RB---` | `6` | `2` | `IsHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_1LC1RE_1LD0LC_0LE0RE_1RA1LD_1RB---) | [`M_1RB0RF_1LC1RE_1LD0LC_0LE0RE_1RA1LD_1RBHHH.lean`](./Halt/M_1RB0RF_1LC1RE_1LD0LC_0LE0RE_1RA1LD_1RBHHH.lean) | | `1RB0RF_1RC0RB_1LD1RA_1LE0LD_1RB0LA_0LD---` | `6` | `2` | `IsHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_1RC0RB_1LD1RA_1LE0LD_1RB0LA_0LD---) | [`M_1RB0RF_1RC0RB_1LD1RA_1LE0LD_1RB0LA_0LDHHH.lean`](./Halt/M_1RB0RF_1RC0RB_1LD1RA_1LE0LD_1RB0LA_0LDHHH.lean) | @@ -1065,7 +1066,7 @@ This directory formalizes 181 resolved `BB(6)` Turing machines reproducing commu | `1RB1RF_1LC0RA_---0LD_1RE1LD_0LF0LB_1RA1LE` | `6` | `2` | `IsHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1RF_1LC0RA_---0LD_1RE1LD_0LF0LB_1RA1LE) | [`M_1RB1RF_1LC0RA_HHH0LD_1RE1LD_0LF0LB_1RA1LE.lean`](./Halt/M_1RB1RF_1LC0RA_HHH0LD_1RE1LD_0LF0LB_1RA1LE.lean) | | `1RB---_1LC1RE_1LA0LD_0RE1LC_1LC1RF_1RB0RD` | `6` | `2` | `IsHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB---_1LC1RE_1LA0LD_0RE1LC_1LC1RF_1RB0RD) | [`M_1RBHHH_1LC1RE_1LA0LD_0RE1LC_1LC1RF_1RB0RD.lean`](./Halt/M_1RBHHH_1LC1RE_1LA0LD_0RE1LC_1LC1RF_1RB0RD.lean) | -### Resolved BB(6) NonHalt Machines (150 machines) +### Resolved BB(6) NonHalt Machines (160 machines) | Machine (`bbchallenge` RLE) | States | Symbols | Proved Property | Origin / Wiki | Lean 4 Proof | | :--- | :--- | :--- | :--- | :--- | :--- | @@ -1085,6 +1086,7 @@ This directory formalizes 181 resolved `BB(6)` Turing machines reproducing commu | `1RB0LC_1LA0RE_0RD1LF_1LC1LB_0LD0RB_0LA---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0LC_1LA0RE_0RD1LF_1LC1LB_0LD0RB_0LA---) | [`M_1RB0LC_1LA0RE_0RD1LF_1LC1LB_0LD0RB_0LAHHH.lean`](./NonHalt/M_1RB0LC_1LA0RE_0RD1LF_1LC1LB_0LD0RB_0LAHHH.lean) | | `1RB0LC_1LC0RE_1LA1LD_1LA1LB_0RF1RA_---0RE` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0LC_1LC0RE_1LA1LD_1LA1LB_0RF1RA_---0RE) | [`M_1RB0LC_1LC0RE_1LA1LD_1LA1LB_0RF1RA_HHH0RE.lean`](./NonHalt/M_1RB0LC_1LC0RE_1LA1LD_1LA1LB_0RF1RA_HHH0RE.lean) | | `1RB0LC_1LC0RE_1LA1LD_1LA1LF_0RB1RA_1LC---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0LC_1LC0RE_1LA1LD_1LA1LF_0RB1RA_1LC---) | [`M_1RB0LC_1LC0RE_1LA1LD_1LA1LF_0RB1RA_1LCHHH.lean`](./NonHalt/M_1RB0LC_1LC0RE_1LA1LD_1LA1LF_0RB1RA_1LCHHH.lean) | +| `1RB0LC_1RC0RA_1RD0RF_0LE---_1LB1LA_1LD1RA` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0LC_1RC0RA_1RD0RF_0LE---_1LB1LA_1LD1RA) | [`M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA.lean`](./NonHalt/M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA.lean) | | `1RB0LD_1LC1RB_0LA0LD_1LE0RB_1RF0RE_---0RD` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0LD_1LC1RB_0LA0LD_1LE0RB_1RF0RE_---0RD) | [`M_1RB0LD_1LC1RB_0LA0LD_1LE0RB_1RF0RE_HHH0RD.lean`](./NonHalt/M_1RB0LD_1LC1RB_0LA0LD_1LE0RB_1RF0RE_HHH0RD.lean) | | `1RB0LD_1RC0RA_1RD1RF_1LA0LE_1RE1LD_0RB---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0LD_1RC0RA_1RD1RF_1LA0LE_1RE1LD_0RB---) | [`M_1RB0LD_1RC0RA_1RD1RF_1LA0LE_1RE1LD_0RBHHH.lean`](./NonHalt/M_1RB0LD_1RC0RA_1RD1RF_1LA0LE_1RE1LD_0RBHHH.lean) | | `1RB0LD_1RC0RE_1LD0RE_1LA0LA_1RB1RF_1RB---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0LD_1RC0RE_1LD0RE_1LA0LA_1RB1RF_1RB---) | [`M_1RB0LD_1RC0RE_1LD0RE_1LA0LA_1RB1RF_1RBHHH.lean`](./NonHalt/M_1RB0LD_1RC0RE_1LD0RE_1LA0LA_1RB1RF_1RBHHH.lean) | @@ -1093,6 +1095,7 @@ This directory formalizes 181 resolved `BB(6)` Turing machines reproducing commu | `1RB0LE_1RC0LF_0LD0RC_1RA1LD_1LB0LE_---0RE` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0LE_1RC0LF_0LD0RC_1RA1LD_1LB0LE_---0RE) | [`M_1RB0LE_1RC0LF_0LD0RC_1RA1LD_1LB0LE_HHH0RE.lean`](./NonHalt/M_1RB0LE_1RC0LF_0LD0RC_1RA1LD_1LB0LE_HHH0RE.lean) | | `1RB0LE_1RC0RC_1LD0RB_1LA0LE_1LD1LF_1LD---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0LE_1RC0RC_1LD0RB_1LA0LE_1LD1LF_1LD---) | [`M_1RB0LE_1RC0RC_1LD0RB_1LA0LE_1LD1LF_1LDHHH.lean`](./NonHalt/M_1RB0LE_1RC0RC_1LD0RB_1LA0LE_1LD1LF_1LDHHH.lean) | | `1RB0LE_1RC1LA_1LD1RE_1LB0LD_1RF0RC_1RB---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0LE_1RC1LA_1LD1RE_1LB0LD_1RF0RC_1RB---) | [`M_1RB0LE_1RC1LA_1LD1RE_1LB0LD_1RF0RC_1RBHHH.lean`](./NonHalt/M_1RB0LE_1RC1LA_1LD1RE_1LB0LD_1RF0RC_1RBHHH.lean) | +| `1RB0LE_1RC---_0RD0RB_1RE0LA_1RF0LF_1LD1RF` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0LE_1RC---_0RD0RB_1RE0LA_1RF0LF_1LD1RF) | [`M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF.lean`](./NonHalt/M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF.lean) | | `1RB0LF_0RC---_1RD0RA_1LE0RC_0LA0LE_1LE1LB` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0LF_0RC---_1RD0RA_1LE0RC_0LA0LE_1LE1LB) | [`M_1RB0LF_0RCHHH_1RD0RA_1LE0RC_0LA0LE_1LE1LB.lean`](./NonHalt/M_1RB0LF_0RCHHH_1RD0RA_1LE0RC_0LA0LE_1LE1LB.lean) | | `1RB0RA_0LC0LA_1RF1LD_1LE0LD_1LC1LF_---1RA` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RA_0LC0LA_1RF1LD_1LE0LD_1LC1LF_---1RA) | [`M_1RB0RA_0LC0LA_1RF1LD_1LE0LD_1LC1LF_HHH1RA.lean`](./NonHalt/M_1RB0RA_0LC0LA_1RF1LD_1LE0LD_1LC1LF_HHH1RA.lean) | | `1RB0RA_0RC0RE_0LD---_1LE1LD_1LF0LD_1RA0RD` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RA_0RC0RE_0LD---_1LE1LD_1LF0LD_1RA0RD) | [`M_1RB0RA_0RC0RE_0LDHHH_1LE1LD_1LF0LD_1RA0RD.lean`](./NonHalt/M_1RB0RA_0RC0RE_0LDHHH_1LE1LD_1LF0LD_1RA0RD.lean) | @@ -1106,8 +1109,10 @@ This directory formalizes 181 resolved `BB(6)` Turing machines reproducing commu | `1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LC---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LC---) | [`M_1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LCHHH.lean`](./NonHalt/M_1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LCHHH.lean) | | `1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LD---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LD---) | [`M_1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LDHHH.lean`](./NonHalt/M_1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LDHHH.lean) | | `1RB0RA_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RB---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RA_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RB---) | [`M_1RB0RA_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RBHHH.lean`](./NonHalt/M_1RB0RA_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RBHHH.lean) | +| `1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LE---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LE---) | [`M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH.lean`](./NonHalt/M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH.lean) | | `1RB0RA_1RC0LE_1LD0RA_---1LE_0RE0LF_1LB1LC` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RA_1RC0LE_1LD0RA_---1LE_0RE0LF_1LB1LC) | [`M_1RB0RA_1RC0LE_1LD0RA_HHH1LE_0RE0LF_1LB1LC.lean`](./NonHalt/M_1RB0RA_1RC0LE_1LD0RA_HHH1LE_0RE0LF_1LB1LC.lean) | | `1RB0RA_1RC0RC_1LD0LE_1RA1LC_1LC1LF_0LC---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RA_1RC0RC_1LD0LE_1RA1LC_1LC1LF_0LC---) | [`M_1RB0RA_1RC0RC_1LD0LE_1RA1LC_1LC1LF_0LCHHH.lean`](./NonHalt/M_1RB0RA_1RC0RC_1LD0LE_1RA1LC_1LC1LF_0LCHHH.lean) | +| `1RB0RA_1RC0RC_1LD1RF_---1LE_1RF0LF_1RA0LE` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RA_1RC0RC_1LD1RF_---1LE_1RF0LF_1RA0LE) | [`M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE.lean`](./NonHalt/M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE.lean) | | `1RB0RA_1RC0RD_1LD1LE_1LF0LC_0LD---_1RA1LD` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RA_1RC0RD_1LD1LE_1LF0LC_0LD---_1RA1LD) | [`M_1RB0RA_1RC0RD_1LD1LE_1LF0LC_0LDHHH_1RA1LD.lean`](./NonHalt/M_1RB0RA_1RC0RD_1LD1LE_1LF0LC_0LDHHH_1RA1LD.lean) | | `1RB0RA_1RC0RE_1RD---_1LE1LD_1LF0LD_1RA1LE` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RA_1RC0RE_1RD---_1LE1LD_1LF0LD_1RA1LE) | [`M_1RB0RA_1RC0RE_1RDHHH_1LE1LD_1LF0LD_1RA1LE.lean`](./NonHalt/M_1RB0RA_1RC0RE_1RDHHH_1LE1LD_1LF0LD_1RA1LE.lean) | | `1RB0RB_1LC0LE_1RD1LB_1RA0RD_1LB1LF_0LA---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RB_1LC0LE_1RD1LB_1RA0RD_1LB1LF_0LA---) | [`M_1RB0RB_1LC0LE_1RD1LB_1RA0RD_1LB1LF_0LAHHH.lean`](./NonHalt/M_1RB0RB_1LC0LE_1RD1LB_1RA0RD_1LB1LF_0LAHHH.lean) | @@ -1118,6 +1123,7 @@ This directory formalizes 181 resolved `BB(6)` Turing machines reproducing commu | `1RB0RC_1LC0LD_1RA1RC_1RA1LE_0LB1RE_---1RA` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RC_1LC0LD_1RA1RC_1RA1LE_0LB1RE_---1RA) | [`M_1RB0RC_1LC0LD_1RA1RC_1RA1LE_0LB1RE_HHH1RA.lean`](./NonHalt/M_1RB0RC_1LC0LD_1RA1RC_1RA1LE_0LB1RE_HHH1RA.lean) | | `1RB0RC_1LC1LF_1LD0LB_1RE1LC_1RA0RE_0LC---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RC_1LC1LF_1LD0LB_1RE1LC_1RA0RE_0LC---) | [`M_1RB0RC_1LC1LF_1LD0LB_1RE1LC_1RA0RE_0LCHHH.lean`](./NonHalt/M_1RB0RC_1LC1LF_1LD0LB_1RE1LC_1RA0RE_0LCHHH.lean) | | `1RB0RC_1LC1RA_0RF0LD_1LE0RB_1LB0LD_---1RD` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RC_1LC1RA_0RF0LD_1LE0RB_1LB0LD_---1RD) | [`M_1RB0RC_1LC1RA_0RF0LD_1LE0RB_1LB0LD_HHH1RD.lean`](./NonHalt/M_1RB0RC_1LC1RA_0RF0LD_1LE0RB_1LB0LD_HHH1RD.lean) | +| `1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_---0RB` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_---0RB) | [`M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB.lean`](./NonHalt/M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB.lean) | | `1RB0RC_1LC1RD_1RA1LE_1LA0RD_0LE1RF_1LB---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RC_1LC1RD_1RA1LE_1LA0RD_0LE1RF_1LB---) | [`M_1RB0RC_1LC1RD_1RA1LE_1LA0RD_0LE1RF_1LBHHH.lean`](./NonHalt/M_1RB0RC_1LC1RD_1RA1LE_1LA0RD_0LE1RF_1LBHHH.lean) | | `1RB0RD_0LC0RA_1LA1LC_1RE0LF_0RA1RF_1LB---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RD_0LC0RA_1LA1LC_1RE0LF_0RA1RF_1LB---) | [`M_1RB0RD_0LC0RA_1LA1LC_1RE0LF_0RA1RF_1LBHHH.lean`](./NonHalt/M_1RB0RD_0LC0RA_1LA1LC_1RE0LF_0RA1RF_1LBHHH.lean) | | `1RB0RD_0RC0LB_0RD1RD_1LE1RA_1RC1LF_---1LA` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RD_0RC0LB_0RD1RD_1LE1RA_1RC1LF_---1LA) | [`M_1RB0RD_0RC0LB_0RD1RD_1LE1RA_1RC1LF_HHH1LA.lean`](./NonHalt/M_1RB0RD_0RC0LB_0RD1RD_1LE1RA_1RC1LF_HHH1LA.lean) | @@ -1140,12 +1146,14 @@ This directory formalizes 181 resolved `BB(6)` Turing machines reproducing commu | `1RB0RE_1RC1LF_0LD0RE_---1LE_1RA0LB_1LB0LC` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RE_1RC1LF_0LD0RE_---1LE_1RA0LB_1LB0LC) | [`M_1RB0RE_1RC1LF_0LD0RE_HHH1LE_1RA0LB_1LB0LC.lean`](./NonHalt/M_1RB0RE_1RC1LF_0LD0RE_HHH1LE_1RA0LB_1LB0LC.lean) | | `1RB0RE_1RC1RE_1LD1RA_1LA0LD_0RA0LF_1LD---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RE_1RC1RE_1LD1RA_1LA0LD_0RA0LF_1LD---) | [`M_1RB0RE_1RC1RE_1LD1RA_1LA0LD_0RA0LF_1LDHHH.lean`](./NonHalt/M_1RB0RE_1RC1RE_1LD1RA_1LA0LD_0RA0LF_1LDHHH.lean) | | `1RB0RE_1RC---_0LD1LE_0RE1LD_1RF0LC_0RA1RE` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RE_1RC---_0LD1LE_0RE1LD_1RF0LC_0RA1RE) | [`M_1RB0RE_1RCHHH_0LD1LE_0RE1LD_1RF0LC_0RA1RE.lean`](./NonHalt/M_1RB0RE_1RCHHH_0LD1LE_0RE1LD_1RF0LC_0RA1RE.lean) | +| `1RB0RF_0LC---_1LE1LD_1RE0LA_1RA0RD_1LB1RD` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_0LC---_1LE1LD_1RE0LA_1RA0RD_1LB1RD) | [`M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD.lean`](./NonHalt/M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD.lean) | | `1RB0RF_1LC0LF_1LD0LC_0LE0LA_1LF---_1RA1RF` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_1LC0LF_1LD0LC_0LE0LA_1LF---_1RA1RF) | [`M_1RB0RF_1LC0LF_1LD0LC_0LE0LA_1LFHHH_1RA1RF.lean`](./NonHalt/M_1RB0RF_1LC0LF_1LD0LC_0LE0LA_1LFHHH_1RA1RF.lean) | | `1RB0RF_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RB---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RB---) | [`M_1RB0RF_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RBHHH.lean`](./NonHalt/M_1RB0RF_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RBHHH.lean) | | `1RB0RF_1LC1RA_1LD0LC_0LE0LA_0RF---_1RA1RF` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_1LC1RA_1LD0LC_0LE0LA_0RF---_1RA1RF) | [`M_1RB0RF_1LC1RA_1LD0LC_0LE0LA_0RFHHH_1RA1RF.lean`](./NonHalt/M_1RB0RF_1LC1RA_1LD0LC_0LE0LA_0RFHHH_1RA1RF.lean) | | `1RB0RF_1LC1RA_1LD0LC_0LE0LA_1RF---_1RA1RE` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_1LC1RA_1LD0LC_0LE0LA_1RF---_1RA1RE) | [`M_1RB0RF_1LC1RA_1LD0LC_0LE0LA_1RFHHH_1RA1RE.lean`](./NonHalt/M_1RB0RF_1LC1RA_1LD0LC_0LE0LA_1RFHHH_1RA1RE.lean) | | `1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LF---_1RA1RB` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LF---_1RA1RB) | [`M_1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LFHHH_1RA1RB.lean`](./NonHalt/M_1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LFHHH_1RA1RB.lean) | | `1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LF---_1RA1RF` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LF---_1RA1RF) | [`M_1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LFHHH_1RA1RF.lean`](./NonHalt/M_1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LFHHH_1RA1RF.lean) | +| `1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LA---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LA---) | [`M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH.lean`](./NonHalt/M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH.lean) | | `1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RA---_0RA0LB` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RA---_0RA0LB) | [`M_1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RAHHH_0RA0LB.lean`](./NonHalt/M_1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RAHHH_0RA0LB.lean) | | `1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RA---_0RE0LB` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RA---_0RE0LB) | [`M_1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RAHHH_0RE0LB.lean`](./NonHalt/M_1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RAHHH_0RE0LB.lean) | | `1RB0RF_1RC1RF_1LD0RE_---0LE_1LA0LE_0RA0LC` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB0RF_1RC1RF_1LD0RE_---0LE_1LA0LE_0RA0LC) | [`M_1RB0RF_1RC1RF_1LD0RE_HHH0LE_1LA0LE_0RA0LC.lean`](./NonHalt/M_1RB0RF_1RC1RF_1LD0RE_HHH0LE_1LA0LE_0RA0LC.lean) | @@ -1154,7 +1162,7 @@ This directory formalizes 181 resolved `BB(6)` Turing machines reproducing commu | `1RB1LA_1LA1RC_1RD0RB_1LE0LF_---1LD_0LE1LA` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LA_1LA1RC_1RD0RB_1LE0LF_---1LD_0LE1LA) | [`M_1RB1LA_1LA1RC_1RD0RB_1LE0LF_HHH1LD_0LE1LA.lean`](./NonHalt/M_1RB1LA_1LA1RC_1RD0RB_1LE0LF_HHH1LD_0LE1LA.lean) | | `1RB1LA_1LC0RA_0LD1RC_---0LE_0LF1LE_1RF1LB` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LA_1LC0RA_0LD1RC_---0LE_0LF1LE_1RF1LB) | [`M_1RB1LA_1LC0RA_0LD1RC_HHH0LE_0LF1LE_1RF1LB.lean`](./NonHalt/M_1RB1LA_1LC0RA_0LD1RC_HHH0LE_0LF1LE_1RF1LB.lean) | | `1RB1LA_1RC0LE_1RD0LF_0LA0RD_1LC0LE_---0RE` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LA_1RC0LE_1RD0LF_0LA0RD_1LC0LE_---0RE) | [`M_1RB1LA_1RC0LE_1RD0LF_0LA0RD_1LC0LE_HHH0RE.lean`](./NonHalt/M_1RB1LA_1RC0LE_1RD0LF_0LA0RD_1LC0LE_HHH0RE.lean) | -| `1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RB---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RB---) | [`M_1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RBHHH.lean`](./NonHalt/M_1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RBHHH.lean) | +| `1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RB---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RB---) | [`M_1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RBHHH.lean`](./M_1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RBHHH.lean) | | `1RB1LB_1LC0LF_1LD0RC_1RE0LA_1RE1RC_---0LE` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LB_1LC0LF_1LD0RC_1RE0LA_1RE1RC_---0LE) | [`M_1RB1LB_1LC0LF_1LD0RC_1RE0LA_1RE1RC_HHH0LE.lean`](./NonHalt/M_1RB1LB_1LC0LF_1LD0RC_1RE0LA_1RE1RC_HHH0LE.lean) | | `1RB1LB_1LC1RB_1RF1LD_0LE0LC_0RC---_1LA0RF` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LB_1LC1RB_1RF1LD_0LE0LC_0RC---_1LA0RF) | [`M_1RB1LB_1LC1RB_1RF1LD_0LE0LC_0RCHHH_1LA0RF.lean`](./NonHalt/M_1RB1LB_1LC1RB_1RF1LD_0LE0LC_0RCHHH_1LA0RF.lean) | | `1RB1LB_1RC0LA_1LD1RF_1RB0LE_---1LA_1RD0RD` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LB_1RC0LA_1LD1RF_1RB0LE_---1LA_1RD0RD) | [`M_1RB1LB_1RC0LA_1LD1RF_1RB0LE_HHH1LA_1RD0RD.lean`](./NonHalt/M_1RB1LB_1RC0LA_1LD1RF_1RB0LE_HHH1LA_1RD0RD.lean) | @@ -1171,9 +1179,11 @@ This directory formalizes 181 resolved `BB(6)` Turing machines reproducing commu | `1RB1LE_1LC0RF_1LA0RD_1LC1RC_1LB0LB_---1RD` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LE_1LC0RF_1LA0RD_1LC1RC_1LB0LB_---1RD) | [`M_1RB1LE_1LC0RF_1LA0RD_1LC1RC_1LB0LB_HHH1RD.lean`](./NonHalt/M_1RB1LE_1LC0RF_1LA0RD_1LC1RC_1LB0LB_HHH1RD.lean) | | `1RB1LE_1LC1RD_0LA1LA_---1RE_1LF0LA_0LC0RF` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LE_1LC1RD_0LA1LA_---1RE_1LF0LA_0LC0RF) | [`M_1RB1LE_1LC1RD_0LA1LA_HHH1RE_1LF0LA_0LC0RF.lean`](./NonHalt/M_1RB1LE_1LC1RD_0LA1LA_HHH1RE_1LF0LA_0LC0RF.lean) | | `1RB1LF_0RC0RB_0LD1LA_1LC0LE_0LA---_1LA1LF` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LF_0RC0RB_0LD1LA_1LC0LE_0LA---_1LA1LF) | [`M_1RB1LF_0RC0RB_0LD1LA_1LC0LE_0LAHHH_1LA1LF.lean`](./NonHalt/M_1RB1LF_0RC0RB_0LD1LA_1LC0LE_0LAHHH_1LA1LF.lean) | +| `1RB1LF_0RC---_1RD1RF_1LE0LF_1LB0LA_1LD0RE` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LF_0RC---_1RD1RF_1LE0LF_1LB0LA_1LD0RE) | [`M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE.lean`](./NonHalt/M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE.lean) | | `1RB1LF_1LC1RB_1RE1LD_1LB0LC_1LA0RE_1LD---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LF_1LC1RB_1RE1LD_1LB0LC_1LA0RE_1LD---) | [`M_1RB1LF_1LC1RB_1RE1LD_1LB0LC_1LA0RE_1LDHHH.lean`](./NonHalt/M_1RB1LF_1LC1RB_1RE1LD_1LB0LC_1LA0RE_1LDHHH.lean) | | `1RB1LF_1RC0RB_1RD0RF_1RE---_1LF1LA_1LA0LE` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LF_1RC0RB_1RD0RF_1RE---_1LF1LA_1LA0LE) | [`M_1RB1LF_1RC0RB_1RD0RF_1REHHH_1LF1LA_1LA0LE.lean`](./NonHalt/M_1RB1LF_1RC0RB_1RD0RF_1REHHH_1LF1LA_1LA0LE.lean) | | `1RB1LF_1RC0RB_1RD0RF_1RE---_1LF1LE_1LA0LE` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1LF_1RC0RB_1RD0RF_1RE---_1LF1LE_1LA0LE) | [`M_1RB1LF_1RC0RB_1RD0RF_1REHHH_1LF1LE_1LA0LE.lean`](./NonHalt/M_1RB1LF_1RC0RB_1RD0RF_1REHHH_1LF1LE_1LA0LE.lean) | +| `1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_---0LD` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_---0LD) | [`M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD.lean`](./NonHalt/M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD.lean) | | `1RB1RA_1LC1LE_0LD0LB_0RA0RF_0LC0RA_1RD---` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1RA_1LC1LE_0LD0LB_0RA0RF_0LC0RA_1RD---) | [`M_1RB1RA_1LC1LE_0LD0LB_0RA0RF_0LC0RA_1RDHHH.lean`](./NonHalt/M_1RB1RA_1LC1LE_0LD0LB_0RA0RF_0LC0RA_1RDHHH.lean) | | `1RB1RA_1LC1LE_1RF1LD_1RE0LD_0LB0RA_---0RC` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1RA_1LC1LE_1RF1LD_1RE0LD_0LB0RA_---0RC) | [`M_1RB1RA_1LC1LE_1RF1LD_1RE0LD_0LB0RA_HHH0RC.lean`](./NonHalt/M_1RB1RA_1LC1LE_1RF1LD_1RE0LD_0LB0RA_HHH0RC.lean) | | `1RB1RA_1LC1RE_0LD0LD_0LE1LF_1LA0RA_---1LC` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB1RA_1LC1RE_0LD0LD_0LE1LF_1LA0RA_---1LC) | [`M_1RB1RA_1LC1RE_0LD0LD_0LE1LF_1LA0RA_HHH1LC.lean`](./NonHalt/M_1RB1RA_1LC1RE_0LD0LD_0LE1LF_1LA0RA_HHH1LC.lean) | @@ -1206,6 +1216,7 @@ This directory formalizes 181 resolved `BB(6)` Turing machines reproducing commu | `1RB---_0RC0RA_1RD1RC_1LE1LF_0LB0LD_0LE0RC` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB---_0RC0RA_1RD1RC_1LE1LF_0LB0LD_0LE0RC) | [`M_1RBHHH_0RC0RA_1RD1RC_1LE1LF_0LB0LD_0LE0RC.lean`](./NonHalt/M_1RBHHH_0RC0RA_1RD1RC_1LE1LF_0LB0LD_0LE0RC.lean) | | `1RB---_0RC1LF_0RD1RB_1LE1RC_0LB0LE_0LE0LA` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB---_0RC1LF_0RD1RB_1LE1RC_0LB0LE_0LE0LA) | [`M_1RBHHH_0RC1LF_0RD1RB_1LE1RC_0LB0LE_0LE0LA.lean`](./NonHalt/M_1RBHHH_0RC1LF_0RD1RB_1LE1RC_0LB0LE_0LE0LA.lean) | | `1RB---_0RC1LF_1LC1LD_1RE0RA_0RD1RF_0LD0LF` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB---_0RC1LF_1LC1LD_1RE0RA_0RD1RF_0LD0LF) | [`M_1RBHHH_0RC1LF_1LC1LD_1RE0RA_0RD1RF_0LD0LF.lean`](./NonHalt/M_1RBHHH_0RC1LF_1LC1LD_1RE0RA_0RD1RF_0LD0LF.lean) | +| `1RB---_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB---_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD) | [`M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD.lean`](./NonHalt/M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD.lean) | | `1RB---_1LC0LF_1RD1LB_1RE0RD_1LB0RB_1LB0LA` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB---_1LC0LF_1RD1LB_1RE0RD_1LB0RB_1LB0LA) | [`M_1RBHHH_1LC0LF_1RD1LB_1RE0RD_1LB0RB_1LB0LA.lean`](./NonHalt/M_1RBHHH_1LC0LF_1RD1LB_1RE0RD_1LB0RB_1LB0LA.lean) | | `1RB---_1LC0RC_0LD0LC_1RE1RA_0RD1LF_0LE0LF` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB---_1LC0RC_0LD0LC_1RE1RA_0RD1LF_0LE0LF) | [`M_1RBHHH_1LC0RC_0LD0LC_1RE1RA_0RD1LF_0LE0LF.lean`](./NonHalt/M_1RBHHH_1LC0RC_0LD0LC_1RE1RA_0RD1LF_0LE0LF.lean) | | `1RB---_1LC1LB_1LD0LB_1RE1LC_1RF0RE_0RA0RC` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB---_1LC1LB_1LD0LB_1RE1LC_1RF0RE_0RA0RC) | [`M_1RBHHH_1LC1LB_1LD0LB_1RE1LC_1RF0RE_0RA0RC.lean`](./NonHalt/M_1RBHHH_1LC1LB_1LD0LB_1RE1LC_1RF0RE_0RA0RC.lean) | @@ -1219,4 +1230,3 @@ This directory formalizes 181 resolved `BB(6)` Turing machines reproducing commu | `1RB---_1RC1LF_1LD1RE_1LB0LD_1RA0RC_1RC0LE` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB---_1RC1LF_1LD1RE_1LB0LD_1RA0RC_1RC0LE) | [`M_1RBHHH_1RC1LF_1LD1RE_1LB0LD_1RA0RC_1RC0LE.lean`](./NonHalt/M_1RBHHH_1RC1LF_1LD1RE_1LB0LD_1RA0RC_1RC0LE.lean) | | `1RB---_1RC1RA_1RD0RB_1LE1RC_1LF0LE_1RC0LC` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB---_1RC1RA_1RD0RB_1LE1RC_1LF0LE_1RC0LC) | [`M_1RBHHH_1RC1RA_1RD0RB_1LE1RC_1LF0LE_1RC0LC.lean`](./NonHalt/M_1RBHHH_1RC1RA_1RD0RB_1LE1RC_1LF0LE_1RC0LC.lean) | | `1RB---_1RC1RE_1LD0RC_0RE0LD_1LC0LF_1RA0RF` | `6` | `2` | `IsNotHalt` | [Wiki](https://wiki.bbchallenge.org/wiki/1RB---_1RC1RE_1LD0RC_0RE0LD_1LC0LF_1RA0RF) | [`M_1RBHHH_1RC1RE_1LD0RC_0RE0LD_1LC0LF_1RA0RF.lean`](./NonHalt/M_1RBHHH_1RC1RE_1LD0RC_0RE0LD_1LC0LF_1RA0RF.lean) | - diff --git a/BusyBeaver/Calculi/SegCount.lean b/BusyBeaver/Calculi/SegCount.lean new file mode 100644 index 00000000..33784920 --- /dev/null +++ b/BusyBeaver/Calculi/SegCount.lean @@ -0,0 +1,41 @@ +/- +Copyright (c) 2026 Google LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +-/ +module + +public import BusyBeaver.Basic +public import BusyBeaver.Calculi.Longitudinal + +open Mathlib Relation Nat Turing BusyBeaver + +namespace BusyBeaver.SegCount + +open BusyBeaver.Longitudinal + +@[expose] public section + +variable {Γ Λ : Type*} [Inhabited Γ] [Inhabited Λ] + +def runSteps (M : Machine Γ Λ) : ℕ → BoundedConfig.BCfg Γ Λ → BoundedConfig.BCfg Γ Λ + | 0, x => x + | n + 1, x => + match BoundedConfig.step M x with + | none => x + | some x' => runSteps M n x' + +theorem runSteps_spec (M : Machine Γ Λ) (n : ℕ) (x y : BoundedConfig.BCfg Γ Λ) + (h : runSteps M n x = y) (l₀ r₀ : ListBlank Γ) : + (BoundedConfig.toCfg x l₀ r₀) [M]⊢* (BoundedConfig.toCfg y l₀ r₀) := by + subst h + induction n generalizing x with + | zero => exact stepStar_refl M _ + | succ n ih => + dsimp [runSteps] + rcases hstep : BoundedConfig.step M x with _ | x' + · exact stepStar_refl M _ + · exact stepStar_trans ⟨1, BoundedConfig.step_spec M x hstep l₀ r₀⟩ (ih x') + +end + +end BusyBeaver.SegCount diff --git a/BusyBeaver/README.md b/BusyBeaver/README.md index 13e7fa3b..3be39eee 100644 --- a/BusyBeaver/README.md +++ b/BusyBeaver/README.md @@ -2,7 +2,7 @@ This library contains formal Lean 4 specifications and kernel-verified behavioral proofs for Busy Beaver 6 (`BB(6)`) and Busy Beaver (3, 3) (`BB(3, 3)`) holdouts, connected to `ConjectureMachines.Machine` via [`BusyBeaver/Bridge.lean`](./Bridge.lean): -- **[`BusyBeaver/BB6/`](./BB6/README.md)** — 269 `BB(6)` (6-state, 2-symbol) Turing machines: 54 holdouts in `BB6/` (the [A6 nonhalting certificate](../artifacts/a6/README.md) and 53 holdouts with certified closed `TapePatternSet` invariants `IsClosedPatternSet`, `HasCollatzReduction` and Collatz-like accelerations `IsValidAcceleration`, including a self-contained, Baker-free 2-adic Laurent-determinant `IsNotHalt` proof for `1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RB---`), plus 35 stacked, odometer, and transducer holdouts (15 machines formalized under `HasStackReduction`, `HasOdometerReduction`, and `HasTransducerReduction`—12 `bbchallenge` Wiki machines and 3 Halving Tower holdouts—and 20 open acceleration problems under `IsValidAcceleration`, 13 of which additionally carry higher-level Poincaré/contraction accelerations `highLevelNext`) in **[`BusyBeaver/BB6/Accelerations/`](./BB6/Accelerations/README.md)**, together with machine-level halting equivalences ([`Equivalences.lean`](./BB6/Equivalences.lean)), hardness classification ([`Hardness.lean`](./BB6/Hardness.lean)), and formal hardness evidence ([`HardnessEvidence.lean`](./BB6/HardnessEvidence.lean)), alongside 180 resolved holdouts in **[`BusyBeaver/BB6/Halt/`](./BB6/Halt/)** (31 `IsHalt` proofs) and **[`BusyBeaver/BB6/NonHalt/`](./BB6/NonHalt/)** (149 `IsNotHalt` proofs) reproducing community and `busycoq` results. +- **[`BusyBeaver/BB6/`](./BB6/README.md)** — 280 `BB(6)` (6-state, 2-symbol) Turing machines: 54 holdouts in `BB6/` (the [A6 nonhalting certificate](../artifacts/a6/README.md) and 53 holdouts with certified closed `TapePatternSet` invariants `IsClosedPatternSet`, `HasCollatzReduction` and Collatz-like accelerations `IsValidAcceleration`, including a self-contained, Baker-free 2-adic Laurent-determinant `IsNotHalt` proof for `1RB1LA_1RC1RE_1LD0RB_1LA0LC_0RF0RD_0RB---`), plus 35 stacked, odometer, and transducer holdouts (15 machines formalized under `HasStackReduction`, `HasOdometerReduction`, and `HasTransducerReduction`—12 `bbchallenge` Wiki machines and 3 Halving Tower holdouts—and 20 open acceleration problems under `IsValidAcceleration`, 13 of which additionally carry higher-level Poincaré/contraction accelerations `highLevelNext`) in **[`BusyBeaver/BB6/Accelerations/`](./BB6/Accelerations/README.md)**, together with machine-level halting equivalences ([`Equivalences.lean`](./BB6/Equivalences.lean)), hardness classification ([`Hardness.lean`](./BB6/Hardness.lean)), and formal hardness evidence ([`HardnessEvidence.lean`](./BB6/HardnessEvidence.lean)), alongside 191 resolved holdouts in **[`BusyBeaver/BB6/Halt/`](./BB6/Halt/)** (32 `IsHalt` proofs) and **[`BusyBeaver/BB6/NonHalt/`](./BB6/NonHalt/)** (159 `IsNotHalt` proofs) reproducing community and `busycoq` results. - **[`BusyBeaver/BB33/`](./BB33/README.md)** — All 6 remaining unsolved `BB(3, 3)` (3-state, 3-symbol) holdout Turing machines (4 equivalence classes: *Bigfoot* (holdout #829), the *Wily Coyote* pair (holdouts #531 & #532), the holdout #758 / #153 pair (probvious champion), and holdout #397), with certified Collatz-like (`HasCollatzReduction`) or stacked Collatz-like (`HasStackedCollatzReduction`) reductions and exact halting equivalences (`IsValidAcceleration`). ## Cryptids, Collatz-like, and Stacked Collatz Reductions diff --git a/BusyBeaverChallenge.lean b/BusyBeaverChallenge.lean index 52915159..3dd18431 100644 --- a/BusyBeaverChallenge.lean +++ b/BusyBeaverChallenge.lean @@ -8100,6 +8100,13 @@ abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB theorem is_halt : IsHalt target := by sorry end BusyBeaver.M_1RB0RE_1RC0RA_0LD0LB_0LA1LE_1LC1LF_0LAHHH +namespace BusyBeaver.M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH" +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB +theorem is_halt : IsHalt target := by sorry +end BusyBeaver.M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH + namespace BusyBeaver.M_1RB0RF_0RC1RD_0LDHHH_1LE1RA_1LA0LF_0RD0RC def machine : ConjectureMachines.Machine 6 2 := load_rle_machine% "1RB0RF_0RC1RD_0LDHHH_1LE1RA_1LA0LF_0RD0RC" @@ -8275,6 +8282,13 @@ abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB theorem is_not_halt : IsNotHalt target := by sorry end BusyBeaver.M_1RB0LC_1LC0RE_1LA1LD_1LA1LF_0RB1RA_1LCHHH +namespace BusyBeaver.M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA" +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB +theorem is_not_halt : IsNotHalt target := by sorry +end BusyBeaver.M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA + namespace BusyBeaver.M_1RB0LD_1LC1RB_0LA0LD_1LE0RB_1RF0RE_HHH0RD def machine : ConjectureMachines.Machine 6 2 := load_rle_machine% "1RB0LD_1LC1RB_0LA0LD_1LE0RB_1RF0RE_HHH0RD" @@ -8338,6 +8352,13 @@ abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB theorem is_not_halt : IsNotHalt target := by sorry end BusyBeaver.M_1RB0LE_1RC1LA_1LD1RE_1LB0LD_1RF0RC_1RBHHH +namespace BusyBeaver.M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF" +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB +theorem is_not_halt : IsNotHalt target := by sorry +end BusyBeaver.M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF + namespace BusyBeaver.M_1RB0LF_0RCHHH_1RD0RA_1LE0RC_0LA0LE_1LE1LB def machine : ConjectureMachines.Machine 6 2 := load_rle_machine% "1RB0LF_0RCHHH_1RD0RA_1LE0RC_0LA0LE_1LE1LB" @@ -8443,6 +8464,13 @@ abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB theorem is_not_halt : IsNotHalt target := by sorry end BusyBeaver.M_1RB0RA_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RBHHH +namespace BusyBeaver.M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH" +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB +theorem is_not_halt : IsNotHalt target := by sorry +end BusyBeaver.M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH + namespace BusyBeaver.M_1RB0RA_1RC0LC_0LD1RF_1RA1LE_1LD0LB_0REHHH def machine : ConjectureMachines.Machine 6 2 := load_rle_machine% "1RB0RA_1RC0LC_0LD1RF_1RA1LE_1LD0LB_0REHHH" @@ -8464,6 +8492,13 @@ abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB theorem is_not_halt : IsNotHalt target := by sorry end BusyBeaver.M_1RB0RA_1RC0RC_1LD0LE_1RA1LC_1LC1LF_0LCHHH +namespace BusyBeaver.M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE" +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB +theorem is_not_halt : IsNotHalt target := by sorry +end BusyBeaver.M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE + namespace BusyBeaver.M_1RB0RA_1RC0RD_1LD1LE_1LF0LC_0LDHHH_1RA1LD def machine : ConjectureMachines.Machine 6 2 := load_rle_machine% "1RB0RA_1RC0RD_1LD1LE_1LF0LC_0LDHHH_1RA1LD" @@ -8534,6 +8569,13 @@ abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB theorem is_not_halt : IsNotHalt target := by sorry end BusyBeaver.M_1RB0RC_1LC1RA_0RF0LD_1LE0RB_1LB0LD_HHH1RD +namespace BusyBeaver.M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB" +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB +theorem is_not_halt : IsNotHalt target := by sorry +end BusyBeaver.M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB + namespace BusyBeaver.M_1RB0RC_1LC1RD_1RA1LE_1LA0RD_0LE1RF_1LBHHH def machine : ConjectureMachines.Machine 6 2 := load_rle_machine% "1RB0RC_1LC1RD_1RA1LE_1LA0RD_0LE1RF_1LBHHH" @@ -8695,6 +8737,13 @@ abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB theorem is_not_halt : IsNotHalt target := by sorry end BusyBeaver.M_1RB0RE_1RCHHH_0LD1LE_0RE1LD_1RF0LC_0RA1RE +namespace BusyBeaver.M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD" +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB +theorem is_not_halt : IsNotHalt target := by sorry +end BusyBeaver.M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD + namespace BusyBeaver.M_1RB0RF_1LC0LF_1LD0LC_0LE0LA_1LFHHH_1RA1RF def machine : ConjectureMachines.Machine 6 2 := load_rle_machine% "1RB0RF_1LC0LF_1LD0LC_0LE0LA_1LFHHH_1RA1RF" @@ -8737,6 +8786,13 @@ abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB theorem is_not_halt : IsNotHalt target := by sorry end BusyBeaver.M_1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LFHHH_1RA1RF +namespace BusyBeaver.M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH" +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB +theorem is_not_halt : IsNotHalt target := by sorry +end BusyBeaver.M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH + namespace BusyBeaver.M_1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RAHHH_0RA0LB def machine : ConjectureMachines.Machine 6 2 := load_rle_machine% "1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RAHHH_0RA0LB" @@ -8905,6 +8961,13 @@ abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB theorem is_not_halt : IsNotHalt target := by sorry end BusyBeaver.M_1RB1LF_0RC0RB_0LD1LA_1LC0LE_0LAHHH_1LA1LF +namespace BusyBeaver.M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE" +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB +theorem is_not_halt : IsNotHalt target := by sorry +end BusyBeaver.M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE + namespace BusyBeaver.M_1RB1LF_1LC1RB_1RE1LD_1LB0LC_1LA0RE_1LDHHH def machine : ConjectureMachines.Machine 6 2 := load_rle_machine% "1RB1LF_1LC1RB_1RE1LD_1LB0LC_1LA0RE_1LDHHH" @@ -8926,6 +8989,13 @@ abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB theorem is_not_halt : IsNotHalt target := by sorry end BusyBeaver.M_1RB1LF_1RC0RB_1RD0RF_1REHHH_1LF1LE_1LA0LE +namespace BusyBeaver.M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD" +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB +theorem is_not_halt : IsNotHalt target := by sorry +end BusyBeaver.M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD + namespace BusyBeaver.M_1RB1RA_1LC1LE_0LD0LB_0RA0RF_0LC0RA_1RDHHH def machine : ConjectureMachines.Machine 6 2 := load_rle_machine% "1RB1RA_1LC1LE_0LD0LB_0RA0RF_0LC0RA_1RDHHH" @@ -9157,6 +9227,13 @@ abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB theorem is_not_halt : IsNotHalt target := by sorry end BusyBeaver.M_1RBHHH_0RC1LF_1LC1LD_1RE0RA_0RD1RF_0LD0LF +namespace BusyBeaver.M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD +def machine : ConjectureMachines.Machine 6 2 := + load_rle_machine% "1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD" +abbrev target : Machine (Fin 2) (Fin 6) := machine.toBB +theorem is_not_halt : IsNotHalt target := by sorry +end BusyBeaver.M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD + namespace BusyBeaver.M_1RBHHH_1LC0LF_1RD1LB_1RE0RD_1LB0RB_1LB0LA def machine : ConjectureMachines.Machine 6 2 := load_rle_machine% "1RBHHH_1LC0LF_1RD1LB_1RE0RD_1LB0RB_1LB0LA" diff --git a/comparator/busy_beaver.json b/comparator/busy_beaver.json index 1448dafc..6461ef3a 100644 --- a/comparator/busy_beaver.json +++ b/comparator/busy_beaver.json @@ -525,6 +525,7 @@ "BusyBeaver.M_1RB0RD_1LC1RE_1LA0LD_0RE0RF_1LC1RA_0LEHHH.is_halt", "BusyBeaver.M_1RB0RD_1RC0LC_1RE1RA_0LD1LA_0LF0LD_0REHHH.is_halt", "BusyBeaver.M_1RB0RE_1RC0RA_0LD0LB_0LA1LE_1LC1LF_0LAHHH.is_halt", + "BusyBeaver.M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH.is_halt", "BusyBeaver.M_1RB0RF_0RC1RD_0LDHHH_1LE1RA_1LA0LF_0RD0RC.is_halt", "BusyBeaver.M_1RB0RF_1LC1RE_1LD0LC_0LE0RE_1RA1LD_1RBHHH.is_halt", "BusyBeaver.M_1RB0RF_1RC0RB_1LD1RA_1LE0LD_1RB0LA_0LDHHH.is_halt", @@ -550,6 +551,7 @@ "BusyBeaver.M_1RB0LC_1LC0RB_0LE0LD_1LCHHH_0RA1LF_1LA1LF.is_not_halt", "BusyBeaver.M_1RB0LC_1LC0RE_1LA1LD_1LA1LB_0RF1RA_HHH0RE.is_not_halt", "BusyBeaver.M_1RB0LC_1LC0RE_1LA1LD_1LA1LF_0RB1RA_1LCHHH.is_not_halt", + "BusyBeaver.M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA.is_not_halt", "BusyBeaver.M_1RB0LD_1LC1RB_0LA0LD_1LE0RB_1RF0RE_HHH0RD.is_not_halt", "BusyBeaver.M_1RB0LD_1RC0RA_1RD1RF_1LA0LE_1RE1LD_0RBHHH.is_not_halt", "BusyBeaver.M_1RB0LD_1RC0RE_1LD0RE_1LA0LA_1RB1RF_1RBHHH.is_not_halt", @@ -559,6 +561,7 @@ "BusyBeaver.M_1RB0LE_1RC0LF_0LD0RC_1RA1LD_1LB0LE_HHH0RE.is_not_halt", "BusyBeaver.M_1RB0LE_1RC0RC_1LD0RB_1LA0LE_1LD1LF_1LDHHH.is_not_halt", "BusyBeaver.M_1RB0LE_1RC1LA_1LD1RE_1LB0LD_1RF0RC_1RBHHH.is_not_halt", + "BusyBeaver.M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF.is_not_halt", "BusyBeaver.M_1RB0LF_0RCHHH_1RD0RA_1LE0RC_0LA0LE_1LE1LB.is_not_halt", "BusyBeaver.M_1RB0RA_0LC0LA_1RF1LD_1LE0LD_1LC1LF_HHH1RA.is_not_halt", "BusyBeaver.M_1RB0RA_0RC0LD_1LA1RF_1LE1LD_1LB1RE_HHH1RA.is_not_halt", @@ -574,9 +577,11 @@ "BusyBeaver.M_1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LCHHH.is_not_halt", "BusyBeaver.M_1RB0RA_1LC0RC_1LE0LD_1LC1LF_1RA1LC_1LDHHH.is_not_halt", "BusyBeaver.M_1RB0RA_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RBHHH.is_not_halt", + "BusyBeaver.M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH.is_not_halt", "BusyBeaver.M_1RB0RA_1RC0LC_0LD1RF_1RA1LE_1LD0LB_0REHHH.is_not_halt", "BusyBeaver.M_1RB0RA_1RC0LE_1LD0RA_HHH1LE_0RE0LF_1LB1LC.is_not_halt", "BusyBeaver.M_1RB0RA_1RC0RC_1LD0LE_1RA1LC_1LC1LF_0LCHHH.is_not_halt", + "BusyBeaver.M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE.is_not_halt", "BusyBeaver.M_1RB0RA_1RC0RD_1LD1LE_1LF0LC_0LDHHH_1RA1LD.is_not_halt", "BusyBeaver.M_1RB0RA_1RC0RE_1RDHHH_1LE1LD_1LF0LD_1RA1LE.is_not_halt", "BusyBeaver.M_1RB0RB_1LC0LE_1RD1LB_1RA0RD_1LB1LF_0LAHHH.is_not_halt", @@ -587,6 +592,7 @@ "BusyBeaver.M_1RB0RC_1LC0LD_1RA1RC_1RA1LE_0LB1RE_HHH1RA.is_not_halt", "BusyBeaver.M_1RB0RC_1LC1LF_1LD0LB_1RE1LC_1RA0RE_0LCHHH.is_not_halt", "BusyBeaver.M_1RB0RC_1LC1RA_0RF0LD_1LE0RB_1LB0LD_HHH1RD.is_not_halt", + "BusyBeaver.M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB.is_not_halt", "BusyBeaver.M_1RB0RC_1LC1RD_1RA1LE_1LA0RD_0LE1RF_1LBHHH.is_not_halt", "BusyBeaver.M_1RB0RD_0LC0RA_1LA1LC_1RE0LF_0RA1RF_1LBHHH.is_not_halt", "BusyBeaver.M_1RB0RD_0LC1RA_0RA1LB_1RE1LB_1LF1LB_HHH1LE.is_not_halt", @@ -610,12 +616,14 @@ "BusyBeaver.M_1RB0RE_1RC1LF_0LD0RE_HHH1LE_1RA0LB_1LB0LC.is_not_halt", "BusyBeaver.M_1RB0RE_1RC1RE_1LD1RA_1LA0LD_0RA0LF_1LDHHH.is_not_halt", "BusyBeaver.M_1RB0RE_1RCHHH_0LD1LE_0RE1LD_1RF0LC_0RA1RE.is_not_halt", + "BusyBeaver.M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD.is_not_halt", "BusyBeaver.M_1RB0RF_1LC0LF_1LD0LC_0LE0LA_1LFHHH_1RA1RF.is_not_halt", "BusyBeaver.M_1RB0RF_1LC0RE_0LC0LD_1RD1LB_0RF1RA_0RBHHH.is_not_halt", "BusyBeaver.M_1RB0RF_1LC1RA_1LD0LC_0LE0LA_0RFHHH_1RA1RF.is_not_halt", "BusyBeaver.M_1RB0RF_1LC1RA_1LD0LC_0LE0LA_1RFHHH_1RA1RE.is_not_halt", "BusyBeaver.M_1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LFHHH_1RA1RB.is_not_halt", "BusyBeaver.M_1RB0RF_1LC1RA_1LD0LC_1LE0LA_1LFHHH_1RA1RF.is_not_halt", + "BusyBeaver.M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH.is_not_halt", "BusyBeaver.M_1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RAHHH_0RA0LB.is_not_halt", "BusyBeaver.M_1RB0RF_1RC0RE_1LD1RA_1LA0LD_1RAHHH_0RE0LB.is_not_halt", "BusyBeaver.M_1RB0RF_1RC1RF_1LD0RE_HHH0LE_1LA0LE_0RA0LC.is_not_halt", @@ -640,9 +648,11 @@ "BusyBeaver.M_1RB1LE_1LC0RF_1LA0RD_1LC1RC_1LB0LB_HHH1RD.is_not_halt", "BusyBeaver.M_1RB1LE_1LC1RD_0LA1LA_HHH1RE_1LF0LA_0LC0RF.is_not_halt", "BusyBeaver.M_1RB1LF_0RC0RB_0LD1LA_1LC0LE_0LAHHH_1LA1LF.is_not_halt", + "BusyBeaver.M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE.is_not_halt", "BusyBeaver.M_1RB1LF_1LC1RB_1RE1LD_1LB0LC_1LA0RE_1LDHHH.is_not_halt", "BusyBeaver.M_1RB1LF_1RC0RB_1RD0RF_1REHHH_1LF1LA_1LA0LE.is_not_halt", "BusyBeaver.M_1RB1LF_1RC0RB_1RD0RF_1REHHH_1LF1LE_1LA0LE.is_not_halt", + "BusyBeaver.M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD.is_not_halt", "BusyBeaver.M_1RB1RA_1LC1LE_0LD0LB_0RA0RF_0LC0RA_1RDHHH.is_not_halt", "BusyBeaver.M_1RB1RA_1LC1LE_1RF1LD_1RE0LD_0LB0RA_HHH0RC.is_not_halt", "BusyBeaver.M_1RB1RA_1LC1RE_0LD0LD_0LE1LF_1LA0RA_HHH1LC.is_not_halt", @@ -676,6 +686,7 @@ "BusyBeaver.M_1RBHHH_0RC0RA_1RD1RC_1LE1LF_0LB0LD_0LE0RC.is_not_halt", "BusyBeaver.M_1RBHHH_0RC1LF_0RD1RB_1LE1RC_0LB0LE_0LE0LA.is_not_halt", "BusyBeaver.M_1RBHHH_0RC1LF_1LC1LD_1RE0RA_0RD1RF_0LD0LF.is_not_halt", + "BusyBeaver.M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD.is_not_halt", "BusyBeaver.M_1RBHHH_1LC0LF_1RD1LB_1RE0RD_1LB0RB_1LB0LA.is_not_halt", "BusyBeaver.M_1RBHHH_1LC0RC_0LD0LC_1RE1RA_0RD1LF_0LE0LF.is_not_halt", "BusyBeaver.M_1RBHHH_1LC1LB_1LD0LB_1RE1LC_1RF0RE_0RA0RC.is_not_halt",