From 0a290872d13f36d27d9963904f3119c7be10ebc8 Mon Sep 17 00:00:00 2001 From: Tom Zahavy Date: Sat, 7 Nov 2026 21:31:03 +0000 Subject: [PATCH] feat(busy_beaver): Port 11 single-file BB(6) halting and non-halting proofs Ports the following 11 BB(6) proofs: - 1 Halt: M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH - 10 NonHalt: M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA, M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF, M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH, M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE, M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB, M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD, M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH, M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE, M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD, M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD - And BusyBeaver/Calculi/SegCount.lean which provides Segment count counting utilities. All unused declarations have been pruned. All lines are wrapped to 100 columns. No autoImplicit or linter overrides are used. lake comparator passes successfully. --- BusyBeaver.lean | 11 + ...RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH.lean | 3493 +++++ ...LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA.lean | 10654 ++++++++++++++++ ...LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF.lean | 4225 ++++++ ...RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH.lean | 46 + ...RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE.lean | 2096 +++ ...RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB.lean | 1843 +++ ...RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD.lean | 46 + ...RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH.lean | 5118 ++++++++ ...LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE.lean | 46 + ...RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD.lean | 4475 +++++++ ...HH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD.lean | 46 + BusyBeaver/BB6/README.md | 26 +- BusyBeaver/Calculi/SegCount.lean | 41 + BusyBeaver/README.md | 2 +- BusyBeaverChallenge.lean | 77 + comparator/busy_beaver.json | 11 + 17 files changed, 32247 insertions(+), 9 deletions(-) create mode 100644 BusyBeaver/BB6/Halt/M_1RB0RE_1RC0RA_0LD0RB_1LA0LE_1LC1LF_0LCHHH.lean create mode 100644 BusyBeaver/BB6/NonHalt/M_1RB0LC_1RC0RA_1RD0RF_0LEHHH_1LB1LA_1LD1RA.lean create mode 100644 BusyBeaver/BB6/NonHalt/M_1RB0LE_1RCHHH_0RD0RB_1RE0LA_1RF0LF_1LD1RF.lean create mode 100644 BusyBeaver/BB6/NonHalt/M_1RB0RA_1LC0RE_1LD0LC_1RA0LB_1RA0RF_1LEHHH.lean create mode 100644 BusyBeaver/BB6/NonHalt/M_1RB0RA_1RC0RC_1LD1RF_HHH1LE_1RF0LF_1RA0LE.lean create mode 100644 BusyBeaver/BB6/NonHalt/M_1RB0RC_1LC1RB_0RE1LD_0LC1LA_1RF1RA_HHH0RB.lean create mode 100644 BusyBeaver/BB6/NonHalt/M_1RB0RF_0LCHHH_1LE1LD_1RE0LA_1RA0RD_1LB1RD.lean create mode 100644 BusyBeaver/BB6/NonHalt/M_1RB0RF_1RC0RB_1LD0RA_1LE0LD_1RB0LC_1LAHHH.lean create mode 100644 BusyBeaver/BB6/NonHalt/M_1RB1LF_0RCHHH_1RD1RF_1LE0LF_1LB0LA_1LD0RE.lean create mode 100644 BusyBeaver/BB6/NonHalt/M_1RB1RA_0LC0RA_1RC1LD_0LB1LE_1LF0RC_HHH0LD.lean create mode 100644 BusyBeaver/BB6/NonHalt/M_1RBHHH_1LC0LA_1LD0LC_1RE0LB_1RF0RE_1LC0RD.lean create mode 100644 BusyBeaver/Calculi/SegCount.lean 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",