Add lean source and binary files (part 55)

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/CertificatesK5.lean

@@ -0,0 +1,1162 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.LayoutCertificate
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CertificateMatrixChunks
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.FastCertificateMatrix
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.FastLayoutGraph
+
+namespace OAI
+
+namespace CycleClique.Construction.Certificates
+
+def k5t3p0 : LayoutCertificate 3 where
+  chains := [[0], [1], [2]]
+  clique := {0, 1, 2}
+  templates := [⟨0, 1, [], [], [], 1, 4⟩,
+    ⟨0, 2, [], [], [], 1, 4⟩,
+    ⟨1, 2, [], [], [], 1, 4⟩]
+  required := []
+  closure := []
+  bad := ⟨none, {(0, 2), (1, 2)}⟩
+
+
+private def k5t3p0_state_0 : ForbiddenMatrix 3 :=
+  fun i j => ((#[#[∅, Finset.Icc 1 4, Finset.Icc 1 4],
+    #[Finset.Icc 1 4, ∅, Finset.Icc 1 4],
+    #[Finset.Icc 1 4, Finset.Icc 1 4, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t3p0_initial_eq_row_0 : ∀ j : Fin 3, (k5t3p0.initialMatrix 5) 0 j = k5t3p0_state_0 0 j := by decide
+
+private theorem k5t3p0_initial_eq_row_1 : ∀ j : Fin 3, (k5t3p0.initialMatrix 5) 1 j = k5t3p0_state_0 1 j := by decide
+
+private theorem k5t3p0_initial_eq_row_2 : ∀ j : Fin 3, (k5t3p0.initialMatrix 5) 2 j = k5t3p0_state_0 2 j := by decide
+
+private theorem k5t3p0_initial_eq : (k5t3p0.initialMatrix 5) = k5t3p0_state_0 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t3p0_initial_eq_row_0 j
+
+  · exact k5t3p0_initial_eq_row_1 j
+
+  · exact k5t3p0_initial_eq_row_2 j
+
+private theorem k5t3p0_closure_0 : ClosureCheck k5t3p0.graph k5t3p0_state_0 5 3 [] := by trivial
+
+private theorem k5t3p0_matrix_eq : k5t3p0.matrix 5 = k5t3p0_state_0 := by
+  change closureMatrix (k5t3p0.initialMatrix 5) _ = _
+  rw [k5t3p0_initial_eq]
+  change closureMatrix k5t3p0_state_0 [] = _
+  rfl
+
+private theorem k5t3p0_part_0 : k5t3p0.chains.flatten = List.finRange _ := by decide
+
+private theorem k5t3p0_part_1 : k5t3p0.chains.map List.length = ([[], [], []] : List (List ℕ)).map (fun w => w.sum + w.length + 1) := by decide
+
+private theorem k5t3p0_part_2 : k5t3p0.chains.map (fun l => l.map (fun i => decide (i ∈ k5t3p0.clique))) = ([[], [], []] : List (List ℕ)).map profileMask := by decide
+
+private theorem k5t3p0_templates_item_0 : (⟨0, 1, [], [], [], 1, 4⟩ : TemplateData (Fin 3)).Check k5t3p0.graph k5t3p0.clique 5 (patternAmount ([[], [], []] : List (List ℕ))) (([[], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p0_templates_item_1 : (⟨0, 2, [], [], [], 1, 4⟩ : TemplateData (Fin 3)).Check k5t3p0.graph k5t3p0.clique 5 (patternAmount ([[], [], []] : List (List ℕ))) (([[], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p0_templates_item_2 : (⟨1, 2, [], [], [], 1, 4⟩ : TemplateData (Fin 3)).Check k5t3p0.graph k5t3p0.clique 5 (patternAmount ([[], [], []] : List (List ℕ))) (([[], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p0_part_3 : ∀ T ∈ k5t3p0.templates, T.Check k5t3p0.graph k5t3p0.clique 5 (patternAmount ([[], [], []] : List (List ℕ))) (([[], [], []] : List (List ℕ)).map List.length).sum := by
+  simp only [k5t3p0, List.forall_mem_cons, List.not_mem_nil, IsEmpty.forall_iff, implies_true, and_true]
+  exact ⟨k5t3p0_templates_item_0, k5t3p0_templates_item_1, k5t3p0_templates_item_2⟩
+
+private theorem k5t3p0_part_4 : ∀ p ∈ k5t3p0.required, p.Check k5t3p0.graph 5 := by decide
+
+private theorem k5t3p0_part_5 : ClosureCheck k5t3p0.graph (k5t3p0.initialMatrix 5) 5 3 k5t3p0.closure := by
+  rw [k5t3p0_initial_eq]
+  exact k5t3p0_closure_0
+
+private theorem k5t3p0_part_6 : k5t3p0.bad.Check k5t3p0.graph (k5t3p0.matrix 5) 5 3 := by
+  rw [k5t3p0_matrix_eq]
+  decide
+
+theorem k5t3p0_check : k5t3p0.Check 5 3 [[], [], []] :=
+  ⟨k5t3p0_part_0, k5t3p0_part_1, k5t3p0_part_2, k5t3p0_part_3, k5t3p0_part_4, k5t3p0_part_5, k5t3p0_part_6⟩
+private def k5t3p1_step_0_data : EdgeAttachmentData 4 := ⟨2, 0, [⟨0, 2, []⟩], ⟨none, {(0, 2), (2, 2), (1, 2)}⟩⟩
+
+private def k5t3p1_step_0 : ClosureStep 4 := .edge k5t3p1_step_0_data
+
+def k5t3p1 : LayoutCertificate 4 where
+  chains := [[0], [1, 2, 3]]
+  clique := {0, 1, 3}
+  templates := [⟨0, 1, [], [], [], 2, 4⟩,
+    ⟨0, 1, [], [], [2, 3], 1, 2⟩,
+    ⟨0, 2, [], [], [1], 1, 3⟩,
+    ⟨0, 3, [], [], [2, 1], 1, 2⟩,
+    ⟨1, 2, [], [], [3], 1, 3⟩,
+    ⟨2, 3, [], [1], [], 1, 3⟩]
+  required := [⟨1, 2, []⟩]
+  closure := [k5t3p1_step_0]
+  bad := ⟨none, {(0, 1), (2, 1), (1, 2)}⟩
+
+
+private def k5t3p1_state_0 : ForbiddenMatrix 4 :=
+  fun i j => ((#[#[∅, Finset.Icc 1 4, {1, 2, 3}, {1, 2}],
+    #[Finset.Icc 1 4, ∅, Finset.Icc 1 4, ∅],
+    #[{1, 2, 3}, Finset.Icc 1 4, ∅, {1, 2, 3}],
+    #[{1, 2}, ∅, {1, 2, 3}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t3p1_initial_eq_row_0 : ∀ j : Fin 4, (k5t3p1.initialMatrix 5) 0 j = k5t3p1_state_0 0 j := by decide
+
+private theorem k5t3p1_initial_eq_row_1 : ∀ j : Fin 4, (k5t3p1.initialMatrix 5) 1 j = k5t3p1_state_0 1 j := by decide
+
+private theorem k5t3p1_initial_eq_row_2 : ∀ j : Fin 4, (k5t3p1.initialMatrix 5) 2 j = k5t3p1_state_0 2 j := by decide
+
+private theorem k5t3p1_initial_eq_row_3 : ∀ j : Fin 4, (k5t3p1.initialMatrix 5) 3 j = k5t3p1_state_0 3 j := by decide
+
+private theorem k5t3p1_initial_eq : (k5t3p1.initialMatrix 5) = k5t3p1_state_0 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t3p1_initial_eq_row_0 j
+
+  · exact k5t3p1_initial_eq_row_1 j
+
+  · exact k5t3p1_initial_eq_row_2 j
+
+  · exact k5t3p1_initial_eq_row_3 j
+
+private def k5t3p1_state_1 : ForbiddenMatrix 4 :=
+  fun i j => ((#[#[∅, Finset.Icc 1 4, Finset.Icc 0 3, {1, 2}],
+    #[Finset.Icc 1 4, ∅, Finset.Icc 1 4, ∅],
+    #[Finset.Icc 0 3, Finset.Icc 1 4, ∅, {1, 2, 3}],
+    #[{1, 2}, ∅, {1, 2, 3}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private def k5t3p1_local_0 : ForbiddenMatrix 4 :=
+  fun i j => ((#[#[∅, Finset.Icc 1 4, Finset.Icc 1 4, {1, 2}],
+    #[Finset.Icc 1 4, ∅, Finset.Icc 1 4, ∅],
+    #[Finset.Icc 1 4, Finset.Icc 1 4, ∅, {1, 2, 3}],
+    #[{1, 2}, ∅, {1, 2, 3}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t3p1_local_0_eq_row_0 : ∀ j : Fin 4, (fun a b => k5t3p1_state_0 a b ∪ requiredMatrix 5 k5t3p1_step_0_data.required a b) 0 j = k5t3p1_local_0 0 j := by decide
+
+private theorem k5t3p1_local_0_eq_row_1 : ∀ j : Fin 4, (fun a b => k5t3p1_state_0 a b ∪ requiredMatrix 5 k5t3p1_step_0_data.required a b) 1 j = k5t3p1_local_0 1 j := by decide
+
+private theorem k5t3p1_local_0_eq_row_2 : ∀ j : Fin 4, (fun a b => k5t3p1_state_0 a b ∪ requiredMatrix 5 k5t3p1_step_0_data.required a b) 2 j = k5t3p1_local_0 2 j := by decide
+
+private theorem k5t3p1_local_0_eq_row_3 : ∀ j : Fin 4, (fun a b => k5t3p1_state_0 a b ∪ requiredMatrix 5 k5t3p1_step_0_data.required a b) 3 j = k5t3p1_local_0 3 j := by decide
+
+private theorem k5t3p1_local_0_eq : (fun a b => k5t3p1_state_0 a b ∪ requiredMatrix 5 k5t3p1_step_0_data.required a b) = k5t3p1_local_0 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t3p1_local_0_eq_row_0 j
+
+  · exact k5t3p1_local_0_eq_row_1 j
+
+  · exact k5t3p1_local_0_eq_row_2 j
+
+  · exact k5t3p1_local_0_eq_row_3 j
+
+private theorem k5t3p1_local_0_paths : ∀ p ∈ k5t3p1_step_0_data.required, p.Check (addedEdgeGraph k5t3p1.graph k5t3p1_step_0_data.i k5t3p1_step_0_data.j) 5 := by decide
+
+private theorem k5t3p1_local_0_bad : k5t3p1_step_0_data.bad.Check (addedEdgeGraph k5t3p1.graph k5t3p1_step_0_data.i k5t3p1_step_0_data.j) k5t3p1_local_0 5 3 := by decide
+
+private theorem k5t3p1_step_0_check : k5t3p1_step_0.Check k5t3p1.graph k5t3p1_state_0 5 3 := by
+  change k5t3p1_step_0_data.Check k5t3p1.graph k5t3p1_state_0 5 3
+  refine ⟨k5t3p1_local_0_paths, ?_⟩
+  rw [k5t3p1_local_0_eq]
+  exact k5t3p1_local_0_bad
+
+private theorem k5t3p1_update_0 : k5t3p1_step_0.apply k5t3p1_state_0 = k5t3p1_state_1 := by
+  have h : ∀ i j : Fin 4, k5t3p1_step_0.apply k5t3p1_state_0 i j = k5t3p1_state_1 i j := by decide
+  exact funext (fun i => funext (h i))
+
+private theorem k5t3p1_closure_1 : ClosureCheck k5t3p1.graph k5t3p1_state_1 5 3 [] := by trivial
+
+private theorem k5t3p1_closure_0 : ClosureCheck k5t3p1.graph k5t3p1_state_0 5 3 [k5t3p1_step_0] := by
+  constructor
+  · exact k5t3p1_step_0_check
+  · rw [k5t3p1_update_0]
+    exact k5t3p1_closure_1
+
+private theorem k5t3p1_matrix_eq : k5t3p1.matrix 5 = k5t3p1_state_1 := by
+  change closureMatrix (k5t3p1.initialMatrix 5) _ = _
+  rw [k5t3p1_initial_eq]
+  change closureMatrix k5t3p1_state_0 [k5t3p1_step_0] = _
+  simp only [closureMatrix]
+  rw [k5t3p1_update_0]
+
+private theorem k5t3p1_part_0 : k5t3p1.chains.flatten = List.finRange _ := by decide
+
+private theorem k5t3p1_part_1 : k5t3p1.chains.map List.length = ([[], [1]] : List (List ℕ)).map (fun w => w.sum + w.length + 1) := by decide
+
+private theorem k5t3p1_part_2 : k5t3p1.chains.map (fun l => l.map (fun i => decide (i ∈ k5t3p1.clique))) = ([[], [1]] : List (List ℕ)).map profileMask := by decide
+
+private theorem k5t3p1_templates_item_0 : (⟨0, 1, [], [], [], 2, 4⟩ : TemplateData (Fin 4)).Check k5t3p1.graph k5t3p1.clique 5 (patternAmount ([[], [1]] : List (List ℕ))) (([[], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p1_templates_item_1 : (⟨0, 1, [], [], [2, 3], 1, 2⟩ : TemplateData (Fin 4)).Check k5t3p1.graph k5t3p1.clique 5 (patternAmount ([[], [1]] : List (List ℕ))) (([[], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p1_templates_item_2 : (⟨0, 2, [], [], [1], 1, 3⟩ : TemplateData (Fin 4)).Check k5t3p1.graph k5t3p1.clique 5 (patternAmount ([[], [1]] : List (List ℕ))) (([[], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p1_templates_item_3 : (⟨0, 3, [], [], [2, 1], 1, 2⟩ : TemplateData (Fin 4)).Check k5t3p1.graph k5t3p1.clique 5 (patternAmount ([[], [1]] : List (List ℕ))) (([[], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p1_templates_item_4 : (⟨1, 2, [], [], [3], 1, 3⟩ : TemplateData (Fin 4)).Check k5t3p1.graph k5t3p1.clique 5 (patternAmount ([[], [1]] : List (List ℕ))) (([[], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p1_templates_item_5 : (⟨2, 3, [], [1], [], 1, 3⟩ : TemplateData (Fin 4)).Check k5t3p1.graph k5t3p1.clique 5 (patternAmount ([[], [1]] : List (List ℕ))) (([[], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p1_part_3 : ∀ T ∈ k5t3p1.templates, T.Check k5t3p1.graph k5t3p1.clique 5 (patternAmount ([[], [1]] : List (List ℕ))) (([[], [1]] : List (List ℕ)).map List.length).sum := by
+  simp only [k5t3p1, List.forall_mem_cons, List.not_mem_nil, IsEmpty.forall_iff, implies_true, and_true]
+  exact ⟨k5t3p1_templates_item_0, k5t3p1_templates_item_1, k5t3p1_templates_item_2, k5t3p1_templates_item_3, k5t3p1_templates_item_4, k5t3p1_templates_item_5⟩
+
+private theorem k5t3p1_required_item_0 : (⟨1, 2, []⟩ : RequiredPathData (Fin 4)).Check k5t3p1.graph 5 := by decide
+
+private theorem k5t3p1_part_4 : ∀ p ∈ k5t3p1.required, p.Check k5t3p1.graph 5 := by
+  simp only [k5t3p1, List.forall_mem_cons, List.not_mem_nil, IsEmpty.forall_iff, implies_true, and_true]
+  exact k5t3p1_required_item_0
+
+private theorem k5t3p1_part_5 : ClosureCheck k5t3p1.graph (k5t3p1.initialMatrix 5) 5 3 k5t3p1.closure := by
+  rw [k5t3p1_initial_eq]
+  exact k5t3p1_closure_0
+
+private theorem k5t3p1_part_6 : k5t3p1.bad.Check k5t3p1.graph (k5t3p1.matrix 5) 5 3 := by
+  rw [k5t3p1_matrix_eq]
+  decide
+
+theorem k5t3p1_check : k5t3p1.Check 5 3 [[], [1]] :=
+  ⟨k5t3p1_part_0, k5t3p1_part_1, k5t3p1_part_2, k5t3p1_part_3, k5t3p1_part_4, k5t3p1_part_5, k5t3p1_part_6⟩
+private def k5t3p2_step_0_data : EdgeAttachmentData 5 := ⟨3, 1, [⟨2, 3, [1]⟩, ⟨2, 4, [3, 1, 0]⟩, ⟨3, 4, [1]⟩], ⟨none, {(0, 0), (2, 2), (3, 2), (4, 1)}⟩⟩
+
+private def k5t3p2_step_0 : ClosureStep 5 := .edge k5t3p2_step_0_data
+
+private def k5t3p2_step_1_data : EdgeAttachmentData 5 := ⟨4, 2, [⟨0, 1, [4, 2]⟩, ⟨1, 3, [0, 4, 2]⟩, ⟨1, 2, [4]⟩, ⟨2, 3, [4]⟩], ⟨none, {(0, 0), (1, 2), (2, 2), (3, 1)}⟩⟩
+
+private def k5t3p2_step_1 : ClosureStep 5 := .edge k5t3p2_step_1_data
+
+private def k5t3p2_step_2_data : FreshAttachmentData 5 := ⟨3, 1, [⟨3, 0, [2, 1, 5, 4]⟩, ⟨3, 0, [2, 5, 4]⟩, ⟨3, 5, [2, 0, 4]⟩, ⟨3, 1, [2, 0, 4, 5]⟩, ⟨5, 0, [1, 2, 3, 4]⟩, ⟨0, 4, [2, 1, 5]⟩, ⟨0, 5, [2, 3, 4]⟩, ⟨0, 1, [2, 3, 4, 5]⟩], ⟨none, {(3, 1), (0, 0), (1, 0), (5, 1), (4, 1)}⟩⟩
+
+private def k5t3p2_step_2 : ClosureStep 5 := .fresh k5t3p2_step_2_data
+
+private def k5t3p2_step_3_data : FreshAttachmentData 5 := ⟨4, 1, [⟨1, 0, [2, 3, 4, 5]⟩, ⟨1, 3, [2, 0, 5, 4]⟩, ⟨1, 4, [5, 0, 2, 3]⟩, ⟨3, 0, [4, 5, 1, 2]⟩, ⟨3, 1, [4, 5, 0, 2]⟩, ⟨4, 0, [3, 2, 1, 5]⟩, ⟨4, 1, [3, 2, 0, 5]⟩], ⟨none, {(1, 1), (3, 1), (4, 1)}⟩⟩
+
+private def k5t3p2_step_3 : ClosureStep 5 := .fresh k5t3p2_step_3_data
+
+private def k5t3p2_step_4_data : FreshAttachmentData 5 := ⟨4, 2, [⟨2, 0, [1, 5, 4, 3]⟩, ⟨4, 0, [3, 2, 1, 5]⟩, ⟨4, 0, [3, 2, 5]⟩, ⟨4, 2, [3, 0, 5]⟩, ⟨4, 1, [3, 0, 5, 2]⟩, ⟨0, 2, [3, 4, 5]⟩, ⟨0, 1, [3, 4, 5, 2]⟩, ⟨0, 3, [5, 1, 2]⟩], ⟨none, {(4, 1), (0, 0), (1, 0), (2, 1), (3, 1)}⟩⟩
+
+private def k5t3p2_step_4 : ClosureStep 5 := .fresh k5t3p2_step_4_data
+
+private def k5t3p2_step_5_data : EdgeAttachmentData 5 := ⟨2, 0, [⟨0, 4, [2, 1]⟩, ⟨2, 0, []⟩], ⟨none, {(2, 2), (0, 2), (4, 1), (3, 0)}⟩⟩
+
+private def k5t3p2_step_5 : ClosureStep 5 := .edge k5t3p2_step_5_data
+
+private def k5t3p2_step_6_data : EdgeAttachmentData 5 := ⟨3, 0, [⟨1, 0, [2, 3]⟩], ⟨none, {(1, 2), (0, 2), (3, 1), (2, 0)}⟩⟩
+
+private def k5t3p2_step_6 : ClosureStep 5 := .edge k5t3p2_step_6_data
+
+def k5t3p2 : LayoutCertificate 5 where
+  chains := [[0], [1, 2, 3, 4]]
+  clique := {0, 1, 4}
+  templates := [⟨0, 1, [], [], [], 3, 4⟩,
+    ⟨0, 1, [], [], [2, 3, 4], 1, 1⟩,
+    ⟨0, 2, [], [], [1], 2, 3⟩,
+    ⟨0, 2, [], [], [3, 4], 1, 2⟩,
+    ⟨0, 3, [], [], [2, 1], 1, 2⟩,
+    ⟨0, 3, [], [], [4], 2, 3⟩,
+    ⟨0, 4, [], [], [], 3, 4⟩,
+    ⟨0, 4, [], [], [3, 2, 1], 1, 1⟩,
+    ⟨1, 2, [], [], [3, 4], 1, 2⟩,
+    ⟨1, 3, [], [], [4], 2, 3⟩,
+    ⟨2, 3, [], [1], [4], 1, 2⟩,
+    ⟨2, 4, [], [1], [], 2, 3⟩,
+    ⟨3, 4, [], [1, 2], [], 1, 2⟩]
+  required := [⟨1, 2, []⟩,
+    ⟨2, 3, []⟩]
+  closure := [k5t3p2_step_0, k5t3p2_step_1, k5t3p2_step_2, k5t3p2_step_3, k5t3p2_step_4, k5t3p2_step_5, k5t3p2_step_6]
+  bad := ⟨none, {(2, 1), (3, 1), (0, 1)}⟩
+
+
+private def k5t3p2_state_0 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, {1, 3, 4}, {1, 2, 3}, {1, 2, 3}, {1, 3, 4}],
+    #[{1, 3, 4}, ∅, {1, 2, 4}, {2, 3}, ∅],
+    #[{1, 2, 3}, {1, 2, 4}, ∅, {1, 2, 4}, {2, 3}],
+    #[{1, 2, 3}, {2, 3}, {1, 2, 4}, ∅, {1, 2}],
+    #[{1, 3, 4}, ∅, {2, 3}, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t3p2_initial_eq_row_0 : ∀ j : Fin 5, (k5t3p2.initialMatrix 5) 0 j = k5t3p2_state_0 0 j := by decide
+
+private theorem k5t3p2_initial_eq_row_1 : ∀ j : Fin 5, (k5t3p2.initialMatrix 5) 1 j = k5t3p2_state_0 1 j := by decide
+
+private theorem k5t3p2_initial_eq_row_2 : ∀ j : Fin 5, (k5t3p2.initialMatrix 5) 2 j = k5t3p2_state_0 2 j := by decide
+
+private theorem k5t3p2_initial_eq_row_3 : ∀ j : Fin 5, (k5t3p2.initialMatrix 5) 3 j = k5t3p2_state_0 3 j := by decide
+
+private theorem k5t3p2_initial_eq_row_4 : ∀ j : Fin 5, (k5t3p2.initialMatrix 5) 4 j = k5t3p2_state_0 4 j := by decide
+
+private theorem k5t3p2_initial_eq : (k5t3p2.initialMatrix 5) = k5t3p2_state_0 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t3p2_initial_eq_row_0 j
+
+  · exact k5t3p2_initial_eq_row_1 j
+
+  · exact k5t3p2_initial_eq_row_2 j
+
+  · exact k5t3p2_initial_eq_row_3 j
+
+  · exact k5t3p2_initial_eq_row_4 j
+
+private def k5t3p2_state_1 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, {1, 3, 4}, {1, 2, 3}, {1, 2, 3}, {1, 3, 4}],
+    #[{1, 3, 4}, ∅, {1, 2, 4}, {0, 2, 3}, ∅],
+    #[{1, 2, 3}, {1, 2, 4}, ∅, {1, 2, 4}, {2, 3}],
+    #[{1, 2, 3}, {0, 2, 3}, {1, 2, 4}, ∅, {1, 2}],
+    #[{1, 3, 4}, ∅, {2, 3}, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private def k5t3p2_local_0 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, {1, 3, 4}, {1, 2, 3}, {1, 2, 3}, {1, 3, 4}],
+    #[{1, 3, 4}, ∅, {1, 2, 4}, {2, 3}, ∅],
+    #[{1, 2, 3}, {1, 2, 4}, ∅, Finset.Icc 1 4, {1, 2, 3}],
+    #[{1, 2, 3}, {2, 3}, Finset.Icc 1 4, ∅, {1, 2, 3}],
+    #[{1, 3, 4}, ∅, {1, 2, 3}, {1, 2, 3}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t3p2_local_0_eq_row_0 : ∀ j : Fin 5, (fun a b => k5t3p2_state_0 a b ∪ requiredMatrix 5 k5t3p2_step_0_data.required a b) 0 j = k5t3p2_local_0 0 j := by decide
+
+private theorem k5t3p2_local_0_eq_row_1 : ∀ j : Fin 5, (fun a b => k5t3p2_state_0 a b ∪ requiredMatrix 5 k5t3p2_step_0_data.required a b) 1 j = k5t3p2_local_0 1 j := by decide
+
+private theorem k5t3p2_local_0_eq_row_2 : ∀ j : Fin 5, (fun a b => k5t3p2_state_0 a b ∪ requiredMatrix 5 k5t3p2_step_0_data.required a b) 2 j = k5t3p2_local_0 2 j := by decide
+
+private theorem k5t3p2_local_0_eq_row_3 : ∀ j : Fin 5, (fun a b => k5t3p2_state_0 a b ∪ requiredMatrix 5 k5t3p2_step_0_data.required a b) 3 j = k5t3p2_local_0 3 j := by decide
+
+private theorem k5t3p2_local_0_eq_row_4 : ∀ j : Fin 5, (fun a b => k5t3p2_state_0 a b ∪ requiredMatrix 5 k5t3p2_step_0_data.required a b) 4 j = k5t3p2_local_0 4 j := by decide
+
+private theorem k5t3p2_local_0_eq : (fun a b => k5t3p2_state_0 a b ∪ requiredMatrix 5 k5t3p2_step_0_data.required a b) = k5t3p2_local_0 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t3p2_local_0_eq_row_0 j
+
+  · exact k5t3p2_local_0_eq_row_1 j
+
+  · exact k5t3p2_local_0_eq_row_2 j
+
+  · exact k5t3p2_local_0_eq_row_3 j
+
+  · exact k5t3p2_local_0_eq_row_4 j
+
+private theorem k5t3p2_local_0_paths : ∀ p ∈ k5t3p2_step_0_data.required, p.Check (addedEdgeGraph k5t3p2.graph k5t3p2_step_0_data.i k5t3p2_step_0_data.j) 5 := by decide
+
+private theorem k5t3p2_local_0_bad : k5t3p2_step_0_data.bad.Check (addedEdgeGraph k5t3p2.graph k5t3p2_step_0_data.i k5t3p2_step_0_data.j) k5t3p2_local_0 5 3 := by decide
+
+private theorem k5t3p2_step_0_check : k5t3p2_step_0.Check k5t3p2.graph k5t3p2_state_0 5 3 := by
+  change k5t3p2_step_0_data.Check k5t3p2.graph k5t3p2_state_0 5 3
+  refine ⟨k5t3p2_local_0_paths, ?_⟩
+  rw [k5t3p2_local_0_eq]
+  exact k5t3p2_local_0_bad
+
+private theorem k5t3p2_update_0 : k5t3p2_step_0.apply k5t3p2_state_0 = k5t3p2_state_1 := by
+  have h : ∀ i j : Fin 5, k5t3p2_step_0.apply k5t3p2_state_0 i j = k5t3p2_state_1 i j := by decide
+  exact funext (fun i => funext (h i))
+
+private def k5t3p2_state_2 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, {1, 3, 4}, {1, 2, 3}, {1, 2, 3}, {1, 3, 4}],
+    #[{1, 3, 4}, ∅, {1, 2, 4}, {0, 2, 3}, ∅],
+    #[{1, 2, 3}, {1, 2, 4}, ∅, {1, 2, 4}, {0, 2, 3}],
+    #[{1, 2, 3}, {0, 2, 3}, {1, 2, 4}, ∅, {1, 2}],
+    #[{1, 3, 4}, ∅, {0, 2, 3}, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private def k5t3p2_local_1 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, Finset.Icc 1 4, {1, 2, 3}, {1, 2, 3}, {1, 3, 4}],
+    #[Finset.Icc 1 4, ∅, Finset.Icc 1 4, Finset.Icc 0 3, ∅],
+    #[{1, 2, 3}, Finset.Icc 1 4, ∅, Finset.Icc 1 4, {2, 3}],
+    #[{1, 2, 3}, Finset.Icc 0 3, Finset.Icc 1 4, ∅, {1, 2}],
+    #[{1, 3, 4}, ∅, {2, 3}, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t3p2_local_1_eq_row_0 : ∀ j : Fin 5, (fun a b => k5t3p2_state_1 a b ∪ requiredMatrix 5 k5t3p2_step_1_data.required a b) 0 j = k5t3p2_local_1 0 j := by decide
+
+private theorem k5t3p2_local_1_eq_row_1 : ∀ j : Fin 5, (fun a b => k5t3p2_state_1 a b ∪ requiredMatrix 5 k5t3p2_step_1_data.required a b) 1 j = k5t3p2_local_1 1 j := by decide
+
+private theorem k5t3p2_local_1_eq_row_2 : ∀ j : Fin 5, (fun a b => k5t3p2_state_1 a b ∪ requiredMatrix 5 k5t3p2_step_1_data.required a b) 2 j = k5t3p2_local_1 2 j := by decide
+
+private theorem k5t3p2_local_1_eq_row_3 : ∀ j : Fin 5, (fun a b => k5t3p2_state_1 a b ∪ requiredMatrix 5 k5t3p2_step_1_data.required a b) 3 j = k5t3p2_local_1 3 j := by decide
+
+private theorem k5t3p2_local_1_eq_row_4 : ∀ j : Fin 5, (fun a b => k5t3p2_state_1 a b ∪ requiredMatrix 5 k5t3p2_step_1_data.required a b) 4 j = k5t3p2_local_1 4 j := by decide
+
+private theorem k5t3p2_local_1_eq : (fun a b => k5t3p2_state_1 a b ∪ requiredMatrix 5 k5t3p2_step_1_data.required a b) = k5t3p2_local_1 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t3p2_local_1_eq_row_0 j
+
+  · exact k5t3p2_local_1_eq_row_1 j
+
+  · exact k5t3p2_local_1_eq_row_2 j
+
+  · exact k5t3p2_local_1_eq_row_3 j
+
+  · exact k5t3p2_local_1_eq_row_4 j
+
+private theorem k5t3p2_local_1_paths : ∀ p ∈ k5t3p2_step_1_data.required, p.Check (addedEdgeGraph k5t3p2.graph k5t3p2_step_1_data.i k5t3p2_step_1_data.j) 5 := by decide
+
+private theorem k5t3p2_local_1_bad : k5t3p2_step_1_data.bad.Check (addedEdgeGraph k5t3p2.graph k5t3p2_step_1_data.i k5t3p2_step_1_data.j) k5t3p2_local_1 5 3 := by decide
+
+private theorem k5t3p2_step_1_check : k5t3p2_step_1.Check k5t3p2.graph k5t3p2_state_1 5 3 := by
+  change k5t3p2_step_1_data.Check k5t3p2.graph k5t3p2_state_1 5 3
+  refine ⟨k5t3p2_local_1_paths, ?_⟩
+  rw [k5t3p2_local_1_eq]
+  exact k5t3p2_local_1_bad
+
+private theorem k5t3p2_update_1 : k5t3p2_step_1.apply k5t3p2_state_1 = k5t3p2_state_2 := by
+  have h : ∀ i j : Fin 5, k5t3p2_step_1.apply k5t3p2_state_1 i j = k5t3p2_state_2 i j := by decide
+  exact funext (fun i => funext (h i))
+
+private def k5t3p2_state_3 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, {1, 3, 4}, {1, 2, 3}, {1, 2, 3}, {1, 3, 4}],
+    #[{1, 3, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3, ∅],
+    #[{1, 2, 3}, {1, 2, 4}, ∅, {1, 2, 4}, {0, 2, 3}],
+    #[{1, 2, 3}, Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2}],
+    #[{1, 3, 4}, ∅, {0, 2, 3}, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private def k5t3p2_local_2 : ForbiddenMatrix 6 :=
+  fun i j => ((#[#[∅, {0}, ∅, {0, 1}, {1}, {0, 1}],
+    #[{0}, ∅, {1, 3, 4}, Finset.Icc 0 3, {1, 2, 3}, {1, 3, 4}],
+    #[∅, {1, 3, 4}, ∅, {1, 2, 4}, {0, 2, 3}, ∅],
+    #[{0, 1}, Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3],
+    #[{1}, {1, 2, 3}, {0, 2, 3}, {1, 2, 4}, ∅, {1, 2}],
+    #[{0, 1}, {1, 3, 4}, ∅, Finset.Icc 0 3, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t3p2_local_2_eq_row_0 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_2 a b ∪ requiredMatrix 5 k5t3p2_step_2_data.required a b) 0 j = k5t3p2_local_2 0 j := by decide
+
+private theorem k5t3p2_local_2_eq_row_1 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_2 a b ∪ requiredMatrix 5 k5t3p2_step_2_data.required a b) 1 j = k5t3p2_local_2 1 j := by decide
+
+private theorem k5t3p2_local_2_eq_row_2 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_2 a b ∪ requiredMatrix 5 k5t3p2_step_2_data.required a b) 2 j = k5t3p2_local_2 2 j := by decide
+
+private theorem k5t3p2_local_2_eq_row_3 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_2 a b ∪ requiredMatrix 5 k5t3p2_step_2_data.required a b) 3 j = k5t3p2_local_2 3 j := by decide
+
+private theorem k5t3p2_local_2_eq_row_4 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_2 a b ∪ requiredMatrix 5 k5t3p2_step_2_data.required a b) 4 j = k5t3p2_local_2 4 j := by decide
+
+private theorem k5t3p2_local_2_eq_row_5 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_2 a b ∪ requiredMatrix 5 k5t3p2_step_2_data.required a b) 5 j = k5t3p2_local_2 5 j := by decide
+
+private theorem k5t3p2_local_2_eq : (fun a b => freshMatrix k5t3p2_state_2 a b ∪ requiredMatrix 5 k5t3p2_step_2_data.required a b) = k5t3p2_local_2 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t3p2_local_2_eq_row_0 j
+
+  · exact k5t3p2_local_2_eq_row_1 j
+
+  · exact k5t3p2_local_2_eq_row_2 j
+
+  · exact k5t3p2_local_2_eq_row_3 j
+
+  · exact k5t3p2_local_2_eq_row_4 j
+
+  · exact k5t3p2_local_2_eq_row_5 j
+
+private theorem k5t3p2_local_2_paths : ∀ p ∈ k5t3p2_step_2_data.required, p.Check (freshGraph k5t3p2.graph k5t3p2_step_2_data.i k5t3p2_step_2_data.j) 5 := by decide
+
+private theorem k5t3p2_local_2_bad : k5t3p2_step_2_data.bad.Check (freshGraph k5t3p2.graph k5t3p2_step_2_data.i k5t3p2_step_2_data.j) k5t3p2_local_2 5 3 := by decide
+
+private theorem k5t3p2_step_2_check : k5t3p2_step_2.Check k5t3p2.graph k5t3p2_state_2 5 3 := by
+  change k5t3p2_step_2_data.Check k5t3p2.graph k5t3p2_state_2 5 3
+  refine ⟨by decide, k5t3p2_local_2_paths, ?_⟩
+  rw [k5t3p2_local_2_eq]
+  exact k5t3p2_local_2_bad
+
+private theorem k5t3p2_update_2 : k5t3p2_step_2.apply k5t3p2_state_2 = k5t3p2_state_3 := by
+  have h : ∀ i j : Fin 5, k5t3p2_step_2.apply k5t3p2_state_2 i j = k5t3p2_state_3 i j := by decide
+  exact funext (fun i => funext (h i))
+
+private def k5t3p2_state_4 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, {1, 3, 4}, {1, 2, 3}, {1, 2, 3}, {1, 3, 4}],
+    #[{1, 3, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3, {1}],
+    #[{1, 2, 3}, {1, 2, 4}, ∅, {1, 2, 4}, {0, 2, 3}],
+    #[{1, 2, 3}, Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2}],
+    #[{1, 3, 4}, {1}, {0, 2, 3}, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private def k5t3p2_local_3 : ForbiddenMatrix 6 :=
+  fun i j => ((#[#[∅, {0}, ∅, {0}, {0}, ∅],
+    #[{0}, ∅, {1, 3, 4}, Finset.Icc 0 3, Finset.Icc 0 3, {1, 3, 4}],
+    #[∅, {1, 3, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3, ∅],
+    #[{0}, Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2, 4}, {0, 2, 3}],
+    #[{0}, Finset.Icc 0 3, Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2}],
+    #[∅, {1, 3, 4}, ∅, {0, 2, 3}, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t3p2_local_3_eq_row_0 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_3 a b ∪ requiredMatrix 5 k5t3p2_step_3_data.required a b) 0 j = k5t3p2_local_3 0 j := by decide
+
+private theorem k5t3p2_local_3_eq_row_1 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_3 a b ∪ requiredMatrix 5 k5t3p2_step_3_data.required a b) 1 j = k5t3p2_local_3 1 j := by decide
+
+private theorem k5t3p2_local_3_eq_row_2 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_3 a b ∪ requiredMatrix 5 k5t3p2_step_3_data.required a b) 2 j = k5t3p2_local_3 2 j := by decide
+
+private theorem k5t3p2_local_3_eq_row_3 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_3 a b ∪ requiredMatrix 5 k5t3p2_step_3_data.required a b) 3 j = k5t3p2_local_3 3 j := by decide
+
+private theorem k5t3p2_local_3_eq_row_4 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_3 a b ∪ requiredMatrix 5 k5t3p2_step_3_data.required a b) 4 j = k5t3p2_local_3 4 j := by decide
+
+private theorem k5t3p2_local_3_eq_row_5 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_3 a b ∪ requiredMatrix 5 k5t3p2_step_3_data.required a b) 5 j = k5t3p2_local_3 5 j := by decide
+
+private theorem k5t3p2_local_3_eq : (fun a b => freshMatrix k5t3p2_state_3 a b ∪ requiredMatrix 5 k5t3p2_step_3_data.required a b) = k5t3p2_local_3 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t3p2_local_3_eq_row_0 j
+
+  · exact k5t3p2_local_3_eq_row_1 j
+
+  · exact k5t3p2_local_3_eq_row_2 j
+
+  · exact k5t3p2_local_3_eq_row_3 j
+
+  · exact k5t3p2_local_3_eq_row_4 j
+
+  · exact k5t3p2_local_3_eq_row_5 j
+
+private theorem k5t3p2_local_3_paths : ∀ p ∈ k5t3p2_step_3_data.required, p.Check (freshGraph k5t3p2.graph k5t3p2_step_3_data.i k5t3p2_step_3_data.j) 5 := by decide
+
+private theorem k5t3p2_local_3_bad : k5t3p2_step_3_data.bad.Check (freshGraph k5t3p2.graph k5t3p2_step_3_data.i k5t3p2_step_3_data.j) k5t3p2_local_3 5 3 := by decide
+
+private theorem k5t3p2_step_3_check : k5t3p2_step_3.Check k5t3p2.graph k5t3p2_state_3 5 3 := by
+  change k5t3p2_step_3_data.Check k5t3p2.graph k5t3p2_state_3 5 3
+  refine ⟨by decide, k5t3p2_local_3_paths, ?_⟩
+  rw [k5t3p2_local_3_eq]
+  exact k5t3p2_local_3_bad
+
+private theorem k5t3p2_update_3 : k5t3p2_step_3.apply k5t3p2_state_3 = k5t3p2_state_4 := by
+  have h : ∀ i j : Fin 5, k5t3p2_step_3.apply k5t3p2_state_3 i j = k5t3p2_state_4 i j := by decide
+  exact funext (fun i => funext (h i))
+
+private def k5t3p2_state_5 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, {1, 3, 4}, {1, 2, 3}, {1, 2, 3}, {1, 3, 4}],
+    #[{1, 3, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3, {1}],
+    #[{1, 2, 3}, {1, 2, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3],
+    #[{1, 2, 3}, Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2}],
+    #[{1, 3, 4}, {1}, Finset.Icc 0 3, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private def k5t3p2_local_4 : ForbiddenMatrix 6 :=
+  fun i j => ((#[#[∅, {0}, {0, 1}, {1}, {0, 1}, ∅],
+    #[{0}, ∅, {1, 3, 4}, {1, 2, 3}, Finset.Icc 0 3, {1, 3, 4}],
+    #[{0, 1}, {1, 3, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3, {1}],
+    #[{1}, {1, 2, 3}, {1, 2, 4}, ∅, {1, 2, 4}, {0, 2, 3}],
+    #[{0, 1}, Finset.Icc 0 3, Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2}],
+    #[∅, {1, 3, 4}, {1}, {0, 2, 3}, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t3p2_local_4_eq_row_0 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_4 a b ∪ requiredMatrix 5 k5t3p2_step_4_data.required a b) 0 j = k5t3p2_local_4 0 j := by decide
+
+private theorem k5t3p2_local_4_eq_row_1 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_4 a b ∪ requiredMatrix 5 k5t3p2_step_4_data.required a b) 1 j = k5t3p2_local_4 1 j := by decide
+
+private theorem k5t3p2_local_4_eq_row_2 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_4 a b ∪ requiredMatrix 5 k5t3p2_step_4_data.required a b) 2 j = k5t3p2_local_4 2 j := by decide
+
+private theorem k5t3p2_local_4_eq_row_3 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_4 a b ∪ requiredMatrix 5 k5t3p2_step_4_data.required a b) 3 j = k5t3p2_local_4 3 j := by decide
+
+private theorem k5t3p2_local_4_eq_row_4 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_4 a b ∪ requiredMatrix 5 k5t3p2_step_4_data.required a b) 4 j = k5t3p2_local_4 4 j := by decide
+
+private theorem k5t3p2_local_4_eq_row_5 : ∀ j : Fin 6, (fun a b => freshMatrix k5t3p2_state_4 a b ∪ requiredMatrix 5 k5t3p2_step_4_data.required a b) 5 j = k5t3p2_local_4 5 j := by decide
+
+private theorem k5t3p2_local_4_eq : (fun a b => freshMatrix k5t3p2_state_4 a b ∪ requiredMatrix 5 k5t3p2_step_4_data.required a b) = k5t3p2_local_4 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t3p2_local_4_eq_row_0 j
+
+  · exact k5t3p2_local_4_eq_row_1 j
+
+  · exact k5t3p2_local_4_eq_row_2 j
+
+  · exact k5t3p2_local_4_eq_row_3 j
+
+  · exact k5t3p2_local_4_eq_row_4 j
+
+  · exact k5t3p2_local_4_eq_row_5 j
+
+private theorem k5t3p2_local_4_paths : ∀ p ∈ k5t3p2_step_4_data.required, p.Check (freshGraph k5t3p2.graph k5t3p2_step_4_data.i k5t3p2_step_4_data.j) 5 := by decide
+
+private theorem k5t3p2_local_4_bad : k5t3p2_step_4_data.bad.Check (freshGraph k5t3p2.graph k5t3p2_step_4_data.i k5t3p2_step_4_data.j) k5t3p2_local_4 5 3 := by decide
+
+private theorem k5t3p2_step_4_check : k5t3p2_step_4.Check k5t3p2.graph k5t3p2_state_4 5 3 := by
+  change k5t3p2_step_4_data.Check k5t3p2.graph k5t3p2_state_4 5 3
+  refine ⟨by decide, k5t3p2_local_4_paths, ?_⟩
+  rw [k5t3p2_local_4_eq]
+  exact k5t3p2_local_4_bad
+
+private theorem k5t3p2_update_4 : k5t3p2_step_4.apply k5t3p2_state_4 = k5t3p2_state_5 := by
+  have h : ∀ i j : Fin 5, k5t3p2_step_4.apply k5t3p2_state_4 i j = k5t3p2_state_5 i j := by decide
+  exact funext (fun i => funext (h i))
+
+private def k5t3p2_state_6 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, {1, 3, 4}, Finset.Icc 0 3, {1, 2, 3}, {1, 3, 4}],
+    #[{1, 3, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3, {1}],
+    #[Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3],
+    #[{1, 2, 3}, Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2}],
+    #[{1, 3, 4}, {1}, Finset.Icc 0 3, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private def k5t3p2_local_5 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, {1, 3, 4}, Finset.Icc 1 4, {1, 2, 3}, Finset.Icc 1 4],
+    #[{1, 3, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3, {1}],
+    #[Finset.Icc 1 4, {1, 2, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3],
+    #[{1, 2, 3}, Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2}],
+    #[Finset.Icc 1 4, {1}, Finset.Icc 0 3, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t3p2_local_5_eq_row_0 : ∀ j : Fin 5, (fun a b => k5t3p2_state_5 a b ∪ requiredMatrix 5 k5t3p2_step_5_data.required a b) 0 j = k5t3p2_local_5 0 j := by decide
+
+private theorem k5t3p2_local_5_eq_row_1 : ∀ j : Fin 5, (fun a b => k5t3p2_state_5 a b ∪ requiredMatrix 5 k5t3p2_step_5_data.required a b) 1 j = k5t3p2_local_5 1 j := by decide
+
+private theorem k5t3p2_local_5_eq_row_2 : ∀ j : Fin 5, (fun a b => k5t3p2_state_5 a b ∪ requiredMatrix 5 k5t3p2_step_5_data.required a b) 2 j = k5t3p2_local_5 2 j := by decide
+
+private theorem k5t3p2_local_5_eq_row_3 : ∀ j : Fin 5, (fun a b => k5t3p2_state_5 a b ∪ requiredMatrix 5 k5t3p2_step_5_data.required a b) 3 j = k5t3p2_local_5 3 j := by decide
+
+private theorem k5t3p2_local_5_eq_row_4 : ∀ j : Fin 5, (fun a b => k5t3p2_state_5 a b ∪ requiredMatrix 5 k5t3p2_step_5_data.required a b) 4 j = k5t3p2_local_5 4 j := by decide
+
+private theorem k5t3p2_local_5_eq : (fun a b => k5t3p2_state_5 a b ∪ requiredMatrix 5 k5t3p2_step_5_data.required a b) = k5t3p2_local_5 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t3p2_local_5_eq_row_0 j
+
+  · exact k5t3p2_local_5_eq_row_1 j
+
+  · exact k5t3p2_local_5_eq_row_2 j
+
+  · exact k5t3p2_local_5_eq_row_3 j
+
+  · exact k5t3p2_local_5_eq_row_4 j
+
+private theorem k5t3p2_local_5_paths : ∀ p ∈ k5t3p2_step_5_data.required, p.Check (addedEdgeGraph k5t3p2.graph k5t3p2_step_5_data.i k5t3p2_step_5_data.j) 5 := by decide
+
+private theorem k5t3p2_local_5_bad : k5t3p2_step_5_data.bad.Check (addedEdgeGraph k5t3p2.graph k5t3p2_step_5_data.i k5t3p2_step_5_data.j) k5t3p2_local_5 5 3 := by decide
+
+private theorem k5t3p2_step_5_check : k5t3p2_step_5.Check k5t3p2.graph k5t3p2_state_5 5 3 := by
+  change k5t3p2_step_5_data.Check k5t3p2.graph k5t3p2_state_5 5 3
+  refine ⟨k5t3p2_local_5_paths, ?_⟩
+  rw [k5t3p2_local_5_eq]
+  exact k5t3p2_local_5_bad
+
+private theorem k5t3p2_update_5 : k5t3p2_step_5.apply k5t3p2_state_5 = k5t3p2_state_6 := by
+  have h : ∀ i j : Fin 5, k5t3p2_step_5.apply k5t3p2_state_5 i j = k5t3p2_state_6 i j := by decide
+  exact funext (fun i => funext (h i))
+
+private def k5t3p2_state_7 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, {1, 3, 4}, Finset.Icc 0 3, Finset.Icc 0 3, {1, 3, 4}],
+    #[{1, 3, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3, {1}],
+    #[Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3],
+    #[Finset.Icc 0 3, Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2}],
+    #[{1, 3, 4}, {1}, Finset.Icc 0 3, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private def k5t3p2_local_6 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, Finset.Icc 1 4, Finset.Icc 0 3, {1, 2, 3}, {1, 3, 4}],
+    #[Finset.Icc 1 4, ∅, {1, 2, 4}, Finset.Icc 0 3, {1}],
+    #[Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2, 4}, Finset.Icc 0 3],
+    #[{1, 2, 3}, Finset.Icc 0 3, {1, 2, 4}, ∅, {1, 2}],
+    #[{1, 3, 4}, {1}, Finset.Icc 0 3, {1, 2}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t3p2_local_6_eq_row_0 : ∀ j : Fin 5, (fun a b => k5t3p2_state_6 a b ∪ requiredMatrix 5 k5t3p2_step_6_data.required a b) 0 j = k5t3p2_local_6 0 j := by decide
+
+private theorem k5t3p2_local_6_eq_row_1 : ∀ j : Fin 5, (fun a b => k5t3p2_state_6 a b ∪ requiredMatrix 5 k5t3p2_step_6_data.required a b) 1 j = k5t3p2_local_6 1 j := by decide
+
+private theorem k5t3p2_local_6_eq_row_2 : ∀ j : Fin 5, (fun a b => k5t3p2_state_6 a b ∪ requiredMatrix 5 k5t3p2_step_6_data.required a b) 2 j = k5t3p2_local_6 2 j := by decide
+
+private theorem k5t3p2_local_6_eq_row_3 : ∀ j : Fin 5, (fun a b => k5t3p2_state_6 a b ∪ requiredMatrix 5 k5t3p2_step_6_data.required a b) 3 j = k5t3p2_local_6 3 j := by decide
+
+private theorem k5t3p2_local_6_eq_row_4 : ∀ j : Fin 5, (fun a b => k5t3p2_state_6 a b ∪ requiredMatrix 5 k5t3p2_step_6_data.required a b) 4 j = k5t3p2_local_6 4 j := by decide
+
+private theorem k5t3p2_local_6_eq : (fun a b => k5t3p2_state_6 a b ∪ requiredMatrix 5 k5t3p2_step_6_data.required a b) = k5t3p2_local_6 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t3p2_local_6_eq_row_0 j
+
+  · exact k5t3p2_local_6_eq_row_1 j
+
+  · exact k5t3p2_local_6_eq_row_2 j
+
+  · exact k5t3p2_local_6_eq_row_3 j
+
+  · exact k5t3p2_local_6_eq_row_4 j
+
+private theorem k5t3p2_local_6_paths : ∀ p ∈ k5t3p2_step_6_data.required, p.Check (addedEdgeGraph k5t3p2.graph k5t3p2_step_6_data.i k5t3p2_step_6_data.j) 5 := by decide
+
+private theorem k5t3p2_local_6_bad : k5t3p2_step_6_data.bad.Check (addedEdgeGraph k5t3p2.graph k5t3p2_step_6_data.i k5t3p2_step_6_data.j) k5t3p2_local_6 5 3 := by decide
+
+private theorem k5t3p2_step_6_check : k5t3p2_step_6.Check k5t3p2.graph k5t3p2_state_6 5 3 := by
+  change k5t3p2_step_6_data.Check k5t3p2.graph k5t3p2_state_6 5 3
+  refine ⟨k5t3p2_local_6_paths, ?_⟩
+  rw [k5t3p2_local_6_eq]
+  exact k5t3p2_local_6_bad
+
+private theorem k5t3p2_update_6 : k5t3p2_step_6.apply k5t3p2_state_6 = k5t3p2_state_7 := by
+  have h : ∀ i j : Fin 5, k5t3p2_step_6.apply k5t3p2_state_6 i j = k5t3p2_state_7 i j := by decide
+  exact funext (fun i => funext (h i))
+
+private theorem k5t3p2_closure_7 : ClosureCheck k5t3p2.graph k5t3p2_state_7 5 3 [] := by trivial
+
+private theorem k5t3p2_closure_6 : ClosureCheck k5t3p2.graph k5t3p2_state_6 5 3 [k5t3p2_step_6] := by
+  constructor
+  · exact k5t3p2_step_6_check
+  · rw [k5t3p2_update_6]
+    exact k5t3p2_closure_7
+
+private theorem k5t3p2_closure_5 : ClosureCheck k5t3p2.graph k5t3p2_state_5 5 3 [k5t3p2_step_5, k5t3p2_step_6] := by
+  constructor
+  · exact k5t3p2_step_5_check
+  · rw [k5t3p2_update_5]
+    exact k5t3p2_closure_6
+
+private theorem k5t3p2_closure_4 : ClosureCheck k5t3p2.graph k5t3p2_state_4 5 3 [k5t3p2_step_4, k5t3p2_step_5, k5t3p2_step_6] := by
+  constructor
+  · exact k5t3p2_step_4_check
+  · rw [k5t3p2_update_4]
+    exact k5t3p2_closure_5
+
+private theorem k5t3p2_closure_3 : ClosureCheck k5t3p2.graph k5t3p2_state_3 5 3 [k5t3p2_step_3, k5t3p2_step_4, k5t3p2_step_5, k5t3p2_step_6] := by
+  constructor
+  · exact k5t3p2_step_3_check
+  · rw [k5t3p2_update_3]
+    exact k5t3p2_closure_4
+
+private theorem k5t3p2_closure_2 : ClosureCheck k5t3p2.graph k5t3p2_state_2 5 3 [k5t3p2_step_2, k5t3p2_step_3, k5t3p2_step_4, k5t3p2_step_5, k5t3p2_step_6] := by
+  constructor
+  · exact k5t3p2_step_2_check
+  · rw [k5t3p2_update_2]
+    exact k5t3p2_closure_3
+
+private theorem k5t3p2_closure_1 : ClosureCheck k5t3p2.graph k5t3p2_state_1 5 3 [k5t3p2_step_1, k5t3p2_step_2, k5t3p2_step_3, k5t3p2_step_4, k5t3p2_step_5, k5t3p2_step_6] := by
+  constructor
+  · exact k5t3p2_step_1_check
+  · rw [k5t3p2_update_1]
+    exact k5t3p2_closure_2
+
+private theorem k5t3p2_closure_0 : ClosureCheck k5t3p2.graph k5t3p2_state_0 5 3 [k5t3p2_step_0, k5t3p2_step_1, k5t3p2_step_2, k5t3p2_step_3, k5t3p2_step_4, k5t3p2_step_5, k5t3p2_step_6] := by
+  constructor
+  · exact k5t3p2_step_0_check
+  · rw [k5t3p2_update_0]
+    exact k5t3p2_closure_1
+
+private theorem k5t3p2_matrix_eq : k5t3p2.matrix 5 = k5t3p2_state_7 := by
+  change closureMatrix (k5t3p2.initialMatrix 5) _ = _
+  rw [k5t3p2_initial_eq]
+  change closureMatrix k5t3p2_state_0 [k5t3p2_step_0, k5t3p2_step_1, k5t3p2_step_2, k5t3p2_step_3, k5t3p2_step_4, k5t3p2_step_5, k5t3p2_step_6] = _
+  simp only [closureMatrix]
+  rw [k5t3p2_update_0, k5t3p2_update_1, k5t3p2_update_2, k5t3p2_update_3, k5t3p2_update_4, k5t3p2_update_5, k5t3p2_update_6]
+
+private theorem k5t3p2_part_0 : k5t3p2.chains.flatten = List.finRange _ := by decide
+
+private theorem k5t3p2_part_1 : k5t3p2.chains.map List.length = ([[], [2]] : List (List ℕ)).map (fun w => w.sum + w.length + 1) := by decide
+
+private theorem k5t3p2_part_2 : k5t3p2.chains.map (fun l => l.map (fun i => decide (i ∈ k5t3p2.clique))) = ([[], [2]] : List (List ℕ)).map profileMask := by decide
+
+private theorem k5t3p2_templates_item_0 : (⟨0, 1, [], [], [], 3, 4⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_templates_item_1 : (⟨0, 1, [], [], [2, 3, 4], 1, 1⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_templates_item_2 : (⟨0, 2, [], [], [1], 2, 3⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_templates_item_3 : (⟨0, 2, [], [], [3, 4], 1, 2⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_templates_item_4 : (⟨0, 3, [], [], [2, 1], 1, 2⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_templates_item_5 : (⟨0, 3, [], [], [4], 2, 3⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_templates_item_6 : (⟨0, 4, [], [], [], 3, 4⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_templates_item_7 : (⟨0, 4, [], [], [3, 2, 1], 1, 1⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_templates_item_8 : (⟨1, 2, [], [], [3, 4], 1, 2⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_templates_item_9 : (⟨1, 3, [], [], [4], 2, 3⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_templates_item_10 : (⟨2, 3, [], [1], [4], 1, 2⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_templates_item_11 : (⟨2, 4, [], [1], [], 2, 3⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_templates_item_12 : (⟨3, 4, [], [1, 2], [], 1, 2⟩ : TemplateData (Fin 5)).Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p2_part_3 : ∀ T ∈ k5t3p2.templates, T.Check k5t3p2.graph k5t3p2.clique 5 (patternAmount ([[], [2]] : List (List ℕ))) (([[], [2]] : List (List ℕ)).map List.length).sum := by
+  simp only [k5t3p2, List.forall_mem_cons, List.not_mem_nil, IsEmpty.forall_iff, implies_true, and_true]
+  exact ⟨k5t3p2_templates_item_0, k5t3p2_templates_item_1, k5t3p2_templates_item_2, k5t3p2_templates_item_3, k5t3p2_templates_item_4, k5t3p2_templates_item_5, k5t3p2_templates_item_6, k5t3p2_templates_item_7, k5t3p2_templates_item_8, k5t3p2_templates_item_9, k5t3p2_templates_item_10, k5t3p2_templates_item_11, k5t3p2_templates_item_12⟩
+
+private theorem k5t3p2_required_item_0 : (⟨1, 2, []⟩ : RequiredPathData (Fin 5)).Check k5t3p2.graph 5 := by decide
+
+private theorem k5t3p2_required_item_1 : (⟨2, 3, []⟩ : RequiredPathData (Fin 5)).Check k5t3p2.graph 5 := by decide
+
+private theorem k5t3p2_part_4 : ∀ p ∈ k5t3p2.required, p.Check k5t3p2.graph 5 := by
+  simp only [k5t3p2, List.forall_mem_cons, List.not_mem_nil, IsEmpty.forall_iff, implies_true, and_true]
+  exact ⟨k5t3p2_required_item_0, k5t3p2_required_item_1⟩
+
+private theorem k5t3p2_part_5 : ClosureCheck k5t3p2.graph (k5t3p2.initialMatrix 5) 5 3 k5t3p2.closure := by
+  rw [k5t3p2_initial_eq]
+  exact k5t3p2_closure_0
+
+private theorem k5t3p2_part_6 : k5t3p2.bad.Check k5t3p2.graph (k5t3p2.matrix 5) 5 3 := by
+  rw [k5t3p2_matrix_eq]
+  decide
+
+theorem k5t3p2_check : k5t3p2.Check 5 3 [[], [2]] :=
+  ⟨k5t3p2_part_0, k5t3p2_part_1, k5t3p2_part_2, k5t3p2_part_3, k5t3p2_part_4, k5t3p2_part_5, k5t3p2_part_6⟩
+def k5t3p3 : LayoutCertificate 5 where
+  chains := [[0, 1, 2, 3, 4]]
+  clique := {0, 2, 4}
+  templates := [⟨0, 1, [], [], [2], 1, 3⟩,
+    ⟨0, 3, [], [], [2], 1, 3⟩,
+    ⟨0, 4, [], [], [], 2, 4⟩,
+    ⟨1, 3, [], [0], [2], 1, 2⟩,
+    ⟨1, 4, [], [0], [], 1, 3⟩,
+    ⟨3, 4, [], [2], [], 1, 3⟩]
+  required := [⟨0, 4, [1, 2, 3]⟩]
+  closure := []
+  bad := ⟨none, {(1, 0), (0, 2), (4, 2), (3, 1)}⟩
+
+
+private def k5t3p3_state_0 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, {1, 2, 3}, ∅, {1, 2, 3}, Finset.Icc 1 4],
+    #[{1, 2, 3}, ∅, ∅, {1, 2}, {1, 2, 3}],
+    #[∅, ∅, ∅, ∅, ∅],
+    #[{1, 2, 3}, {1, 2}, ∅, ∅, {1, 2, 3}],
+    #[Finset.Icc 1 4, {1, 2, 3}, ∅, {1, 2, 3}, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t3p3_initial_eq_row_0 : ∀ j : Fin 5, (k5t3p3.initialMatrix 5) 0 j = k5t3p3_state_0 0 j := by decide
+
+private theorem k5t3p3_initial_eq_row_1 : ∀ j : Fin 5, (k5t3p3.initialMatrix 5) 1 j = k5t3p3_state_0 1 j := by decide
+
+private theorem k5t3p3_initial_eq_row_2 : ∀ j : Fin 5, (k5t3p3.initialMatrix 5) 2 j = k5t3p3_state_0 2 j := by decide
+
+private theorem k5t3p3_initial_eq_row_3 : ∀ j : Fin 5, (k5t3p3.initialMatrix 5) 3 j = k5t3p3_state_0 3 j := by decide
+
+private theorem k5t3p3_initial_eq_row_4 : ∀ j : Fin 5, (k5t3p3.initialMatrix 5) 4 j = k5t3p3_state_0 4 j := by decide
+
+private theorem k5t3p3_initial_eq : (k5t3p3.initialMatrix 5) = k5t3p3_state_0 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t3p3_initial_eq_row_0 j
+
+  · exact k5t3p3_initial_eq_row_1 j
+
+  · exact k5t3p3_initial_eq_row_2 j
+
+  · exact k5t3p3_initial_eq_row_3 j
+
+  · exact k5t3p3_initial_eq_row_4 j
+
+private theorem k5t3p3_closure_0 : ClosureCheck k5t3p3.graph k5t3p3_state_0 5 3 [] := by trivial
+
+private theorem k5t3p3_matrix_eq : k5t3p3.matrix 5 = k5t3p3_state_0 := by
+  change closureMatrix (k5t3p3.initialMatrix 5) _ = _
+  rw [k5t3p3_initial_eq]
+  change closureMatrix k5t3p3_state_0 [] = _
+  rfl
+
+private theorem k5t3p3_part_0 : k5t3p3.chains.flatten = List.finRange _ := by decide
+
+private theorem k5t3p3_part_1 : k5t3p3.chains.map List.length = ([[1, 1]] : List (List ℕ)).map (fun w => w.sum + w.length + 1) := by decide
+
+private theorem k5t3p3_part_2 : k5t3p3.chains.map (fun l => l.map (fun i => decide (i ∈ k5t3p3.clique))) = ([[1, 1]] : List (List ℕ)).map profileMask := by decide
+
+private theorem k5t3p3_templates_item_0 : (⟨0, 1, [], [], [2], 1, 3⟩ : TemplateData (Fin 5)).Check k5t3p3.graph k5t3p3.clique 5 (patternAmount ([[1, 1]] : List (List ℕ))) (([[1, 1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p3_templates_item_1 : (⟨0, 3, [], [], [2], 1, 3⟩ : TemplateData (Fin 5)).Check k5t3p3.graph k5t3p3.clique 5 (patternAmount ([[1, 1]] : List (List ℕ))) (([[1, 1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p3_templates_item_2 : (⟨0, 4, [], [], [], 2, 4⟩ : TemplateData (Fin 5)).Check k5t3p3.graph k5t3p3.clique 5 (patternAmount ([[1, 1]] : List (List ℕ))) (([[1, 1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p3_templates_item_3 : (⟨1, 3, [], [0], [2], 1, 2⟩ : TemplateData (Fin 5)).Check k5t3p3.graph k5t3p3.clique 5 (patternAmount ([[1, 1]] : List (List ℕ))) (([[1, 1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p3_templates_item_4 : (⟨1, 4, [], [0], [], 1, 3⟩ : TemplateData (Fin 5)).Check k5t3p3.graph k5t3p3.clique 5 (patternAmount ([[1, 1]] : List (List ℕ))) (([[1, 1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p3_templates_item_5 : (⟨3, 4, [], [2], [], 1, 3⟩ : TemplateData (Fin 5)).Check k5t3p3.graph k5t3p3.clique 5 (patternAmount ([[1, 1]] : List (List ℕ))) (([[1, 1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t3p3_part_3 : ∀ T ∈ k5t3p3.templates, T.Check k5t3p3.graph k5t3p3.clique 5 (patternAmount ([[1, 1]] : List (List ℕ))) (([[1, 1]] : List (List ℕ)).map List.length).sum := by
+  simp only [k5t3p3, List.forall_mem_cons, List.not_mem_nil, IsEmpty.forall_iff, implies_true, and_true]
+  exact ⟨k5t3p3_templates_item_0, k5t3p3_templates_item_1, k5t3p3_templates_item_2, k5t3p3_templates_item_3, k5t3p3_templates_item_4, k5t3p3_templates_item_5⟩
+
+private theorem k5t3p3_required_item_0 : (⟨0, 4, [1, 2, 3]⟩ : RequiredPathData (Fin 5)).Check k5t3p3.graph 5 := by decide
+
+private theorem k5t3p3_part_4 : ∀ p ∈ k5t3p3.required, p.Check k5t3p3.graph 5 := by
+  simp only [k5t3p3, List.forall_mem_cons, List.not_mem_nil, IsEmpty.forall_iff, implies_true, and_true]
+  exact k5t3p3_required_item_0
+
+private theorem k5t3p3_part_5 : ClosureCheck k5t3p3.graph (k5t3p3.initialMatrix 5) 5 3 k5t3p3.closure := by
+  rw [k5t3p3_initial_eq]
+  exact k5t3p3_closure_0
+
+private theorem k5t3p3_part_6 : k5t3p3.bad.Check k5t3p3.graph (k5t3p3.matrix 5) 5 3 := by
+  rw [k5t3p3_matrix_eq]
+  decide
+
+theorem k5t3p3_check : k5t3p3.Check 5 3 [[1, 1]] :=
+  ⟨k5t3p3_part_0, k5t3p3_part_1, k5t3p3_part_2, k5t3p3_part_3, k5t3p3_part_4, k5t3p3_part_5, k5t3p3_part_6⟩
+def k5t4p0 : LayoutCertificate 4 where
+  chains := [[0], [1], [2], [3]]
+  clique := {0, 1, 2, 3}
+  templates := [⟨0, 1, [], [], [], 1, 4⟩,
+    ⟨0, 2, [], [], [], 1, 4⟩,
+    ⟨0, 3, [], [], [], 1, 4⟩,
+    ⟨1, 2, [], [], [], 1, 4⟩,
+    ⟨1, 3, [], [], [], 1, 4⟩,
+    ⟨2, 3, [], [], [], 1, 4⟩]
+  required := []
+  closure := []
+  bad := ⟨none, {(0, 2), (1, 2), (2, 2)}⟩
+
+
+private def k5t4p0_state_0 : ForbiddenMatrix 4 :=
+  fun i j => ((#[#[∅, Finset.Icc 1 4, Finset.Icc 1 4, Finset.Icc 1 4],
+    #[Finset.Icc 1 4, ∅, Finset.Icc 1 4, Finset.Icc 1 4],
+    #[Finset.Icc 1 4, Finset.Icc 1 4, ∅, Finset.Icc 1 4],
+    #[Finset.Icc 1 4, Finset.Icc 1 4, Finset.Icc 1 4, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t4p0_initial_eq_row_0 : ∀ j : Fin 4, (k5t4p0.initialMatrix 5) 0 j = k5t4p0_state_0 0 j := by decide
+
+private theorem k5t4p0_initial_eq_row_1 : ∀ j : Fin 4, (k5t4p0.initialMatrix 5) 1 j = k5t4p0_state_0 1 j := by decide
+
+private theorem k5t4p0_initial_eq_row_2 : ∀ j : Fin 4, (k5t4p0.initialMatrix 5) 2 j = k5t4p0_state_0 2 j := by decide
+
+private theorem k5t4p0_initial_eq_row_3 : ∀ j : Fin 4, (k5t4p0.initialMatrix 5) 3 j = k5t4p0_state_0 3 j := by decide
+
+private theorem k5t4p0_initial_eq : (k5t4p0.initialMatrix 5) = k5t4p0_state_0 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t4p0_initial_eq_row_0 j
+
+  · exact k5t4p0_initial_eq_row_1 j
+
+  · exact k5t4p0_initial_eq_row_2 j
+
+  · exact k5t4p0_initial_eq_row_3 j
+
+private theorem k5t4p0_closure_0 : ClosureCheck k5t4p0.graph k5t4p0_state_0 5 4 [] := by trivial
+
+private theorem k5t4p0_matrix_eq : k5t4p0.matrix 5 = k5t4p0_state_0 := by
+  change closureMatrix (k5t4p0.initialMatrix 5) _ = _
+  rw [k5t4p0_initial_eq]
+  change closureMatrix k5t4p0_state_0 [] = _
+  rfl
+
+private theorem k5t4p0_part_0 : k5t4p0.chains.flatten = List.finRange _ := by decide
+
+private theorem k5t4p0_part_1 : k5t4p0.chains.map List.length = ([[], [], [], []] : List (List ℕ)).map (fun w => w.sum + w.length + 1) := by decide
+
+private theorem k5t4p0_part_2 : k5t4p0.chains.map (fun l => l.map (fun i => decide (i ∈ k5t4p0.clique))) = ([[], [], [], []] : List (List ℕ)).map profileMask := by decide
+
+private theorem k5t4p0_templates_item_0 : (⟨0, 1, [], [], [], 1, 4⟩ : TemplateData (Fin 4)).Check k5t4p0.graph k5t4p0.clique 5 (patternAmount ([[], [], [], []] : List (List ℕ))) (([[], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p0_templates_item_1 : (⟨0, 2, [], [], [], 1, 4⟩ : TemplateData (Fin 4)).Check k5t4p0.graph k5t4p0.clique 5 (patternAmount ([[], [], [], []] : List (List ℕ))) (([[], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p0_templates_item_2 : (⟨0, 3, [], [], [], 1, 4⟩ : TemplateData (Fin 4)).Check k5t4p0.graph k5t4p0.clique 5 (patternAmount ([[], [], [], []] : List (List ℕ))) (([[], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p0_templates_item_3 : (⟨1, 2, [], [], [], 1, 4⟩ : TemplateData (Fin 4)).Check k5t4p0.graph k5t4p0.clique 5 (patternAmount ([[], [], [], []] : List (List ℕ))) (([[], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p0_templates_item_4 : (⟨1, 3, [], [], [], 1, 4⟩ : TemplateData (Fin 4)).Check k5t4p0.graph k5t4p0.clique 5 (patternAmount ([[], [], [], []] : List (List ℕ))) (([[], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p0_templates_item_5 : (⟨2, 3, [], [], [], 1, 4⟩ : TemplateData (Fin 4)).Check k5t4p0.graph k5t4p0.clique 5 (patternAmount ([[], [], [], []] : List (List ℕ))) (([[], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p0_part_3 : ∀ T ∈ k5t4p0.templates, T.Check k5t4p0.graph k5t4p0.clique 5 (patternAmount ([[], [], [], []] : List (List ℕ))) (([[], [], [], []] : List (List ℕ)).map List.length).sum := by
+  simp only [k5t4p0, List.forall_mem_cons, List.not_mem_nil, IsEmpty.forall_iff, implies_true, and_true]
+  exact ⟨k5t4p0_templates_item_0, k5t4p0_templates_item_1, k5t4p0_templates_item_2, k5t4p0_templates_item_3, k5t4p0_templates_item_4, k5t4p0_templates_item_5⟩
+
+private theorem k5t4p0_part_4 : ∀ p ∈ k5t4p0.required, p.Check k5t4p0.graph 5 := by decide
+
+private theorem k5t4p0_part_5 : ClosureCheck k5t4p0.graph (k5t4p0.initialMatrix 5) 5 4 k5t4p0.closure := by
+  rw [k5t4p0_initial_eq]
+  exact k5t4p0_closure_0
+
+private theorem k5t4p0_part_6 : k5t4p0.bad.Check k5t4p0.graph (k5t4p0.matrix 5) 5 4 := by
+  rw [k5t4p0_matrix_eq]
+  decide
+
+theorem k5t4p0_check : k5t4p0.Check 5 4 [[], [], [], []] :=
+  ⟨k5t4p0_part_0, k5t4p0_part_1, k5t4p0_part_2, k5t4p0_part_3, k5t4p0_part_4, k5t4p0_part_5, k5t4p0_part_6⟩
+def k5t4p1 : LayoutCertificate 5 where
+  chains := [[0], [1], [2, 3, 4]]
+  clique := {0, 1, 2, 4}
+  templates := [⟨0, 1, [], [], [], 2, 4⟩,
+    ⟨0, 1, [[2, 3, 4]], [], [], 1, 1⟩,
+    ⟨0, 2, [], [], [], 2, 4⟩,
+    ⟨0, 2, [], [], [3, 4], 1, 2⟩,
+    ⟨0, 3, [], [], [2], 1, 3⟩,
+    ⟨0, 4, [], [], [], 2, 4⟩,
+    ⟨0, 4, [], [], [3, 2], 1, 2⟩,
+    ⟨1, 2, [], [], [], 2, 4⟩,
+    ⟨1, 2, [], [], [3, 4], 1, 2⟩,
+    ⟨1, 3, [], [], [2], 1, 3⟩,
+    ⟨2, 3, [], [], [4], 1, 3⟩]
+  required := []
+  closure := []
+  bad := ⟨none, {(0, 3), (1, 1), (2, 1), (3, 0)}⟩
+
+
+private def k5t4p1_state_0 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, Finset.Icc 1 4, Finset.Icc 1 4, {1, 2, 3}, Finset.Icc 1 4],
+    #[Finset.Icc 1 4, ∅, Finset.Icc 1 4, {1, 2, 3}, ∅],
+    #[Finset.Icc 1 4, Finset.Icc 1 4, ∅, {1, 2, 3}, ∅],
+    #[{1, 2, 3}, {1, 2, 3}, {1, 2, 3}, ∅, ∅],
+    #[Finset.Icc 1 4, ∅, ∅, ∅, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t4p1_initial_eq_row_0 : ∀ j : Fin 5, (k5t4p1.initialMatrix 5) 0 j = k5t4p1_state_0 0 j := by decide
+
+private theorem k5t4p1_initial_eq_row_1 : ∀ j : Fin 5, (k5t4p1.initialMatrix 5) 1 j = k5t4p1_state_0 1 j := by decide
+
+private theorem k5t4p1_initial_eq_row_2 : ∀ j : Fin 5, (k5t4p1.initialMatrix 5) 2 j = k5t4p1_state_0 2 j := by decide
+
+private theorem k5t4p1_initial_eq_row_3 : ∀ j : Fin 5, (k5t4p1.initialMatrix 5) 3 j = k5t4p1_state_0 3 j := by decide
+
+private theorem k5t4p1_initial_eq_row_4 : ∀ j : Fin 5, (k5t4p1.initialMatrix 5) 4 j = k5t4p1_state_0 4 j := by decide
+
+private theorem k5t4p1_initial_eq : (k5t4p1.initialMatrix 5) = k5t4p1_state_0 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t4p1_initial_eq_row_0 j
+
+  · exact k5t4p1_initial_eq_row_1 j
+
+  · exact k5t4p1_initial_eq_row_2 j
+
+  · exact k5t4p1_initial_eq_row_3 j
+
+  · exact k5t4p1_initial_eq_row_4 j
+
+private theorem k5t4p1_closure_0 : ClosureCheck k5t4p1.graph k5t4p1_state_0 5 4 [] := by trivial
+
+private theorem k5t4p1_matrix_eq : k5t4p1.matrix 5 = k5t4p1_state_0 := by
+  change closureMatrix (k5t4p1.initialMatrix 5) _ = _
+  rw [k5t4p1_initial_eq]
+  change closureMatrix k5t4p1_state_0 [] = _
+  rfl
+
+private theorem k5t4p1_part_0 : k5t4p1.chains.flatten = List.finRange _ := by decide
+
+private theorem k5t4p1_part_1 : k5t4p1.chains.map List.length = ([[], [], [1]] : List (List ℕ)).map (fun w => w.sum + w.length + 1) := by decide
+
+private theorem k5t4p1_part_2 : k5t4p1.chains.map (fun l => l.map (fun i => decide (i ∈ k5t4p1.clique))) = ([[], [], [1]] : List (List ℕ)).map profileMask := by decide
+
+private theorem k5t4p1_templates_item_0 : (⟨0, 1, [], [], [], 2, 4⟩ : TemplateData (Fin 5)).Check k5t4p1.graph k5t4p1.clique 5 (patternAmount ([[], [], [1]] : List (List ℕ))) (([[], [], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p1_templates_item_1 : (⟨0, 1, [[2, 3, 4]], [], [], 1, 1⟩ : TemplateData (Fin 5)).Check k5t4p1.graph k5t4p1.clique 5 (patternAmount ([[], [], [1]] : List (List ℕ))) (([[], [], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p1_templates_item_2 : (⟨0, 2, [], [], [], 2, 4⟩ : TemplateData (Fin 5)).Check k5t4p1.graph k5t4p1.clique 5 (patternAmount ([[], [], [1]] : List (List ℕ))) (([[], [], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p1_templates_item_3 : (⟨0, 2, [], [], [3, 4], 1, 2⟩ : TemplateData (Fin 5)).Check k5t4p1.graph k5t4p1.clique 5 (patternAmount ([[], [], [1]] : List (List ℕ))) (([[], [], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p1_templates_item_4 : (⟨0, 3, [], [], [2], 1, 3⟩ : TemplateData (Fin 5)).Check k5t4p1.graph k5t4p1.clique 5 (patternAmount ([[], [], [1]] : List (List ℕ))) (([[], [], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p1_templates_item_5 : (⟨0, 4, [], [], [], 2, 4⟩ : TemplateData (Fin 5)).Check k5t4p1.graph k5t4p1.clique 5 (patternAmount ([[], [], [1]] : List (List ℕ))) (([[], [], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p1_templates_item_6 : (⟨0, 4, [], [], [3, 2], 1, 2⟩ : TemplateData (Fin 5)).Check k5t4p1.graph k5t4p1.clique 5 (patternAmount ([[], [], [1]] : List (List ℕ))) (([[], [], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p1_templates_item_7 : (⟨1, 2, [], [], [], 2, 4⟩ : TemplateData (Fin 5)).Check k5t4p1.graph k5t4p1.clique 5 (patternAmount ([[], [], [1]] : List (List ℕ))) (([[], [], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p1_templates_item_8 : (⟨1, 2, [], [], [3, 4], 1, 2⟩ : TemplateData (Fin 5)).Check k5t4p1.graph k5t4p1.clique 5 (patternAmount ([[], [], [1]] : List (List ℕ))) (([[], [], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p1_templates_item_9 : (⟨1, 3, [], [], [2], 1, 3⟩ : TemplateData (Fin 5)).Check k5t4p1.graph k5t4p1.clique 5 (patternAmount ([[], [], [1]] : List (List ℕ))) (([[], [], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p1_templates_item_10 : (⟨2, 3, [], [], [4], 1, 3⟩ : TemplateData (Fin 5)).Check k5t4p1.graph k5t4p1.clique 5 (patternAmount ([[], [], [1]] : List (List ℕ))) (([[], [], [1]] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t4p1_part_3 : ∀ T ∈ k5t4p1.templates, T.Check k5t4p1.graph k5t4p1.clique 5 (patternAmount ([[], [], [1]] : List (List ℕ))) (([[], [], [1]] : List (List ℕ)).map List.length).sum := by
+  simp only [k5t4p1, List.forall_mem_cons, List.not_mem_nil, IsEmpty.forall_iff, implies_true, and_true]
+  exact ⟨k5t4p1_templates_item_0, k5t4p1_templates_item_1, k5t4p1_templates_item_2, k5t4p1_templates_item_3, k5t4p1_templates_item_4, k5t4p1_templates_item_5, k5t4p1_templates_item_6, k5t4p1_templates_item_7, k5t4p1_templates_item_8, k5t4p1_templates_item_9, k5t4p1_templates_item_10⟩
+
+private theorem k5t4p1_part_4 : ∀ p ∈ k5t4p1.required, p.Check k5t4p1.graph 5 := by decide
+
+private theorem k5t4p1_part_5 : ClosureCheck k5t4p1.graph (k5t4p1.initialMatrix 5) 5 4 k5t4p1.closure := by
+  rw [k5t4p1_initial_eq]
+  exact k5t4p1_closure_0
+
+private theorem k5t4p1_part_6 : k5t4p1.bad.Check k5t4p1.graph (k5t4p1.matrix 5) 5 4 := by
+  rw [k5t4p1_matrix_eq]
+  decide
+
+theorem k5t4p1_check : k5t4p1.Check 5 4 [[], [], [1]] :=
+  ⟨k5t4p1_part_0, k5t4p1_part_1, k5t4p1_part_2, k5t4p1_part_3, k5t4p1_part_4, k5t4p1_part_5, k5t4p1_part_6⟩
+def k5t5p0 : LayoutCertificate 5 where
+  chains := [[0], [1], [2], [3], [4]]
+  clique := {0, 1, 2, 3, 4}
+  templates := [⟨0, 1, [], [], [], 1, 4⟩,
+    ⟨0, 2, [], [], [], 1, 4⟩,
+    ⟨0, 3, [], [], [], 1, 4⟩,
+    ⟨0, 4, [], [], [], 1, 4⟩,
+    ⟨1, 2, [], [], [], 1, 4⟩,
+    ⟨1, 3, [], [], [], 1, 4⟩,
+    ⟨1, 4, [], [], [], 1, 4⟩,
+    ⟨2, 3, [], [], [], 1, 4⟩,
+    ⟨2, 4, [], [], [], 1, 4⟩,
+    ⟨3, 4, [], [], [], 1, 4⟩]
+  required := []
+  closure := []
+  bad := ⟨none, {(0, 1), (1, 1), (2, 1), (3, 1), (4, 3)}⟩
+
+
+private def k5t5p0_state_0 : ForbiddenMatrix 5 :=
+  fun i j => ((#[#[∅, Finset.Icc 1 4, Finset.Icc 1 4, Finset.Icc 1 4, Finset.Icc 1 4],
+    #[Finset.Icc 1 4, ∅, Finset.Icc 1 4, Finset.Icc 1 4, Finset.Icc 1 4],
+    #[Finset.Icc 1 4, Finset.Icc 1 4, ∅, Finset.Icc 1 4, Finset.Icc 1 4],
+    #[Finset.Icc 1 4, Finset.Icc 1 4, Finset.Icc 1 4, ∅, Finset.Icc 1 4],
+    #[Finset.Icc 1 4, Finset.Icc 1 4, Finset.Icc 1 4, Finset.Icc 1 4, ∅]] : Array (Array (Finset ℕ))).getD i.val #[]).getD j.val ∅
+
+private theorem k5t5p0_initial_eq_row_0 : ∀ j : Fin 5, (k5t5p0.initialMatrix 5) 0 j = k5t5p0_state_0 0 j := by decide
+
+private theorem k5t5p0_initial_eq_row_1 : ∀ j : Fin 5, (k5t5p0.initialMatrix 5) 1 j = k5t5p0_state_0 1 j := by decide
+
+private theorem k5t5p0_initial_eq_row_2 : ∀ j : Fin 5, (k5t5p0.initialMatrix 5) 2 j = k5t5p0_state_0 2 j := by decide
+
+private theorem k5t5p0_initial_eq_row_3 : ∀ j : Fin 5, (k5t5p0.initialMatrix 5) 3 j = k5t5p0_state_0 3 j := by decide
+
+private theorem k5t5p0_initial_eq_row_4 : ∀ j : Fin 5, (k5t5p0.initialMatrix 5) 4 j = k5t5p0_state_0 4 j := by decide
+
+private theorem k5t5p0_initial_eq : (k5t5p0.initialMatrix 5) = k5t5p0_state_0 := by
+  funext i j
+  fin_cases i
+
+  · exact k5t5p0_initial_eq_row_0 j
+
+  · exact k5t5p0_initial_eq_row_1 j
+
+  · exact k5t5p0_initial_eq_row_2 j
+
+  · exact k5t5p0_initial_eq_row_3 j
+
+  · exact k5t5p0_initial_eq_row_4 j
+
+private theorem k5t5p0_closure_0 : ClosureCheck k5t5p0.graph k5t5p0_state_0 5 5 [] := by trivial
+
+private theorem k5t5p0_matrix_eq : k5t5p0.matrix 5 = k5t5p0_state_0 := by
+  change closureMatrix (k5t5p0.initialMatrix 5) _ = _
+  rw [k5t5p0_initial_eq]
+  change closureMatrix k5t5p0_state_0 [] = _
+  rfl
+
+private theorem k5t5p0_part_0 : k5t5p0.chains.flatten = List.finRange _ := by decide
+
+private theorem k5t5p0_part_1 : k5t5p0.chains.map List.length = ([[], [], [], [], []] : List (List ℕ)).map (fun w => w.sum + w.length + 1) := by decide
+
+private theorem k5t5p0_part_2 : k5t5p0.chains.map (fun l => l.map (fun i => decide (i ∈ k5t5p0.clique))) = ([[], [], [], [], []] : List (List ℕ)).map profileMask := by decide
+
+private theorem k5t5p0_templates_item_0 : (⟨0, 1, [], [], [], 1, 4⟩ : TemplateData (Fin 5)).Check k5t5p0.graph k5t5p0.clique 5 (patternAmount ([[], [], [], [], []] : List (List ℕ))) (([[], [], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t5p0_templates_item_1 : (⟨0, 2, [], [], [], 1, 4⟩ : TemplateData (Fin 5)).Check k5t5p0.graph k5t5p0.clique 5 (patternAmount ([[], [], [], [], []] : List (List ℕ))) (([[], [], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t5p0_templates_item_2 : (⟨0, 3, [], [], [], 1, 4⟩ : TemplateData (Fin 5)).Check k5t5p0.graph k5t5p0.clique 5 (patternAmount ([[], [], [], [], []] : List (List ℕ))) (([[], [], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t5p0_templates_item_3 : (⟨0, 4, [], [], [], 1, 4⟩ : TemplateData (Fin 5)).Check k5t5p0.graph k5t5p0.clique 5 (patternAmount ([[], [], [], [], []] : List (List ℕ))) (([[], [], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t5p0_templates_item_4 : (⟨1, 2, [], [], [], 1, 4⟩ : TemplateData (Fin 5)).Check k5t5p0.graph k5t5p0.clique 5 (patternAmount ([[], [], [], [], []] : List (List ℕ))) (([[], [], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t5p0_templates_item_5 : (⟨1, 3, [], [], [], 1, 4⟩ : TemplateData (Fin 5)).Check k5t5p0.graph k5t5p0.clique 5 (patternAmount ([[], [], [], [], []] : List (List ℕ))) (([[], [], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t5p0_templates_item_6 : (⟨1, 4, [], [], [], 1, 4⟩ : TemplateData (Fin 5)).Check k5t5p0.graph k5t5p0.clique 5 (patternAmount ([[], [], [], [], []] : List (List ℕ))) (([[], [], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t5p0_templates_item_7 : (⟨2, 3, [], [], [], 1, 4⟩ : TemplateData (Fin 5)).Check k5t5p0.graph k5t5p0.clique 5 (patternAmount ([[], [], [], [], []] : List (List ℕ))) (([[], [], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t5p0_templates_item_8 : (⟨2, 4, [], [], [], 1, 4⟩ : TemplateData (Fin 5)).Check k5t5p0.graph k5t5p0.clique 5 (patternAmount ([[], [], [], [], []] : List (List ℕ))) (([[], [], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t5p0_templates_item_9 : (⟨3, 4, [], [], [], 1, 4⟩ : TemplateData (Fin 5)).Check k5t5p0.graph k5t5p0.clique 5 (patternAmount ([[], [], [], [], []] : List (List ℕ))) (([[], [], [], [], []] : List (List ℕ)).map List.length).sum := by decide
+
+private theorem k5t5p0_part_3 : ∀ T ∈ k5t5p0.templates, T.Check k5t5p0.graph k5t5p0.clique 5 (patternAmount ([[], [], [], [], []] : List (List ℕ))) (([[], [], [], [], []] : List (List ℕ)).map List.length).sum := by
+  simp only [k5t5p0, List.forall_mem_cons, List.not_mem_nil, IsEmpty.forall_iff, implies_true, and_true]
+  exact ⟨k5t5p0_templates_item_0, k5t5p0_templates_item_1, k5t5p0_templates_item_2, k5t5p0_templates_item_3, k5t5p0_templates_item_4, k5t5p0_templates_item_5, k5t5p0_templates_item_6, k5t5p0_templates_item_7, k5t5p0_templates_item_8, k5t5p0_templates_item_9⟩
+
+private theorem k5t5p0_part_4 : ∀ p ∈ k5t5p0.required, p.Check k5t5p0.graph 5 := by decide
+
+private theorem k5t5p0_part_5 : ClosureCheck k5t5p0.graph (k5t5p0.initialMatrix 5) 5 5 k5t5p0.closure := by
+  rw [k5t5p0_initial_eq]
+  exact k5t5p0_closure_0
+
+private theorem k5t5p0_part_6 : k5t5p0.bad.Check k5t5p0.graph (k5t5p0.matrix 5) 5 5 := by
+  rw [k5t5p0_matrix_eq]
+  decide
+
+theorem k5t5p0_check : k5t5p0.Check 5 5 [[], [], [], [], []] :=
+  ⟨k5t5p0_part_0, k5t5p0_part_1, k5t5p0_part_2, k5t5p0_part_3, k5t5p0_part_4, k5t5p0_part_5, k5t5p0_part_6⟩
+end CycleClique.Construction.Certificates
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/CertifiedRamseyReduction.lean

@@ -0,0 +1,58 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CertificateCoverage
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CanonicalRawCoverage
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.FiniteRangeReduction
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.RamseyMainReduction
+
+namespace OAI
+
+/-! Mathematical assembly for a fixed cycle parameter, once its concrete
+finite certificate coverage has been proved. -/
+
+namespace CycleClique.Construction
+open scoped Classical
+
+def CertificateCoverageAt (k : ℕ) : Prop :=
+  ∀ t, 3 ≤ t → t ≤ k → t ≤ 8 → k / 2 ≤ t →
+    ∀ P ∈ pathPatterns t (k - t), HasCheckedCertificate k t P
+
+theorem no_expanded_counterexample_of_coverage (hCE : CEAlphaTwo) {k : ℕ}
+    (hcoverage : CertificateCoverageAt k)
+    {V : Type} [Fintype V] {G : SimpleGraph V} {a : ℕ}
+    (hk : 5 ≤ k) (ha : 2 ≤ a) (hak : a ≤ k)
+    (hcard : Fintype.card V = k * a + 1) (hI : IndependenceBound G a)
+    (hcycle : ¬ HasCycle G (k + 1))
+    (hexpand : ∀ I : Finset V, G.IsIndepSet (I : Set V) → I.Nonempty →
+      k * I.card + 1 ≤ (closedNeighborhood G I).card) : False := by
+  classical
+  obtain ⟨_, hω3, hωhi, hhalf⟩ :=
+    finite_range_clique_bounds hCE hk ha hak hcard hI hcycle hexpand
+  obtain ⟨Q, hQ⟩ := G.exists_isNClique_cliqueNum
+  have hQcard := hQ.card_eq
+  have hQk : Q.card ≤ k := by omega
+  obtain ⟨S, hopt⟩ := ExpandedPathSystem.exists_optimal G Q k
+  obtain ⟨P, U, hP, hUv, hUa, hUe, hp, hne⟩ := hopt.exists_canonical_raw
+  obtain ⟨n, c, hc⟩ := hcoverage Q.card (by omega) hQk (by omega) (by omega) P hP
+  exact c.false_of_check hCE hk (by omega) hQk hQ.isClique hcycle (by omega)
+    (fun I hi => (hI I hi).trans hak) hexpand hopt U hUv hUa hUe hp hne hc
+
+theorem cycle_clique_upper_of_coverage (hCE : CEAlphaTwo) {k a : ℕ}
+    (hk : 5 ≤ k) (ha : 2 ≤ a) (hak : a ≤ k) (hcoverage : CertificateCoverageAt k) :
+    RamseyProperty (k + 1) (a + 1) (k * a + 1) := by
+  apply ramseyProperty_of_expanded_exclusion (by omega) ha hak
+  intro b hb hbk G hcycle hI hexpand
+  exact no_expanded_counterexample_of_coverage hCE hcoverage hk hb hbk (by simp) hI hcycle hexpand
+
+theorem isRamseyNumber_of_certificate_coverage (hCE : CEAlphaTwo) {m n : ℕ}
+    (hm : 6 ≤ m) (hn : 3 ≤ n) (hnm : n ≤ m)
+    (hcoverage : CertificateCoverageAt (m - 1)) :
+    IsRamseyNumber m n ((m - 1) * (n - 1) + 1) := by
+  have hm' : m - 1 + 1 = m := by omega
+  have hn' : n - 1 + 1 = n := by omega
+  apply isRamseyNumber_of_upper_lower
+  · simpa only [hm', hn'] using cycle_clique_upper_of_coverage hCE
+      (k := m - 1) (a := n - 1) (by omega) (by omega) (by omega) hcoverage
+  · exact blockGraph_not_ramsey (by omega) (by omega)
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/ChainCounts.lean

@@ -0,0 +1,149 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.NormalizeChains
+
+namespace OAI
+
+/-! Count assigned paths before and after deleting singleton chain pieces. -/
+
+namespace CycleClique.Construction
+variable {V : Type*} {G : SimpleGraph V} {Q : Finset V}
+
+noncomputable def chainCliqueCount (Q : Finset V) (l : List V) : ℕ := by
+  classical
+  exact (l.filter (fun v => decide (v ∈ Q))).length
+
+noncomputable def rawAssignedCount (Q : Finset V) (C : List (List V)) : ℕ :=
+  (C.map (fun l => chainCliqueCount Q l - 1)).sum
+
+@[simp] theorem chainCliqueCount_append (A B : List V) :
+    chainCliqueCount Q (A ++ B) = chainCliqueCount Q A + chainCliqueCount Q B := by
+  classical
+  simp [chainCliqueCount, List.filter_append]
+
+@[simp] theorem chainCliqueCount_reverse (A : List V) :
+    chainCliqueCount Q A.reverse = chainCliqueCount Q A := by
+  classical
+  simp [chainCliqueCount, List.filter_reverse]
+
+theorem chainCliqueCount_eq_zero {J : List V} (hJ : ∀ z ∈ J, z ∉ Q) :
+    chainCliqueCount Q J = 0 := by
+  classical
+  simp only [chainCliqueCount, List.length_eq_zero_iff, List.filter_eq_nil_iff]
+  intro z hz
+  simpa using hJ z hz
+
+@[simp] theorem rawAssignedCount_append (A B : List (List V)) :
+    rawAssignedCount Q (A ++ B) = rawAssignedCount Q A + rawAssignedCount Q B := by
+  simp [rawAssignedCount]
+
+theorem chainCliqueCount_pos {l : List V} (hne : l ≠ [])
+    (hhead : ∀ v ∈ l.head?, v ∈ Q) : 1 ≤ chainCliqueCount Q l := by
+  classical
+  have hm : l.head hne ∈ l.filter (fun v => decide (v ∈ Q)) := by
+    apply List.mem_filter.mpr
+    exact ⟨List.head_mem hne, by simpa using hhead _ (List.head?_eq_some_head hne)⟩
+  exact List.length_pos_iff.mpr (List.ne_nil_of_mem hm)
+
+theorem chainCliqueCount_pos_last {l : List V} (hne : l ≠ [])
+    (hlast : ∀ v ∈ l.getLast?, v ∈ Q) : 1 ≤ chainCliqueCount Q l := by
+  rw [← chainCliqueCount_reverse]
+  exact chainCliqueCount_pos (by simpa using hne) (by simpa using hlast)
+
+theorem chainCliqueCount_flatten (C : List (List V)) :
+    chainCliqueCount Q C.flatten = (C.map (chainCliqueCount Q)).sum := by
+  classical
+  simp only [chainCliqueCount, List.filter_flatten, List.length_flatten, List.map_map,
+    Function.comp_def]
+  rfl
+
+theorem rawAssignedCount_add_length (C : List (List V))
+    (hpos : ∀ l ∈ C, 1 ≤ chainCliqueCount Q l) :
+    rawAssignedCount Q C + C.length = chainCliqueCount Q C.flatten := by
+  rw [chainCliqueCount_flatten]
+  induction C with
+  | nil => simp [rawAssignedCount]
+  | cons l C ih =>
+    have hl := hpos l (by simp)
+    have hi := ih (fun l hl => hpos l (by simp [hl]))
+    simp only [rawAssignedCount, List.map_cons, List.sum_cons, List.length_cons] at hi ⊢
+    omega
+
+theorem ExpandedPathSystem.incident_eq_chainCliqueCount (S : ExpandedPathSystem G Q) :
+    S.incident = chainCliqueCount Q S.chains.flatten := by
+  classical
+  have heq : S.vertices ∩ Q =
+      (S.chains.flatten.filter (fun v => decide (v ∈ Q))).toFinset := by
+    ext v
+    simp [ExpandedPathSystem.vertices]
+    aesop
+  unfold incident
+  rw [heq, List.toFinset_card_of_nodup (S.flatten_nodup.filter _)]
+  rfl
+
+theorem ExpandedPathSystem.assignedCount_eq_raw (S : ExpandedPathSystem G Q) :
+    S.assignedCount = rawAssignedCount Q S.chains := by
+  have hpos : ∀ l ∈ S.chains, 1 ≤ chainCliqueCount Q l := by
+    intro l hl
+    apply chainCliqueCount_pos
+    · intro heq
+      have hh := S.nontrivial l hl
+      simp [heq] at hh
+    · exact (S.endpoints l hl).1
+  have h := rawAssignedCount_add_length S.chains hpos
+  rw [← S.incident_eq_chainCliqueCount] at h
+  unfold assignedCount
+  omega
+
+theorem short_chainCliqueCount {l : List V} (hne : l ≠ [])
+    (hends : (∀ v ∈ l.head?, v ∈ Q) ∧ (∀ v ∈ l.getLast?, v ∈ Q))
+    (hsteps : l.IsChain (fun x y => ¬ (x ∈ Q ∧ y ∈ Q)))
+    (hlen : l.length < 3) : chainCliqueCount Q l = 1 := by
+  classical
+  cases l with
+  | nil => exact False.elim (hne rfl)
+  | cons x l =>
+    cases l with
+    | nil =>
+      have hx := hends.1 x (by simp)
+      simp [chainCliqueCount, hx]
+    | cons y l =>
+      have hy := short_chain_in_clique hends hsteps hlen
+      have hxQ := hy x (by simp)
+      have hyQ := hy y (by simp)
+      exact False.elim ((List.isChain_cons_cons.mp hsteps).1 ⟨hxQ, hyQ⟩)
+
+theorem short_chainCliqueCount_le {l : List V}
+    (hends : (∀ v ∈ l.head?, v ∈ Q) ∧ (∀ v ∈ l.getLast?, v ∈ Q))
+    (hsteps : l.IsChain (fun x y => ¬ (x ∈ Q ∧ y ∈ Q)))
+    (hlen : l.length < 3) : chainCliqueCount Q l ≤ 1 := by
+  by_cases he : l = []
+  · subst l
+    simp [chainCliqueCount]
+  · rw [short_chainCliqueCount he hends hsteps hlen]
+
+theorem normalizeChains_assignedCount (C : List (List V))
+    (hpaths : ∀ l ∈ C, l.Nodup ∧ l.IsChain G.Adj)
+    (hdis : C.Pairwise List.Disjoint)
+    (hends : ∀ l ∈ C, (∀ v ∈ l.head?, v ∈ Q) ∧ (∀ v ∈ l.getLast?, v ∈ Q))
+    (hsteps : ∀ l ∈ C, l.IsChain (fun x y => ¬ (x ∈ Q ∧ y ∈ Q))) :
+    (normalizeChains C hpaths hdis hends hsteps).assignedCount = rawAssignedCount Q C := by
+  classical
+  rw [ExpandedPathSystem.assignedCount_eq_raw]
+  change rawAssignedCount Q (C.filter (fun l => decide (3 ≤ l.length))) = _
+  induction C with
+  | nil => simp [rawAssignedCount]
+  | cons l C ih =>
+    have ht := ih (fun l hl => hpaths l (by simp [hl]))
+      (List.pairwise_cons.mp hdis).2
+      (fun l hl => hends l (by simp [hl]))
+      (fun l hl => hsteps l (by simp [hl]))
+    by_cases hl : 3 ≤ l.length
+    · simpa [List.filter_cons, hl, rawAssignedCount] using
+        congrArg (fun n => chainCliqueCount Q l - 1 + n) ht
+    · have hc := short_chainCliqueCount_le
+        (hends l (by simp)) (hsteps l (by simp)) (by omega)
+      have hz : chainCliqueCount Q l - 1 = 0 := by omega
+      simpa [List.filter_cons, hl, rawAssignedCount, hz] using ht
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/CliqueThree.lean

@@ -0,0 +1,35 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.Size
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.LargeClique
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.LowerBound
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.Monotonicity
+
+namespace OAI
+
+/-! The `n=3`, `m≥6` part of the formula, conditional on the same precise
+published Hamiltonicity input as the size test. -/
+
+namespace CycleClique.Construction
+theorem cycle_clique_three_upper (hCE : CEAlphaTwo) {k : ℕ} (hk : 5 ≤ k) :
+    RamseyProperty (k + 1) 3 (2 * k + 1) := by
+  intro G
+  by_cases hc : HasCycle G (k + 1)
+  · exact Or.inl hc
+  · apply Or.inr
+    apply size_test_graph hCE hk (show 1 ≤ k by omega) hc
+      (cliqueNum_le_of_no_cycle (by omega) hc)
+    simp only [Fintype.card_fin]
+    omega
+
+theorem cycle_clique_three_ge_six (hCE : CEAlphaTwo) {m : ℕ} (hm : 6 ≤ m) :
+    IsRamseyNumber m 3 ((m - 1) * 2 + 1) := by
+  have hk : 5 ≤ m - 1 := by omega
+  have hm' : m - 1 + 1 = m := by omega
+  apply isRamseyNumber_of_upper_lower
+  · simpa only [hm', Nat.mul_comm] using cycle_clique_three_upper hCE hk
+  · simpa only [hm', Nat.mul_comm] using
+      (blockGraph_not_ramsey (a := 2) (k := m - 1) (m := m) (n := 3)
+        (by omega) (by omega))
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/CliqueTraversal.lean

@@ -0,0 +1,87 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.LongestPaths
+import Mathlib.Data.List.ChainOfFn
+import Mathlib.Data.List.FinRange
+
+namespace OAI
+
+/-! Simple paths through all clique vertices with prescribed distinct ends. -/
+
+namespace CycleClique.Construction
+theorem indexedPath_ofFn_chain {V : Type*} {G : SimpleGraph V} {r : ℕ}
+    {f : Fin (r + 1) → V} (hf : IsIndexedPath G f) :
+    (List.ofFn f).Nodup ∧ (List.ofFn f).IsChain G.Adj := by
+  refine ⟨List.nodup_ofFn.mpr hf.1, List.isChain_ofFn.mpr ?_⟩
+  intro i hi
+  exact hf.2 ⟨i, by omega⟩
+
+theorem indexedPath_of_list {V : Type*} {G : SimpleGraph V} {r : ℕ}
+    (L : List V) (hL : L.Nodup) (hchain : L.IsChain G.Adj) (hlen : L.length = r + 1) :
+    IsIndexedPath G (fun i : Fin (r + 1) => L.get (Fin.cast hlen.symm i)) := by
+  refine ⟨hL.injective_get.comp (Fin.cast_injective _), ?_⟩
+  intro i
+  exact (List.isChain_iff_getElem.mp hchain) i.val (by have := i.isLt; omega)
+
+private theorem chain_of_pairwise {V : Type*} {R : V → V → Prop} {L : List V}
+    (h : L.Pairwise R) : L.IsChain R := by
+  induction h with
+  | nil => exact .nil
+  | @cons a l hrel _ ih =>
+    exact ih.cons (fun b hb => hrel b (List.mem_of_mem_head? hb))
+
+theorem chain_of_clique_nodup {V : Type*} {G : SimpleGraph V} {E : Finset V}
+    (hclique : G.IsClique (E : Set V)) {L : List V} (hL : L.Nodup)
+    (hmem : ∀ v ∈ L, v ∈ E) : L.IsChain G.Adj := by
+  apply chain_of_pairwise
+  exact hL.pairwise_of_forall_ne
+    (fun a ha b hb hab => hclique (hmem a ha) (hmem b hb) hab)
+
+theorem exists_clique_traversal {V : Type*} [DecidableEq V]
+    {G : SimpleGraph V} {E : Finset V} (hclique : G.IsClique (E : Set V))
+    {a b : V} (ha : a ∈ E) (hb : b ∈ E) (hab : a ≠ b) :
+    ∃ L : List V, L.Nodup ∧ L.IsChain G.Adj ∧ L.length = E.card ∧
+      L.head? = some a ∧ L.getLast? = some b ∧ ∀ v ∈ L, v ∈ E := by
+  classical
+  let M := ((E.erase a).erase b).toList
+  let L := a :: (M ++ [b])
+  have hM : ∀ v ∈ M, v ∈ E ∧ v ≠ a ∧ v ≠ b := by
+    intro v hv
+    have hm : v ∈ (E.erase a).erase b := by simpa [M] using hv
+    exact ⟨Finset.mem_of_mem_erase (Finset.mem_of_mem_erase hm),
+      (Finset.mem_erase.mp (Finset.mem_of_mem_erase hm)).1,
+      (Finset.mem_erase.mp hm).1⟩
+  have hL : L.Nodup := by
+    apply List.nodup_cons.mpr
+    constructor
+    · intro h
+      rcases List.mem_append.mp h with h | h
+      · exact (hM a h).2.1 rfl
+      · have heq : a = b := by simpa using h
+        exact hab heq
+    · apply List.nodup_append.mpr
+      refine ⟨Finset.nodup_toList _, by simp, ?_⟩
+      intro v hv b' hb' heq
+      have hb'eq : b' = b := by simpa using hb'
+      exact (hM v hv).2.2 (heq.trans hb'eq)
+  have hmem : ∀ v ∈ L, v ∈ E := by
+    intro v hv
+    rcases List.mem_cons.mp hv with rfl | hv
+    · exact ha
+    · rcases List.mem_append.mp hv with hv | hv
+      · exact (hM v hv).1
+      · have heq : v = b := by simpa using hv
+        exact heq ▸ hb
+  have hlen : L.length = E.card := by
+    have hea := Finset.card_erase_add_one ha
+    have hba : b ∈ E.erase a := Finset.mem_erase.mpr ⟨hab.symm, hb⟩
+    have heb := Finset.card_erase_add_one hba
+    dsimp [L, M]
+    simp only [List.length_cons, List.length_append, Finset.length_toList, List.length_nil]
+    omega
+  exact ⟨L, hL, chain_of_clique_nodup hclique hL hmem, hlen, rfl,
+    by
+      change ((a :: M) ++ [b]).getLast? = some b
+      exact List.getLast?_append_cons (a :: M) b [], hmem⟩
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/ClosedIndexed.lean

@@ -0,0 +1,67 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.ColouredPathStart
+import Mathlib.Algebra.Group.Fin.Basic
+
+namespace OAI
+
+/-! An indexed path whose endpoints are adjacent can be started at any of its vertices. -/
+
+namespace CycleClique.Construction
+theorem cycleNext_eq_add_one {r : ℕ} (i : Fin (r + 1)) : cycleNext i = i + 1 := by
+  cases r with
+  | zero =>
+    apply Fin.ext
+    have h₁ := (cycleNext i).isLt
+    have h₂ := (i + 1).isLt
+    omega
+  | succ r => apply Fin.ext; rfl
+
+theorem indexedPath_closed_cycle {V : Type*} {G : SimpleGraph V} {r : ℕ}
+    {f : Fin (r + 1) → V} (hf : IsIndexedPath G f)
+    (hclose : G.Adj (f (Fin.last r)) (f 0)) :
+    ∀ i, G.Adj (f i) (f (cycleNext i)) := by
+  intro i
+  by_cases hi : i.val = r
+  · have heq : i = Fin.last r := Fin.ext hi
+    have hn : cycleNext i = 0 := by
+      apply Fin.ext
+      simp only [cycleNext, hi, Nat.mod_self, Fin.val_zero]
+    rw [hn, heq]
+    exact hclose
+  · let j : Fin r := ⟨i.val, by have := i.isLt; omega⟩
+    have hleft : j.castSucc = i := Fin.ext rfl
+    have hright : j.succ = cycleNext i := by
+      apply Fin.ext
+      exact (Nat.mod_eq_of_lt (by have := i.isLt; omega)).symm
+    simpa only [hleft, hright] using hf.2 j
+
+theorem indexedPath_closed_ending {V : Type*} {G : SimpleGraph V} {r : ℕ}
+    {f : Fin (r + 1) → V} (hf : IsIndexedPath G f)
+    (hclose : G.Adj (f (Fin.last r)) (f 0)) (j : Fin (r + 1)) :
+    ∃ g : Fin (r + 1) → V, IsIndexedPath G g ∧
+      g (Fin.last r) = f j ∧ Set.range g = Set.range f := by
+  let c := j - Fin.last r
+  let g : Fin (r + 1) → V := fun i => f (i + c)
+  have hadd : ∀ i : Fin r, i.succ = i.castSucc + (1 : Fin (r + 1)) := by
+    intro i
+    apply Fin.ext
+    rw [Fin.val_add_one_of_lt (show i.castSucc < Fin.last r from i.isLt)]
+    rfl
+  have hg : IsIndexedPath G g := by
+    refine ⟨hf.1.comp (fun a b h => add_right_cancel h), ?_⟩
+    intro i
+    have h := indexedPath_closed_cycle hf hclose (i.castSucc + c)
+    simpa only [g, cycleNext_eq_add_one, hadd, add_assoc, add_comm 1 c] using h
+  refine ⟨g, hg, ?_, ?_⟩
+  · change f (Fin.last r + (j - Fin.last r)) = f j
+    congr 1
+    abel
+  · ext v
+    constructor
+    · rintro ⟨i, rfl⟩
+      exact ⟨i + c, rfl⟩
+    · rintro ⟨i, rfl⟩
+      exact ⟨i - c, by simp [g]⟩
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/ClosureCertificates.lean

@@ -0,0 +1,90 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.FiniteAttachments
+
+namespace OAI
+
+/-! Soundness of the checker's hypothetical zero/one attachment rules.
+Each local contradiction is witnessed by explicit required paths and a
+checked bad state; inherited constraints refer only to earlier states. -/
+
+namespace CycleClique.Construction
+structure EdgeAttachmentData (n : ℕ) where
+  i : Fin n
+  j : Fin n
+  required : List (RequiredPathData (Fin n))
+  bad : BadData n
+  deriving DecidableEq
+
+structure FreshAttachmentData (n : ℕ) where
+  i : Fin n
+  j : Fin n
+  required : List (RequiredPathData (Fin (n + 1)))
+  bad : BadData (n + 1)
+  deriving DecidableEq
+
+variable {n : ℕ}
+
+def EdgeAttachmentData.Check (H : SimpleGraph (Fin n)) (M : ForbiddenMatrix n)
+    (k t : ℕ) (c : EdgeAttachmentData n) : Prop :=
+  (∀ p ∈ c.required, p.Check (addedEdgeGraph H c.i c.j) k) ∧
+    c.bad.Check (addedEdgeGraph H c.i c.j)
+      (fun a b => M a b ∪ requiredMatrix k c.required a b) k t
+
+def FreshAttachmentData.Check (H : SimpleGraph (Fin n)) (M : ForbiddenMatrix n)
+    (k t : ℕ) (c : FreshAttachmentData n) : Prop :=
+  c.i ≠ c.j ∧ (∀ p ∈ c.required, p.Check (freshGraph H c.i c.j) k) ∧
+    c.bad.Check (freshGraph H c.i c.j)
+      (fun a b => freshMatrix M a b ∪ requiredMatrix k c.required a b) k t
+
+instance (H : SimpleGraph (Fin n)) [DecidableRel H.Adj] (M : ForbiddenMatrix n)
+    (k t : ℕ) (c : EdgeAttachmentData n) : Decidable (c.Check H M k t) :=
+  inferInstanceAs (Decidable (_ ∧ _))
+
+instance (H : SimpleGraph (Fin n)) [DecidableRel H.Adj] (M : ForbiddenMatrix n)
+    (k t : ℕ) (c : FreshAttachmentData n) : Decidable (c.Check H M k t) :=
+  inferInstanceAs (Decidable (_ ∧ _))
+
+variable {V : Type} [Fintype V] {G : SimpleGraph V} {H : SimpleGraph (Fin n)}
+
+theorem EdgeAttachmentData.forbids (hCE : CEAlphaTwo) {k t : ℕ}
+    (hk : 5 ≤ k) (ht : 1 ≤ t) (hcycle : ¬ HasCycle G (k + 1))
+    (hclique : G.cliqueNum ≤ t) (hbound : IndependenceBound G k)
+    (f : H →g G) (hf : Function.Injective f) {X : Finset V}
+    (hfX : ∀ i, f i ∈ X) (hX : X.card = n)
+    {M : ForbiddenMatrix n} (hM : M.Sound G X f)
+    (hexpand : ∀ I : Finset V, G.IsIndepSet (I : Set V) → I.Nonempty →
+      k * I.card + 1 ≤ (closedNeighborhood G I).card)
+    (c : EdgeAttachmentData n) (hc : c.Check H M k t) :
+    ¬ OutsidePath G (X : Set V) (f c.i) (f c.j) 0 := by
+  intro h
+  let F := addedEdgeHom f (outsidePath_zero.mp h)
+  have hR := requiredMatrix_sound (by omega) hcycle F hf hfX c.required hc.1
+  exact c.bad.false_of_check hCE hk ht hcycle hclique hbound F hf hfX hX
+    (hM.union hR) hexpand hc.2
+
+theorem FreshAttachmentData.forbids (hCE : CEAlphaTwo) {k t : ℕ}
+    (hk : 5 ≤ k) (ht : 1 ≤ t) (hcycle : ¬ HasCycle G (k + 1))
+    (hclique : G.cliqueNum ≤ t) (hbound : IndependenceBound G k)
+    (f : H →g G) (hf : Function.Injective f) {X : Finset V}
+    (hfX : ∀ i, f i ∈ X) (hX : X.card = n)
+    {M : ForbiddenMatrix n} (hM : M.Sound G X f)
+    (hexpand : ∀ I : Finset V, G.IsIndepSet (I : Set V) → I.Nonempty →
+      k * I.card + 1 ≤ (closedNeighborhood G I).card)
+    (c : FreshAttachmentData n) (hc : c.Check H M k t) :
+    ¬ OutsidePath G (X : Set V) (f c.i) (f c.j) 1 := by
+  classical
+  intro h
+  obtain ⟨z, hz, hiz, hjz⟩ := (outsidePath_one_iff_common_neighbor
+    (fun he => hc.1 (hf he))).mp h
+  have hjz' := hjz.symm
+  let F := freshHom f z hiz hjz'
+  have hF := freshHom_injective f hf hfX hz hiz hjz'
+  have hFX := freshHom_mem f hfX hiz hjz'
+  have hX' : (insert z X).card = n + 1 := by rw [Finset.card_insert_of_notMem hz, hX]
+  have hM' := freshMatrix_sound f hM hiz hjz'
+  have hR := requiredMatrix_sound (by omega) hcycle F hF hFX c.required hc.2.1
+  exact c.bad.false_of_check hCE hk ht hcycle hclique hbound F hF hFX hX'
+    (hM'.union hR) hexpand hc.2.2
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/ClosureSteps.lean

@@ -0,0 +1,110 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.ClosureCertificates
+
+namespace OAI
+
+/-! A finite sequence of locally checked hypothetical attachments builds
+only sound forbidden entries. Every step reads the preceding matrix. -/
+
+namespace CycleClique.Construction
+inductive ClosureStep (n : ℕ)
+  | edge : EdgeAttachmentData n → ClosureStep n
+  | fresh : FreshAttachmentData n → ClosureStep n
+  deriving DecidableEq
+
+namespace ClosureStep
+
+variable {n : ℕ}
+
+def source : ClosureStep n → Fin n
+  | .edge c => c.i
+  | .fresh c => c.i
+
+def target : ClosureStep n → Fin n
+  | .edge c => c.j
+  | .fresh c => c.j
+
+def parameter : ClosureStep n → ℕ
+  | .edge _ => 0
+  | .fresh _ => 1
+
+def Check (H : SimpleGraph (Fin n)) (M : ForbiddenMatrix n) (k t : ℕ) : ClosureStep n → Prop
+  | .edge c => c.Check H M k t
+  | .fresh c => c.Check H M k t
+
+instance (H : SimpleGraph (Fin n)) [DecidableRel H.Adj] (M : ForbiddenMatrix n)
+    (k t : ℕ) (c : ClosureStep n) : Decidable (c.Check H M k t) := by
+  cases c <;> dsimp only [Check] <;> infer_instance
+
+def entryMatrix (c : ClosureStep n) : ForbiddenMatrix n := fun i j =>
+  if (i = c.source ∧ j = c.target) ∨ (i = c.target ∧ j = c.source)
+    then {c.parameter} else ∅
+
+def apply (c : ClosureStep n) (M : ForbiddenMatrix n) : ForbiddenMatrix n :=
+  fun i j => M i j ∪ c.entryMatrix i j
+
+end ClosureStep
+
+variable {n : ℕ}
+
+def closureMatrix (M : ForbiddenMatrix n) : List (ClosureStep n) → ForbiddenMatrix n
+  | [] => M
+  | c :: C => closureMatrix (c.apply M) C
+
+def ClosureCheck (H : SimpleGraph (Fin n)) (M : ForbiddenMatrix n) (k t : ℕ) :
+    List (ClosureStep n) → Prop
+  | [] => True
+  | c :: C => c.Check H M k t ∧ ClosureCheck H (c.apply M) k t C
+
+instance (H : SimpleGraph (Fin n)) [DecidableRel H.Adj] (M : ForbiddenMatrix n)
+    (k t : ℕ) (C : List (ClosureStep n)) : Decidable (ClosureCheck H M k t C) := by
+  induction C generalizing M with
+  | nil => exact isTrue trivial
+  | cons c C ih =>
+    letI := ih (c.apply M)
+    exact inferInstanceAs (Decidable (_ ∧ _))
+
+variable {V : Type} [Fintype V] {G : SimpleGraph V} {H : SimpleGraph (Fin n)}
+
+theorem ClosureStep.apply_sound (hCE : CEAlphaTwo) {k t : ℕ}
+    (hk : 5 ≤ k) (ht : 1 ≤ t) (hcycle : ¬ HasCycle G (k + 1))
+    (hclique : G.cliqueNum ≤ t) (hbound : IndependenceBound G k)
+    (f : H →g G) (hf : Function.Injective f) {X : Finset V}
+    (hfX : ∀ i, f i ∈ X) (hX : X.card = n)
+    {M : ForbiddenMatrix n} (hM : M.Sound G X f)
+    (hexpand : ∀ I : Finset V, G.IsIndepSet (I : Set V) → I.Nonempty →
+      k * I.card + 1 ≤ (closedNeighborhood G I).card)
+    (c : ClosureStep n) (hc : c.Check H M k t) : (c.apply M).Sound G X f := by
+  have hb : ¬ OutsidePath G (X : Set V) (f c.source) (f c.target) c.parameter := by
+    cases c with
+    | edge c => exact c.forbids hCE hk ht hcycle hclique hbound f hf hfX hX hM hexpand hc
+    | fresh c => exact c.forbids hCE hk ht hcycle hclique hbound f hf hfX hX hM hexpand hc
+  apply hM.union
+  intro i j d hd
+  have hpair : (i = c.source ∧ j = c.target) ∨ (i = c.target ∧ j = c.source) := by
+    by_contra hn
+    simp only [ClosureStep.entryMatrix, hn, ↓reduceIte, Finset.notMem_empty] at hd
+  have heq : d = c.parameter := by
+    simpa only [ClosureStep.entryMatrix, hpair, ↓reduceIte, Finset.mem_singleton] using hd
+  subst d
+  rcases hpair with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩
+  · exact hb
+  · exact fun h => hb h.reverse
+
+theorem closureMatrix_sound (hCE : CEAlphaTwo) {k t : ℕ}
+    (hk : 5 ≤ k) (ht : 1 ≤ t) (hcycle : ¬ HasCycle G (k + 1))
+    (hclique : G.cliqueNum ≤ t) (hbound : IndependenceBound G k)
+    (f : H →g G) (hf : Function.Injective f) {X : Finset V}
+    (hfX : ∀ i, f i ∈ X) (hX : X.card = n)
+    {M : ForbiddenMatrix n} (hM : M.Sound G X f)
+    (hexpand : ∀ I : Finset V, G.IsIndepSet (I : Set V) → I.Nonempty →
+      k * I.card + 1 ≤ (closedNeighborhood G I).card)
+    (C : List (ClosureStep n)) (hC : ClosureCheck H M k t C) :
+    (closureMatrix M C).Sound G X f := by
+  induction C generalizing M with
+  | nil => exact hM
+  | cons c C ih =>
+    exact ih (c.apply_sound hCE hk ht hcycle hclique hbound f hf hfX hX hM hexpand hC.1) hC.2
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/ColouredPath.lean

@@ -0,0 +1,49 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.PathRotation
+import Mathlib.Combinatorics.SimpleGraph.Bipartite
+import Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected
+
+namespace OAI
+
+/-!
+# Starting the coloured-path argument
+
+The first step of manuscript Lemma `clq:coloured-path` is proved by
+walk induction: preservation of colour across two steps, together with
+one monochromatic edge, makes the colour constant on its component.
+-/
+
+namespace CycleClique.Construction
+private theorem color_eq_of_walk {V : Type*} {G : SimpleGraph V} (χ : V → Fin 2)
+    (htwo : ∀ {u x v}, G.Adj u x → G.Adj x v → χ u = χ v)
+    {u v w : V} (p : G.Walk v w) (huv : G.Adj u v) (heq : χ u = χ v) : χ w = χ v := by
+  induction p generalizing u with
+  | nil => rfl
+  | @cons v z w hvz p ih =>
+    have hχ : χ v = χ z := heq.symm.trans (htwo huv hvz)
+    exact (ih hvz hχ).trans hχ.symm
+
+/-- In a connected nonbipartite graph, any nonconstant two-colouring
+has differently coloured vertices sharing a neighbour. -/
+theorem differently_colored_common_neighbors {V : Type*} {G : SimpleGraph V}
+    (hconnected : G.Connected) (hnonbipartite : ¬ G.IsBipartite)
+    (χ : V → Fin 2) (hnonconstant : ∃ u v, χ u ≠ χ v) :
+    ∃ x y z, G.Adj x y ∧ G.Adj x z ∧ χ y ≠ χ z := by
+  classical
+  by_contra hnone
+  have htwo : ∀ {u x v}, G.Adj u x → G.Adj x v → χ u = χ v := by
+    intro u x v hux hxv
+    by_contra hχ
+    exact hnone ⟨x, u, v, hux.symm, hxv, hχ⟩
+  have hproper : ∀ {u v}, G.Adj u v → χ u ≠ χ v := by
+    intro u v huv heq
+    have hconstant : ∀ w, χ w = χ v := by
+      intro w
+      obtain ⟨p⟩ := hconnected v w
+      exact color_eq_of_walk χ htwo p huv heq
+    obtain ⟨a, b, hab⟩ := hnonconstant
+    exact hab ((hconstant a).trans (hconstant b).symm)
+  exact hnonbipartite ⟨SimpleGraph.Coloring.mk χ hproper⟩
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/ColouredPathFull.lean

@@ -0,0 +1,160 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.EndpointStructure
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.DeletionOrder
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.AttachmentResidual
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.ResidualPaths
+
+namespace OAI
+
+/-! The full prescribed-length coloured-path lemma of manuscript Section 3. -/
+
+namespace CycleClique.Construction
+private noncomputable def indexedSupport {V : Type*} {r : ℕ}
+    (f : Fin (r + 1) → V) : Finset V := by
+  classical
+  exact Finset.univ.image f
+
+private theorem mem_indexedSupport {V : Type*} {r : ℕ} {f : Fin (r + 1) → V} {v : V} :
+    v ∈ indexedSupport f ↔ ∃ i, f i = v := by
+  classical
+  simp [indexedSupport]
+
+private theorem indexedSupport_range {V : Type*} {r : ℕ} (f : Fin (r + 1) → V) :
+    Set.range f = (indexedSupport f : Set V) := by
+  ext v
+  exact mem_indexedSupport.symm
+
+private theorem indexedSupport_card {V : Type*} {r : ℕ} {f : Fin (r + 1) → V}
+    (hf : Function.Injective f) : (indexedSupport f).card = r + 1 := by
+  classical
+  rw [indexedSupport, Finset.card_image_of_injective _ hf, Finset.card_univ, Fintype.card_fin]
+
+/-- Prescribed-length paths with differently coloured endpoints. -/
+theorem colored_path_prescribed_length {V : Type*} [Fintype V] [DecidableEq V]
+    {H : SimpleGraph V} {s : ℕ} (hs : 4 ≤ s)
+    (hconn : H.Connected) (hnonbip : ¬ H.IsBipartite) (hno : H.cliqueNum < s)
+    (hdegree : ∀ v, s ≤ (H.neighborSet v).ncard)
+    (hpair : ∀ a b, a ≠ b → ¬ H.Adj a b →
+      2 * s ≤ (closedNeighborhood H {a, b}).card)
+    (χ : V → Fin 2) (hnonconstant : ∃ a b, χ a ≠ χ b)
+    {ℓ : ℕ} (hℓ : 1 ≤ ℓ) (hℓmax : ℓ ≤ 2 * s - 2) :
+    ∃ g : Fin (ℓ + 1) → V, IsIndexedPath H g ∧ χ (g 0) ≠ χ (g (Fin.last ℓ)) := by
+  classical
+  by_contra hnone
+  obtain ⟨x, y, z, hxy, hxz, hyz⟩ :=
+    differently_colored_common_neighbors hconn hnonbip χ hnonconstant
+  let D := H.induce {v | v ≠ y ∧ v ≠ z}
+  let x' : {v : V | v ≠ y ∧ v ≠ z} := ⟨x, hxy.ne, hxz.ne⟩
+  let C := D.connectedComponentMk x'
+  let U := componentVertices C
+  have hxU : x ∈ U := mem_componentVertices.mpr
+    ⟨⟨x', SimpleGraph.ConnectedComponent.connectedComponentMk_mem⟩, rfl⟩
+  obtain ⟨hyU, hzU⟩ := deleted_not_componentVertices C
+  change y ∉ U at hyU
+  change z ∉ U at hzU
+  have hUavoid : ∀ a ∈ U, a ≠ y ∧ a ≠ z := fun a ha =>
+    ⟨ne_of_mem_of_not_mem ha hyU, ne_of_mem_of_not_mem ha hzU⟩
+  have hcoverU : ∀ a ∈ U, ∀ b, H.Adj a b → b ∈ U ∨ b = y ∨ b = z := by
+    intro a ha b hab
+    exact componentVertices_neighbor_cover C ha hab
+  have hUconn : (H.induce (U : Set V)).Connected := componentVertices_connected C
+  obtain ⟨r, f, hf, hstart, hfU, hmax⟩ := exists_longest_path_in H U hxU
+  let W := indexedSupport f
+  have hWcard : W.card = r + 1 := indexedSupport_card hf.1
+  have hWU : W ⊆ U := by
+    intro v hv
+    obtain ⟨i, rfl⟩ := mem_indexedSupport.mp hv
+    exact hfU i
+  have hspanning : IsSpanningPath H x W f := ⟨hf.1, hf.2, hstart, indexedSupport_range f⟩
+  have havoid : ∀ i, f i ≠ y ∧ f i ≠ z := fun i => hUavoid _ (hfU i)
+  have hrshort := no_colored_path_start_bound hxy hxz χ hyz hℓ hnone hf hstart havoid
+  have hshort : W.card + 2 < 2 * s := by omega
+  let E := pathEnds H x W r
+  have hstructure := endpoint_structure hs hno hdegree hpair hyU hzU hWU hcoverU
+    hspanning hWcard hshort hmax
+  obtain ⟨hEclique, hElower, hEupper, u, huU, huE, htwo, hfull, w, hw, hwy, hwz⟩ := hstructure
+  change H.IsClique (E : Set V) at hEclique
+  change s - 2 ≤ E.card at hElower
+  change E.card ≤ s - 1 at hEupper
+  change u ∈ U at huU
+  change u ∉ E at huE
+  change w ∈ E at hw
+  have hEU : E ⊆ U := (pathEnds_subset H x W r).trans hWU
+  have hattach : ∀ e ∈ E, ∀ v ∈ U, H.Adj e v → v ∉ E → v = u := by
+    intro e he v hv hev hvE
+    rcases hfull e he v hev with hv' | hvu | rfl | rfl
+    · exact False.elim (hvE hv')
+    · exact hvu
+    · exact False.elim (hyU hv)
+    · exact False.elim (hzU hv)
+  have hUnotclique := not_clique_of_two_deleted_neighborhoods
+    ⟨x, hxU⟩ hyU hno (fun v _ => hdegree v) hcoverU
+  have hUorder := two_deleted_component_order hUnotclique hcoverU hpair
+  let T := U \ E
+  have hTset : (T : Set V) = {v | v ∈ U ∧ v ∉ E} := by ext v; simp [T]
+  have hTsum : T.card + E.card = U.card := Finset.card_sdiff_add_card_eq_card hEU
+  have hTcard : 2 ≤ T.card := by omega
+  have huT : u ∈ T := Finset.mem_sdiff.mpr ⟨huU, huE⟩
+  have hTconn : (H.induce (T : Set V)).Connected := by
+    rw [hTset]
+    exact connected_induce_difference_single_attachment hUconn huU huE hattach
+  obtain ⟨q, g, hg, hgstart, hgT, hgmax⟩ := exists_longest_path_in H T huT
+  have hq : 1 ≤ q := restricted_longest_nontrivial hTconn hTcard huT hgmax
+  let R := indexedSupport g
+  let v := g (Fin.last q)
+  have hRcard : R.card = q + 1 := indexedSupport_card hg.1
+  have hRT : R ⊆ T := by
+    intro a ha
+    obtain ⟨i, rfl⟩ := mem_indexedSupport.mp ha
+    exact hgT i
+  have hvR : v ∈ R := mem_indexedSupport.mpr ⟨Fin.last q, rfl⟩
+  have huR : u ∈ R := mem_indexedSupport.mpr ⟨0, hgstart⟩
+  have hvU : v ∈ U := (Finset.mem_sdiff.mp (hRT hvR)).1
+  have hvE : v ∉ E := (Finset.mem_sdiff.mp (hRT hvR)).2
+  have hvu : v ≠ u := by
+    intro heq
+    have hidx := hg.1 (heq.trans hgstart.symm)
+    have hval := congrArg Fin.val hidx
+    simp only [Fin.val_last, Fin.val_zero] at hval
+    omega
+  have hspanningR : IsSpanningPath H u R g :=
+    ⟨hg.1, hg.2, hgstart, indexedSupport_range g⟩
+  have hvEnd : v ∈ pathEnds H u R q := mem_pathEnds.mpr ⟨g, hspanningR, rfl⟩
+  have hcoverv : ∀ a, H.Adj v a → a ∈ R ∨ a = y ∨ a = z := by
+    intro a hva
+    rcases hcoverU v hvU a hva with haU | hay | haz
+    · have haE : a ∉ E := by
+        intro ha
+        exact hvu (hattach a ha v hvU hva.symm hvE)
+      have haT : a ∈ T := Finset.mem_sdiff.mpr ⟨haU, haE⟩
+      exact Or.inl (restricted_endpoint_neighbors hRT hgmax hvEnd a haT hva)
+    · exact Or.inr (Or.inl hay)
+    · exact Or.inr (Or.inr haz)
+  have hvw : v ≠ w := (ne_of_mem_of_not_mem hw hvE).symm
+  have hnonadj : ¬ H.Adj v w := fun h => hvu (hattach w hw v hvU h.symm hvE)
+  have hcombined := endpoint_residual_order huR hvR hw hcoverv (hfull w hw)
+    (hpair v w hvw hnonadj)
+  change 2 * s - 2 ≤ E.card + R.card at hcombined
+  have hRlist := indexedPath_ofFn_chain hg
+  have hRhead : (List.ofFn g).head? = some u := by rw [List.ofFn_succ]; simp [hgstart]
+  have hRmem : ∀ a ∈ List.ofFn g, a ∈ R := by
+    intro a ha
+    exact mem_indexedSupport.mpr ((List.mem_ofFn' g a).mp ha)
+  have hRoutside : ∀ a ∈ List.ofFn g, a ∉ E := by
+    intro a ha
+    exact (Finset.mem_sdiff.mp (hRT (hRmem a ha))).2
+  obtain ⟨L, hL, hLchain, hLhead, hLlen, hLmem⟩ := clique_join_remaining_path
+    hEclique hw htwo (List.ofFn g) hRlist.1 hRlist.2 hRhead hRoutside
+  have hLavoid : ∀ a ∈ L, a ≠ y ∧ a ≠ z := by
+    intro a ha
+    have haU : a ∈ U := by
+      rcases hLmem a ha with haE | haR
+      · exact hEU haE
+      · exact (Finset.mem_sdiff.mp (hRT (hRmem a haR))).1
+    exact hUavoid a haU
+  have hLshort := no_colored_path_list_bound hwy hwz χ hyz hℓ hnone hL hLchain hLhead hLavoid
+  simp only [List.length_ofFn] at hLlen
+  omega
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/ColouredPathStart.lean

@@ -0,0 +1,74 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.ColouredPath
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.DeletedComponent
+
+namespace OAI
+
+/-! Initial longest-path obstruction in the coloured-path proof. -/
+
+namespace CycleClique.Construction
+theorem indexedPath_prefix {V : Type*} {G : SimpleGraph V} {q r : ℕ}
+    {f : Fin (q + 1) → V} (hf : IsIndexedPath G f) (hrq : r ≤ q) :
+    IsIndexedPath G (fun i : Fin (r + 1) => f (Fin.castLE (by omega) i)) := by
+  refine ⟨hf.1.comp (Fin.castLE_injective _), ?_⟩
+  intro i
+  exact hf.2 ⟨i.val, by have := i.isLt; omega⟩
+
+theorem indexedPath_cons {V : Type*} {G : SimpleGraph V} {r : ℕ}
+    {f : Fin (r + 1) → V} (hf : IsIndexedPath G f) {v : V}
+    (hv : v ∉ Set.range f) (hadj : G.Adj v (f 0)) :
+    IsIndexedPath G (Fin.cons v f) := by
+  refine ⟨Fin.cons_injective_iff.mpr ⟨hv, hf.1⟩, ?_⟩
+  intro i
+  refine Fin.cases ?_ (fun j => ?_) i
+  · simpa using hadj
+  · have heq : j.succ.castSucc = j.castSucc.succ := Fin.ext rfl
+    rw [heq]
+    simpa only [Fin.cons_succ] using hf.2 j
+
+/-- One of two differently coloured common neighbours can prefix any
+path avoiding them, producing different colours at its two ends. -/
+theorem colored_path_of_common_neighbor {V : Type*} {H : SimpleGraph V}
+    {x y z : V} (hxy : H.Adj x y) (hxz : H.Adj x z)
+    (χ : V → Fin 2) (hyz : χ y ≠ χ z) {q : ℕ}
+    {f : Fin (q + 1) → V} (hf : IsIndexedPath H f) (hstart : f 0 = x)
+    (havoid : ∀ i, f i ≠ y ∧ f i ≠ z) :
+    ∃ g : Fin (q + 1 + 1) → V, IsIndexedPath H g ∧
+      χ (g 0) ≠ χ (g (Fin.last (q + 1))) := by
+  have hyavoid : y ∉ Set.range f := by
+    rintro ⟨i, hi⟩
+    exact (havoid i).1 hi
+  have hzavoid : z ∉ Set.range f := by
+    rintro ⟨i, hi⟩
+    exact (havoid i).2 hi
+  by_cases hycol : χ y = χ (f (Fin.last q))
+  · refine ⟨Fin.cons z f, indexedPath_cons hf hzavoid (by rw [hstart]; exact hxz.symm), ?_⟩
+    simp only [Fin.cons_zero, Fin.cons_last]
+    intro hzcol
+    exact hyz (hycol.trans hzcol.symm)
+  · refine ⟨Fin.cons y f, indexedPath_cons hf hyavoid (by rw [hstart]; exact hxy.symm), ?_⟩
+    simpa only [Fin.cons_zero, Fin.cons_last] using hycol
+
+/-- Under failure of the desired exact-length coloured path, every
+path starting at the common neighbour in the deletion has smaller order. -/
+theorem no_colored_path_start_bound {V : Type*} {H : SimpleGraph V}
+    {x y z : V} (hxy : H.Adj x y) (hxz : H.Adj x z)
+    (χ : V → Fin 2) (hyz : χ y ≠ χ z) {ℓ : ℕ} (hℓ : 1 ≤ ℓ)
+    (hno : ¬ ∃ g : Fin (ℓ + 1) → V, IsIndexedPath H g ∧
+      χ (g 0) ≠ χ (g (Fin.last ℓ)))
+    {q : ℕ} {f : Fin (q + 1) → V} (hf : IsIndexedPath H f) (hstart : f 0 = x)
+    (havoid : ∀ i, f i ≠ y ∧ f i ≠ z) : q + 1 < ℓ := by
+  cases ℓ with
+  | zero => omega
+  | succ ℓ =>
+    by_contra hn
+    have hbound : ℓ ≤ q := by omega
+    let f' : Fin (ℓ + 1) → V := fun i => f (Fin.castLE (by omega) i)
+    have hf' : IsIndexedPath H f' := indexedPath_prefix hf hbound
+    have hstart' : f' 0 = x := hstart
+    have havoid' : ∀ i, f' i ≠ y ∧ f' i ≠ z := fun i => havoid _
+    obtain ⟨g, hg, hcolor⟩ := colored_path_of_common_neighbor hxy hxz χ hyz hf' hstart' havoid'
+    exact hno ⟨g, hg, hcolor⟩
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/ComponentVertices.lean

@@ -0,0 +1,99 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.DeletedComponent
+
+namespace OAI
+
+/-! Realizing a component of the two-vertex deletion as ambient vertices. -/
+
+namespace CycleClique.Construction
+def deletedComponentEmbedding {V : Type*} {H : SimpleGraph V} {y z : V}
+    (C : (H.induce {v | v ≠ y ∧ v ≠ z}).ConnectedComponent) : C ↪ V :=
+  ⟨fun v => v.val.val, fun _ _ h => Subtype.ext (Subtype.ext h)⟩
+
+noncomputable def componentVertices {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {y z : V}
+    (C : (H.induce {v | v ≠ y ∧ v ≠ z}).ConnectedComponent) : Finset V := by
+  classical
+  exact Finset.univ.map (deletedComponentEmbedding C)
+
+@[simp] theorem mem_componentVertices {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {y z v : V}
+    {C : (H.induce {v | v ≠ y ∧ v ≠ z}).ConnectedComponent} :
+    v ∈ componentVertices C ↔ ∃ u : C, u.val.val = v := by
+  classical
+  constructor
+  · intro hv
+    change v ∈ Finset.univ.map (deletedComponentEmbedding C) at hv
+    obtain ⟨u, _, hu⟩ := Finset.mem_map.mp hv
+    exact ⟨u, hu⟩
+  · rintro ⟨u, hu⟩
+    change v ∈ Finset.univ.map (deletedComponentEmbedding C)
+    exact Finset.mem_map.mpr ⟨u, Finset.mem_univ _, hu⟩
+
+theorem deleted_not_componentVertices {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {y z : V}
+    (C : (H.induce {v | v ≠ y ∧ v ≠ z}).ConnectedComponent) :
+    y ∉ componentVertices C ∧ z ∉ componentVertices C := by
+  constructor
+  · rintro hy
+    obtain ⟨u, hu⟩ := mem_componentVertices.mp hy
+    exact u.val.property.1 hu
+  · rintro hz
+    obtain ⟨u, hu⟩ := mem_componentVertices.mp hz
+    exact u.val.property.2 hu
+
+theorem componentVertices_neighbor_cover {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {y z : V}
+    (C : (H.induce {v | v ≠ y ∧ v ≠ z}).ConnectedComponent)
+    {u v : V} (hu : u ∈ componentVertices C) (h : H.Adj u v) :
+    v ∈ componentVertices C ∨ v = y ∨ v = z := by
+  obtain ⟨u', rfl⟩ := mem_componentVertices.mp hu
+  rcases deleted_component_neighbor_cover C u' h with hy | hz | ⟨w, _, hw⟩
+  · exact Or.inr (Or.inl hy)
+  · exact Or.inr (Or.inr hz)
+  · exact Or.inl (mem_componentVertices.mpr ⟨w, hw⟩)
+
+theorem componentVertices_connected {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {y z : V}
+    (C : (H.induce {v | v ≠ y ∧ v ≠ z}).ConnectedComponent) :
+    (H.induce (componentVertices C : Set V)).Connected := by
+  classical
+  let f : C → (componentVertices C : Set V) := fun u =>
+    ⟨u.val.val, mem_componentVertices.mpr ⟨u, rfl⟩⟩
+  let φ : C.toSimpleGraph →g H.induce (componentVertices C : Set V) :=
+    { toFun := f, map_rel' := fun h => h }
+  have hsurj : Function.Surjective φ := by
+    intro v
+    obtain ⟨u, hu⟩ := mem_componentVertices.mp v.property
+    exact ⟨u, Subtype.ext hu⟩
+  exact C.connected_toSimpleGraph.map φ hsurj
+
+/-- Restriction to a vertex set closed under all other neighbours loses
+at most the two deleted neighbours. -/
+theorem induced_degree_loss_pair {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {U : Finset V} {y z : V}
+    (hcover : ∀ u ∈ U, ∀ v, H.Adj u v → v ∈ U ∨ v = y ∨ v = z)
+    (u : (U : Set V)) :
+    (H.neighborSet u.val).ncard ≤ ((H.induce (U : Set V)).neighborSet u).ncard + 2 := by
+  classical
+  let K := H.induce (U : Set V)
+  let N : Finset V := (K.neighborFinset u).map ⟨Subtype.val, Subtype.val_injective⟩
+  have hsub : H.neighborFinset u.val ⊆ N ∪ {y, z} := by
+    intro v hv
+    have hadj := (H.mem_neighborFinset u.val v).mp hv
+    rcases hcover u.val u.property v hadj with hvU | rfl | rfl
+    · let w : (U : Set V) := ⟨v, hvU⟩
+      have hw : w ∈ K.neighborFinset u := (K.mem_neighborFinset u w).mpr hadj
+      exact Finset.mem_union_left _ (Finset.mem_map.mpr ⟨w, hw, rfl⟩)
+    · simp
+    · simp
+  have hcard := (Finset.card_le_card hsub).trans (Finset.card_union_le N {y, z})
+  have hpair : ({y, z} : Finset V).card ≤ 2 := Finset.card_le_two
+  have hN : N.card = (K.neighborFinset u).card := Finset.card_map _
+  rw [hN] at hcard
+  have hdegree : (H.neighborFinset u.val).card ≤ (K.neighborFinset u).card + 2 := by omega
+  simpa only [SimpleGraph.card_neighborFinset_eq_degree,
+    SimpleGraph.ncard_neighborSet] using hdegree
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/ConditionalMain.lean

@@ -0,0 +1,41 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.AllCheckedCertificates
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.RamseyFromFiniteCoverage
+
+namespace OAI
+
+/-! The full main Ramsey theorem, conditional only on the precisely stated
+published Chvátal–Erdős input. Finite obstruction inputs are discharged by
+kernel-checked concrete certificates and their exhaustive coverage. -/
+
+namespace CycleClique.Construction
+theorem finiteCertificateCoverage : FiniteCertificateCoverage :=
+  fun _ _ hk hk' ht htk ht' hhalf => checked_certificate_coverage hk hk' ht htk ht' hhalf
+
+theorem no_expanded_counterexample (hCE : CEAlphaTwo)
+    {V : Type} [Fintype V] {G : SimpleGraph V} {k a : ℕ}
+    (hk : 5 ≤ k) (ha : 2 ≤ a) (hak : a ≤ k)
+    (hcard : Fintype.card V = k * a + 1) (hI : IndependenceBound G a)
+    (hcycle : ¬ HasCycle G (k + 1))
+    (hexpand : ∀ I : Finset V, G.IsIndepSet (I : Set V) → I.Nonempty →
+      k * I.card + 1 ≤ (closedNeighborhood G I).card) : False :=
+  no_expanded_counterexample_of_finite_coverage hCE finiteCertificateCoverage
+    hk ha hak hcard hI hcycle hexpand
+
+theorem cycle_clique_upper (hCE : CEAlphaTwo) {k a : ℕ}
+    (hk : 3 ≤ k) (ha : 2 ≤ a) (hak : a ≤ k) :
+    RamseyProperty (k + 1) (a + 1) (k * a + 1) :=
+  cycle_clique_upper_of_finite_coverage hCE finiteCertificateCoverage hk ha hak
+
+theorem cycle_clique_main (hCE : CEAlphaTwo) {m n : ℕ}
+    (hn : 3 ≤ n) (hnm : n ≤ m) (hexcept : (m, n) ≠ (3, 3)) :
+    IsRamseyNumber m n ((m - 1) * (n - 1) + 1) :=
+  cycle_clique_main_of_finite_coverage hCE finiteCertificateCoverage hn hnm hexcept
+
+theorem cycle_clique_ramsey (hCE : CEAlphaTwo) {m n : ℕ}
+    (hn : 3 ≤ n) (hnm : n ≤ m) :
+    IsRamseyNumber m n (if m = 3 ∧ n = 3 then 6 else (m - 1) * (n - 1) + 1) :=
+  cycle_clique_ramsey_of_finite_coverage hCE finiteCertificateCoverage hn hnm
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/ConnectedLongPath.lean

@@ -0,0 +1,104 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.GlobalLongest
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.PathRotation
+
+namespace OAI
+
+/-! A connected graph of minimum degree s has a path of order at least min(|V|,2s+1). -/
+
+namespace CycleClique.Construction
+private theorem last_degree_index_bound {V : Type*} [Fintype V] {G : SimpleGraph V} [DecidableRel G.Adj]
+    {r : ℕ} {f : Fin (r + 1) → V}
+    (hcover : ∀ v, G.Adj (f (Fin.last r)) v → v ∈ Set.range f) :
+    (G.neighborSet (f (Fin.last r))).ncard ≤
+      (Finset.univ.filter (fun i : Fin r => G.Adj (f (Fin.last r)) (f i.castSucc))).card := by
+  classical
+  let A := Finset.univ.filter (fun i : Fin r => G.Adj (f (Fin.last r)) (f i.castSucc))
+  have hsub : G.neighborFinset (f (Fin.last r)) ⊆ A.image (fun i => f i.castSucc) := by
+    intro v hv
+    have hadj := (G.mem_neighborFinset _ _).mp hv
+    obtain ⟨j, hj⟩ := hcover v hadj
+    have hjne : j ≠ Fin.last r := fun h => hadj.ne (by simpa only [h] using hj)
+    have hjlt : j.val < r := by
+      have := j.isLt
+      have hneq : j.val ≠ r := fun h => hjne (Fin.ext h)
+      omega
+    let i : Fin r := ⟨j.val, hjlt⟩
+    have hij : i.castSucc = j := Fin.ext rfl
+    apply Finset.mem_image.mpr
+    refine ⟨i, ?_, ?_⟩
+    · simp only [A, Finset.mem_filter, Finset.mem_univ, true_and]
+      rwa [hij, hj]
+    · simpa only [hij] using hj
+  have h := (Finset.card_le_card hsub).trans (Finset.card_image_le)
+  simpa only [SimpleGraph.card_neighborFinset_eq_degree, SimpleGraph.ncard_neighborSet] using h
+
+private theorem first_degree_index_bound {V : Type*} [Fintype V] {G : SimpleGraph V} [DecidableRel G.Adj]
+    {r : ℕ} {f : Fin (r + 1) → V}
+    (hcover : ∀ v, G.Adj (f 0) v → v ∈ Set.range f) :
+    (G.neighborSet (f 0)).ncard ≤
+      (Finset.univ.filter (fun i : Fin r => G.Adj (f 0) (f i.succ))).card := by
+  classical
+  let B := Finset.univ.filter (fun i : Fin r => G.Adj (f 0) (f i.succ))
+  have hsub : G.neighborFinset (f 0) ⊆ B.image (fun i => f i.succ) := by
+    intro v hv
+    have hadj := (G.mem_neighborFinset _ _).mp hv
+    obtain ⟨j, hj⟩ := hcover v hadj
+    have hjne : j ≠ 0 := fun h => hadj.ne (by simpa only [h] using hj)
+    have hjpos : 1 ≤ j.val := by
+      have hneq : j.val ≠ 0 := fun h => hjne (Fin.ext (by simpa only [Fin.val_zero] using h))
+      omega
+    let i : Fin r := ⟨j.val - 1, by have := j.isLt; omega⟩
+    have hij : i.succ = j := by apply Fin.ext; dsimp [i]; omega
+    apply Finset.mem_image.mpr
+    refine ⟨i, ?_, ?_⟩
+    · simp only [B, Finset.mem_filter, Finset.mem_univ, true_and]
+      rwa [hij, hj]
+    · simpa only [hij] using hj
+  have h := (Finset.card_le_card hsub).trans (Finset.card_image_le)
+  simpa only [SimpleGraph.card_neighborFinset_eq_degree, SimpleGraph.ncard_neighborSet] using h
+
+/-- Manuscript Lemma `clq:long-path`, in the application-sized form. -/
+theorem connected_long_path {V : Type*} [Fintype V] {G : SimpleGraph V} {s k : ℕ}
+    (hconn : G.Connected) (hdegree : ∀ v, s ≤ (G.neighborSet v).ncard)
+    (hk : k ≤ 2 * s + 1) (hcard : k ≤ Fintype.card V) :
+    ∃ r, ∃ f : Fin (r + 1) → V, IsIndexedPath G f ∧ k ≤ r + 1 := by
+  classical
+  let : Nonempty V := hconn.nonempty
+  obtain ⟨r, f, hf, hmax⟩ := exists_longest_path G
+  refine ⟨r, f, hf, ?_⟩
+  by_contra hshort
+  have hlast : ∀ v, G.Adj (f (Fin.last r)) v → v ∈ Set.range f :=
+    longest_path_endpoint_neighbors hf rfl (fun q g hg _ => hmax q g hg)
+  have hfirst : ∀ v, G.Adj (f 0) v → v ∈ Set.range f := by
+    intro v hv
+    have hrev := longest_path_endpoint_neighbors (indexedPath_reverse hf) rfl
+      (fun q g hg _ => hmax q g hg) v (by simpa using hv)
+    obtain ⟨j, hj⟩ := hrev
+    exact ⟨j.rev, hj⟩
+  let A := Finset.univ.filter (fun i : Fin r => G.Adj (f (Fin.last r)) (f i.castSucc))
+  let B := Finset.univ.filter (fun i : Fin r => G.Adj (f 0) (f i.succ))
+  have hA : s ≤ A.card := (hdegree _).trans (last_degree_index_bound hlast)
+  have hB : s ≤ B.card := (hdegree _).trans (first_degree_index_bound hfirst)
+  have hnotdisjoint : ¬ Disjoint A B := by
+    intro hdisjoint
+    have h := Finset.card_union_of_disjoint hdisjoint
+    have hbound : (A ∪ B).card ≤ r := by
+      have hsub : A ∪ B ⊆ Finset.univ := Finset.subset_univ _
+      simpa only [Finset.card_univ, Fintype.card_fin] using Finset.card_le_card hsub
+    omega
+  obtain ⟨p, hpA, hpB⟩ := Finset.not_disjoint_iff.mp hnotdisjoint
+  have hpA' := (Finset.mem_filter.mp hpA).2
+  have hpB' := (Finset.mem_filter.mp hpB).2
+  obtain ⟨hrotinj, hrotchain, hrotfirst, hrotlast, _⟩ := rotate_path f hf.1 hf.2 p hpA'
+  have hrot : IsIndexedPath G (f ∘ rotationIndex p) := ⟨hrotinj, hrotchain⟩
+  have hclose : G.Adj ((f ∘ rotationIndex p) (Fin.last r)) ((f ∘ rotationIndex p) 0) := by
+    rw [hrotfirst, hrotlast]
+    exact hpB'.symm
+  have hsurj := closed_longest_path_surjective hconn hrot hmax hclose
+  have hfull := Fintype.card_le_of_surjective _ hsurj
+  simp only [Fintype.card_fin] at hfull
+  omega
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/CoverageK5.lean

@@ -0,0 +1,226 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CertificatesK5
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CertificateCoverage
+
+namespace OAI
+
+namespace CycleClique.Construction.CertifiedCoverage
+
+private theorem k5t3_cover4 : ∀ P ∈ pathPatterns 0 2 [], HasCheckedCertificate 5 3 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k5t3p0, Certificates.k5t3p0_check⟩
+
+private theorem k5t3_cover3 : ∀ P ∈ pathPatterns 1 2 [], HasCheckedCertificate 5 3 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k5t3_cover4
+
+private theorem k5t3_cover5 : ∀ P ∈ pathPatterns 0 1 [1], HasCheckedCertificate 5 3 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k5t3p1, Certificates.k5t3p1_check⟩
+
+private theorem k5t3_cover6 : ∀ P ∈ pathPatterns 0 0 [2], HasCheckedCertificate 5 3 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k5t3p2, Certificates.k5t3p2_check⟩
+
+private theorem k5t3_cover2 : ∀ P ∈ pathPatterns 2 2 [], HasCheckedCertificate 5 3 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k5t3_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k5t3_cover5
+        · exact by
+            intro _
+            exact k5t3_cover6
+
+private theorem k5t3_cover7 : ∀ P ∈ pathPatterns 1 1 [1], HasCheckedCertificate 5 3 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k5t3_cover8 : ∀ P ∈ pathPatterns 0 0 [1, 1], HasCheckedCertificate 5 3 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k5t3p3, Certificates.k5t3p3_check⟩
+
+private theorem k5t3_cover9 : ∀ P ∈ pathPatterns 1 0 [2], HasCheckedCertificate 5 3 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k5t3_cover1 : ∀ P ∈ pathPatterns 3 2 [], HasCheckedCertificate 5 3 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k5t3_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k5t3_cover7
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k5t3_cover8
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k5t3_cover9
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k5_t3 :
+    ∀ P ∈ pathPatterns 3 2, HasCheckedCertificate 5 3 P :=
+  k5t3_cover1
+
+private theorem k5t4_cover5 : ∀ P ∈ pathPatterns 0 1 [], HasCheckedCertificate 5 4 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k5t4p0, Certificates.k5t4p0_check⟩
+
+private theorem k5t4_cover4 : ∀ P ∈ pathPatterns 1 1 [], HasCheckedCertificate 5 4 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k5t4_cover5
+
+private theorem k5t4_cover6 : ∀ P ∈ pathPatterns 0 0 [1], HasCheckedCertificate 5 4 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k5t4p1, Certificates.k5t4p1_check⟩
+
+private theorem k5t4_cover3 : ∀ P ∈ pathPatterns 2 1 [], HasCheckedCertificate 5 4 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k5t4_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k5t4_cover6
+
+private theorem k5t4_cover7 : ∀ P ∈ pathPatterns 1 0 [1], HasCheckedCertificate 5 4 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k5t4_cover2 : ∀ P ∈ pathPatterns 3 1 [], HasCheckedCertificate 5 4 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k5t4_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k5t4_cover7
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k5t4_cover8 : ∀ P ∈ pathPatterns 2 0 [1], HasCheckedCertificate 5 4 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k5t4_cover1 : ∀ P ∈ pathPatterns 4 1 [], HasCheckedCertificate 5 4 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k5t4_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k5t4_cover8
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k5_t4 :
+    ∀ P ∈ pathPatterns 4 1, HasCheckedCertificate 5 4 P :=
+  k5t4_cover1
+
+private theorem k5t5_cover6 : ∀ P ∈ pathPatterns 0 0 [], HasCheckedCertificate 5 5 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k5t5p0, Certificates.k5t5p0_check⟩
+
+private theorem k5t5_cover5 : ∀ P ∈ pathPatterns 1 0 [], HasCheckedCertificate 5 5 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k5t5_cover6
+
+private theorem k5t5_cover4 : ∀ P ∈ pathPatterns 2 0 [], HasCheckedCertificate 5 5 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k5t5_cover5
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k5t5_cover3 : ∀ P ∈ pathPatterns 3 0 [], HasCheckedCertificate 5 5 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k5t5_cover4
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k5t5_cover2 : ∀ P ∈ pathPatterns 4 0 [], HasCheckedCertificate 5 5 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k5t5_cover3
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k5t5_cover1 : ∀ P ∈ pathPatterns 5 0 [], HasCheckedCertificate 5 5 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k5t5_cover2
+      · intro q
+        exact Fin.elim0 q
+
+theorem coverage_k5_t5 :
+    ∀ P ∈ pathPatterns 5 0, HasCheckedCertificate 5 5 P :=
+  k5t5_cover1
+
+end CycleClique.Construction.CertifiedCoverage
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/CoverageK6.lean

@@ -0,0 +1,438 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CertificatesK6
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CertificateCoverage
+
+namespace OAI
+
+namespace CycleClique.Construction.CertifiedCoverage
+
+private theorem k6t3_cover4 : ∀ P ∈ pathPatterns 0 3 [], HasCheckedCertificate 6 3 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t3p0, Certificates.k6t3p0_check⟩
+
+private theorem k6t3_cover3 : ∀ P ∈ pathPatterns 1 3 [], HasCheckedCertificate 6 3 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k6t3_cover4
+
+private theorem k6t3_cover5 : ∀ P ∈ pathPatterns 0 2 [1], HasCheckedCertificate 6 3 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t3p1, Certificates.k6t3p1_check⟩
+
+private theorem k6t3_cover6 : ∀ P ∈ pathPatterns 0 1 [2], HasCheckedCertificate 6 3 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t3p2, Certificates.k6t3p2_check⟩
+
+private theorem k6t3_cover7 : ∀ P ∈ pathPatterns 0 0 [3], HasCheckedCertificate 6 3 ([[], [3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t3p3, Certificates.k6t3p3_check⟩
+
+private theorem k6t3_cover2 : ∀ P ∈ pathPatterns 2 3 [], HasCheckedCertificate 6 3 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t3_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k6t3_cover5
+        · exact by
+            intro _
+            exact k6t3_cover6
+        · exact by
+            intro _
+            exact k6t3_cover7
+
+private theorem k6t3_cover8 : ∀ P ∈ pathPatterns 1 2 [1], HasCheckedCertificate 6 3 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k6t3_cover9 : ∀ P ∈ pathPatterns 0 1 [1, 1], HasCheckedCertificate 6 3 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t3p4, Certificates.k6t3p4_check⟩
+
+private theorem k6t3_cover10 : ∀ P ∈ pathPatterns 0 0 [1, 2], HasCheckedCertificate 6 3 ([[1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t3p5, Certificates.k6t3p5_check⟩
+
+private theorem k6t3_cover11 : ∀ P ∈ pathPatterns 1 1 [2], HasCheckedCertificate 6 3 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k6t3_cover12 : ∀ P ∈ pathPatterns 1 0 [3], HasCheckedCertificate 6 3 ([[3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+
+private theorem k6t3_cover1 : ∀ P ∈ pathPatterns 3 3 [], HasCheckedCertificate 6 3 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t3_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k6t3_cover8
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k6t3_cover9
+              · exact by
+                  intro _
+                  exact k6t3_cover10
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k6t3_cover11
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k6t3_cover12
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k6_t3 :
+    ∀ P ∈ pathPatterns 3 3, HasCheckedCertificate 6 3 P :=
+  k6t3_cover1
+
+private theorem k6t4_cover5 : ∀ P ∈ pathPatterns 0 2 [], HasCheckedCertificate 6 4 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t4p0, Certificates.k6t4p0_check⟩
+
+private theorem k6t4_cover4 : ∀ P ∈ pathPatterns 1 2 [], HasCheckedCertificate 6 4 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k6t4_cover5
+
+private theorem k6t4_cover6 : ∀ P ∈ pathPatterns 0 1 [1], HasCheckedCertificate 6 4 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t4p1, Certificates.k6t4p1_check⟩
+
+private theorem k6t4_cover7 : ∀ P ∈ pathPatterns 0 0 [2], HasCheckedCertificate 6 4 ([[], [], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t4p2, Certificates.k6t4p2_check⟩
+
+private theorem k6t4_cover3 : ∀ P ∈ pathPatterns 2 2 [], HasCheckedCertificate 6 4 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t4_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k6t4_cover6
+        · exact by
+            intro _
+            exact k6t4_cover7
+
+private theorem k6t4_cover8 : ∀ P ∈ pathPatterns 1 1 [1], HasCheckedCertificate 6 4 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k6t4_cover9 : ∀ P ∈ pathPatterns 0 0 [1, 1], HasCheckedCertificate 6 4 ([[], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t4p3, Certificates.k6t4p3_check⟩
+
+private theorem k6t4_cover10 : ∀ P ∈ pathPatterns 1 0 [2], HasCheckedCertificate 6 4 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k6t4_cover2 : ∀ P ∈ pathPatterns 3 2 [], HasCheckedCertificate 6 4 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t4_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k6t4_cover8
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k6t4_cover9
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k6t4_cover10
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k6t4_cover12 : ∀ P ∈ pathPatterns 0 0 [1], HasCheckedCertificate 6 4 ([[1], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t4p4, Certificates.k6t4p4_check⟩
+
+private theorem k6t4_cover11 : ∀ P ∈ pathPatterns 2 1 [1], HasCheckedCertificate 6 4 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k6t4_cover12
+
+private theorem k6t4_cover13 : ∀ P ∈ pathPatterns 1 0 [1, 1], HasCheckedCertificate 6 4 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k6t4_cover14 : ∀ P ∈ pathPatterns 2 0 [2], HasCheckedCertificate 6 4 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k6t4_cover1 : ∀ P ∈ pathPatterns 4 2 [], HasCheckedCertificate 6 4 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t4_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k6t4_cover11
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k6t4_cover13
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k6t4_cover14
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k6_t4 :
+    ∀ P ∈ pathPatterns 4 2, HasCheckedCertificate 6 4 P :=
+  k6t4_cover1
+
+private theorem k6t5_cover6 : ∀ P ∈ pathPatterns 0 1 [], HasCheckedCertificate 6 5 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t5p0, Certificates.k6t5p0_check⟩
+
+private theorem k6t5_cover5 : ∀ P ∈ pathPatterns 1 1 [], HasCheckedCertificate 6 5 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k6t5_cover6
+
+private theorem k6t5_cover7 : ∀ P ∈ pathPatterns 0 0 [1], HasCheckedCertificate 6 5 ([[], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t5p1, Certificates.k6t5p1_check⟩
+
+private theorem k6t5_cover4 : ∀ P ∈ pathPatterns 2 1 [], HasCheckedCertificate 6 5 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t5_cover5
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k6t5_cover7
+
+private theorem k6t5_cover8 : ∀ P ∈ pathPatterns 1 0 [1], HasCheckedCertificate 6 5 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k6t5_cover3 : ∀ P ∈ pathPatterns 3 1 [], HasCheckedCertificate 6 5 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t5_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k6t5_cover8
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k6t5_cover9 : ∀ P ∈ pathPatterns 2 0 [1], HasCheckedCertificate 6 5 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k6t5_cover2 : ∀ P ∈ pathPatterns 4 1 [], HasCheckedCertificate 6 5 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t5_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k6t5_cover9
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k6t5_cover10 : ∀ P ∈ pathPatterns 3 0 [1], HasCheckedCertificate 6 5 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k6t5_cover1 : ∀ P ∈ pathPatterns 5 1 [], HasCheckedCertificate 6 5 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t5_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k6t5_cover10
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k6_t5 :
+    ∀ P ∈ pathPatterns 5 1, HasCheckedCertificate 6 5 P :=
+  k6t5_cover1
+
+private theorem k6t6_cover7 : ∀ P ∈ pathPatterns 0 0 [], HasCheckedCertificate 6 6 ([[], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k6t6p0, Certificates.k6t6p0_check⟩
+
+private theorem k6t6_cover6 : ∀ P ∈ pathPatterns 1 0 [], HasCheckedCertificate 6 6 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k6t6_cover7
+
+private theorem k6t6_cover5 : ∀ P ∈ pathPatterns 2 0 [], HasCheckedCertificate 6 6 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t6_cover6
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k6t6_cover4 : ∀ P ∈ pathPatterns 3 0 [], HasCheckedCertificate 6 6 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t6_cover5
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k6t6_cover3 : ∀ P ∈ pathPatterns 4 0 [], HasCheckedCertificate 6 6 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t6_cover4
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k6t6_cover2 : ∀ P ∈ pathPatterns 5 0 [], HasCheckedCertificate 6 6 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t6_cover3
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k6t6_cover1 : ∀ P ∈ pathPatterns 6 0 [], HasCheckedCertificate 6 6 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k6t6_cover2
+      · intro q
+        exact Fin.elim0 q
+
+theorem coverage_k6_t6 :
+    ∀ P ∈ pathPatterns 6 0, HasCheckedCertificate 6 6 P :=
+  k6t6_cover1
+
+end CycleClique.Construction.CertifiedCoverage
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/CoverageK7.lean

@@ -0,0 +1,815 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CertificatesK7
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CertificateCoverage
+
+namespace OAI
+
+namespace CycleClique.Construction.CertifiedCoverage
+
+private theorem k7t3_cover4 : ∀ P ∈ pathPatterns 0 4 [], HasCheckedCertificate 7 3 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t3p0, Certificates.k7t3p0_check⟩
+
+private theorem k7t3_cover3 : ∀ P ∈ pathPatterns 1 4 [], HasCheckedCertificate 7 3 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k7t3_cover4
+
+private theorem k7t3_cover5 : ∀ P ∈ pathPatterns 0 3 [1], HasCheckedCertificate 7 3 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t3p1, Certificates.k7t3p1_check⟩
+
+private theorem k7t3_cover6 : ∀ P ∈ pathPatterns 0 2 [2], HasCheckedCertificate 7 3 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t3p2, Certificates.k7t3p2_check⟩
+
+private theorem k7t3_cover7 : ∀ P ∈ pathPatterns 0 1 [3], HasCheckedCertificate 7 3 ([[], [3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t3p3, Certificates.k7t3p3_check⟩
+
+private theorem k7t3_cover8 : ∀ P ∈ pathPatterns 0 0 [4], HasCheckedCertificate 7 3 ([[], [4]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t3p4, Certificates.k7t3p4_check⟩
+
+private theorem k7t3_cover2 : ∀ P ∈ pathPatterns 2 4 [], HasCheckedCertificate 7 3 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t3_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k7t3_cover5
+        · exact by
+            intro _
+            exact k7t3_cover6
+        · exact by
+            intro _
+            exact k7t3_cover7
+        · exact by
+            intro _
+            exact k7t3_cover8
+
+private theorem k7t3_cover9 : ∀ P ∈ pathPatterns 1 3 [1], HasCheckedCertificate 7 3 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k7t3_cover10 : ∀ P ∈ pathPatterns 0 2 [1, 1], HasCheckedCertificate 7 3 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t3p5, Certificates.k7t3p5_check⟩
+
+private theorem k7t3_cover11 : ∀ P ∈ pathPatterns 0 1 [1, 2], HasCheckedCertificate 7 3 ([[1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t3p6, Certificates.k7t3p6_check⟩
+
+private theorem k7t3_cover12 : ∀ P ∈ pathPatterns 0 0 [1, 3], HasCheckedCertificate 7 3 ([[1, 3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t3p7, Certificates.k7t3p7_check⟩
+
+private theorem k7t3_cover13 : ∀ P ∈ pathPatterns 1 2 [2], HasCheckedCertificate 7 3 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k7t3_cover14 : ∀ P ∈ pathPatterns 0 0 [2, 2], HasCheckedCertificate 7 3 ([[2, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t3p8, Certificates.k7t3p8_check⟩
+
+private theorem k7t3_cover15 : ∀ P ∈ pathPatterns 1 1 [3], HasCheckedCertificate 7 3 ([[3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+
+private theorem k7t3_cover16 : ∀ P ∈ pathPatterns 1 0 [4], HasCheckedCertificate 7 3 ([[4]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [4] [] ∧ LexLE [] [])) h)
+
+private theorem k7t3_cover1 : ∀ P ∈ pathPatterns 3 4 [], HasCheckedCertificate 7 3 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t3_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t3_cover9
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k7t3_cover10
+              · exact by
+                  intro _
+                  exact k7t3_cover11
+              · exact by
+                  intro _
+                  exact k7t3_cover12
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t3_cover13
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+              · exact by
+                  intro _
+                  exact k7t3_cover14
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t3_cover15
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [3, 1] ∧ LexLE [3, 1] [1, 3])) h)
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t3_cover16
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k7_t3 :
+    ∀ P ∈ pathPatterns 3 4, HasCheckedCertificate 7 3 P :=
+  k7t3_cover1
+
+private theorem k7t4_cover5 : ∀ P ∈ pathPatterns 0 3 [], HasCheckedCertificate 7 4 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t4p0, Certificates.k7t4p0_check⟩
+
+private theorem k7t4_cover4 : ∀ P ∈ pathPatterns 1 3 [], HasCheckedCertificate 7 4 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k7t4_cover5
+
+private theorem k7t4_cover6 : ∀ P ∈ pathPatterns 0 2 [1], HasCheckedCertificate 7 4 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t4p1, Certificates.k7t4p1_check⟩
+
+private theorem k7t4_cover7 : ∀ P ∈ pathPatterns 0 1 [2], HasCheckedCertificate 7 4 ([[], [], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t4p2, Certificates.k7t4p2_check⟩
+
+private theorem k7t4_cover8 : ∀ P ∈ pathPatterns 0 0 [3], HasCheckedCertificate 7 4 ([[], [], [3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t4p3, Certificates.k7t4p3_check⟩
+
+private theorem k7t4_cover3 : ∀ P ∈ pathPatterns 2 3 [], HasCheckedCertificate 7 4 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t4_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k7t4_cover6
+        · exact by
+            intro _
+            exact k7t4_cover7
+        · exact by
+            intro _
+            exact k7t4_cover8
+
+private theorem k7t4_cover9 : ∀ P ∈ pathPatterns 1 2 [1], HasCheckedCertificate 7 4 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k7t4_cover10 : ∀ P ∈ pathPatterns 0 1 [1, 1], HasCheckedCertificate 7 4 ([[], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t4p4, Certificates.k7t4p4_check⟩
+
+private theorem k7t4_cover11 : ∀ P ∈ pathPatterns 0 0 [1, 2], HasCheckedCertificate 7 4 ([[], [1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t4p5, Certificates.k7t4p5_check⟩
+
+private theorem k7t4_cover12 : ∀ P ∈ pathPatterns 1 1 [2], HasCheckedCertificate 7 4 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k7t4_cover13 : ∀ P ∈ pathPatterns 1 0 [3], HasCheckedCertificate 7 4 ([[], [3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+
+private theorem k7t4_cover2 : ∀ P ∈ pathPatterns 3 3 [], HasCheckedCertificate 7 4 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t4_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t4_cover9
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k7t4_cover10
+              · exact by
+                  intro _
+                  exact k7t4_cover11
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t4_cover12
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t4_cover13
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k7t4_cover15 : ∀ P ∈ pathPatterns 0 1 [1], HasCheckedCertificate 7 4 ([[1], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t4p6, Certificates.k7t4p6_check⟩
+
+private theorem k7t4_cover16 : ∀ P ∈ pathPatterns 0 0 [2], HasCheckedCertificate 7 4 ([[1], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t4p7, Certificates.k7t4p7_check⟩
+
+private theorem k7t4_cover14 : ∀ P ∈ pathPatterns 2 2 [1], HasCheckedCertificate 7 4 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k7t4_cover15
+        · exact by
+            intro _
+            exact k7t4_cover16
+
+private theorem k7t4_cover17 : ∀ P ∈ pathPatterns 1 1 [1, 1], HasCheckedCertificate 7 4 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k7t4_cover18 : ∀ P ∈ pathPatterns 0 0 [1, 1, 1], HasCheckedCertificate 7 4 ([[1, 1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t4p8, Certificates.k7t4p8_check⟩
+
+private theorem k7t4_cover19 : ∀ P ∈ pathPatterns 1 0 [1, 2], HasCheckedCertificate 7 4 ([[1, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 2] [] ∧ LexLE [] [])) h)
+
+private theorem k7t4_cover20 : ∀ P ∈ pathPatterns 2 1 [2], HasCheckedCertificate 7 4 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [2] [1] ∧ LexLE [1] [1])) h)
+
+private theorem k7t4_cover21 : ∀ P ∈ pathPatterns 2 0 [3], HasCheckedCertificate 7 4 ([[3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k7t4_cover1 : ∀ P ∈ pathPatterns 4 3 [], HasCheckedCertificate 7 4 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t4_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t4_cover14
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k7t4_cover17
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        intro _
+                        exact k7t4_cover18
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k7t4_cover19
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t4_cover20
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro h
+                      exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t4_cover21
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k7_t4 :
+    ∀ P ∈ pathPatterns 4 3, HasCheckedCertificate 7 4 P :=
+  k7t4_cover1
+
+private theorem k7t5_cover6 : ∀ P ∈ pathPatterns 0 2 [], HasCheckedCertificate 7 5 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t5p0, Certificates.k7t5p0_check⟩
+
+private theorem k7t5_cover5 : ∀ P ∈ pathPatterns 1 2 [], HasCheckedCertificate 7 5 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k7t5_cover6
+
+private theorem k7t5_cover7 : ∀ P ∈ pathPatterns 0 1 [1], HasCheckedCertificate 7 5 ([[], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t5p1, Certificates.k7t5p1_check⟩
+
+private theorem k7t5_cover8 : ∀ P ∈ pathPatterns 0 0 [2], HasCheckedCertificate 7 5 ([[], [], [], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t5p2, Certificates.k7t5p2_check⟩
+
+private theorem k7t5_cover4 : ∀ P ∈ pathPatterns 2 2 [], HasCheckedCertificate 7 5 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t5_cover5
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k7t5_cover7
+        · exact by
+            intro _
+            exact k7t5_cover8
+
+private theorem k7t5_cover9 : ∀ P ∈ pathPatterns 1 1 [1], HasCheckedCertificate 7 5 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k7t5_cover10 : ∀ P ∈ pathPatterns 0 0 [1, 1], HasCheckedCertificate 7 5 ([[], [], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t5p3, Certificates.k7t5p3_check⟩
+
+private theorem k7t5_cover11 : ∀ P ∈ pathPatterns 1 0 [2], HasCheckedCertificate 7 5 ([[], [], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k7t5_cover3 : ∀ P ∈ pathPatterns 3 2 [], HasCheckedCertificate 7 5 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t5_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t5_cover9
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k7t5_cover10
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t5_cover11
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k7t5_cover13 : ∀ P ∈ pathPatterns 0 0 [1], HasCheckedCertificate 7 5 ([[], [1], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t5p4, Certificates.k7t5p4_check⟩
+
+private theorem k7t5_cover12 : ∀ P ∈ pathPatterns 2 1 [1], HasCheckedCertificate 7 5 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k7t5_cover13
+
+private theorem k7t5_cover14 : ∀ P ∈ pathPatterns 1 0 [1, 1], HasCheckedCertificate 7 5 ([[], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k7t5_cover15 : ∀ P ∈ pathPatterns 2 0 [2], HasCheckedCertificate 7 5 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k7t5_cover2 : ∀ P ∈ pathPatterns 4 2 [], HasCheckedCertificate 7 5 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t5_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t5_cover12
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k7t5_cover14
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t5_cover15
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k7t5_cover17 : ∀ P ∈ pathPatterns 1 0 [1], HasCheckedCertificate 7 5 ([[1], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k7t5_cover16 : ∀ P ∈ pathPatterns 3 1 [1], HasCheckedCertificate 7 5 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t5_cover17
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k7t5_cover18 : ∀ P ∈ pathPatterns 2 0 [1, 1], HasCheckedCertificate 7 5 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k7t5_cover19 : ∀ P ∈ pathPatterns 3 0 [2], HasCheckedCertificate 7 5 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k7t5_cover1 : ∀ P ∈ pathPatterns 5 2 [], HasCheckedCertificate 7 5 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t5_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t5_cover16
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k7t5_cover18
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t5_cover19
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k7_t5 :
+    ∀ P ∈ pathPatterns 5 2, HasCheckedCertificate 7 5 P :=
+  k7t5_cover1
+
+private theorem k7t6_cover7 : ∀ P ∈ pathPatterns 0 1 [], HasCheckedCertificate 7 6 ([[], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t6p0, Certificates.k7t6p0_check⟩
+
+private theorem k7t6_cover6 : ∀ P ∈ pathPatterns 1 1 [], HasCheckedCertificate 7 6 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k7t6_cover7
+
+private theorem k7t6_cover8 : ∀ P ∈ pathPatterns 0 0 [1], HasCheckedCertificate 7 6 ([[], [], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t6p1, Certificates.k7t6p1_check⟩
+
+private theorem k7t6_cover5 : ∀ P ∈ pathPatterns 2 1 [], HasCheckedCertificate 7 6 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t6_cover6
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k7t6_cover8
+
+private theorem k7t6_cover9 : ∀ P ∈ pathPatterns 1 0 [1], HasCheckedCertificate 7 6 ([[], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k7t6_cover4 : ∀ P ∈ pathPatterns 3 1 [], HasCheckedCertificate 7 6 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t6_cover5
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t6_cover9
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k7t6_cover10 : ∀ P ∈ pathPatterns 2 0 [1], HasCheckedCertificate 7 6 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k7t6_cover3 : ∀ P ∈ pathPatterns 4 1 [], HasCheckedCertificate 7 6 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t6_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t6_cover10
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k7t6_cover11 : ∀ P ∈ pathPatterns 3 0 [1], HasCheckedCertificate 7 6 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k7t6_cover2 : ∀ P ∈ pathPatterns 5 1 [], HasCheckedCertificate 7 6 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t6_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t6_cover11
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k7t6_cover12 : ∀ P ∈ pathPatterns 4 0 [1], HasCheckedCertificate 7 6 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k7t6_cover1 : ∀ P ∈ pathPatterns 6 1 [], HasCheckedCertificate 7 6 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t6_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k7t6_cover12
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k7_t6 :
+    ∀ P ∈ pathPatterns 6 1, HasCheckedCertificate 7 6 P :=
+  k7t6_cover1
+
+private theorem k7t7_cover8 : ∀ P ∈ pathPatterns 0 0 [], HasCheckedCertificate 7 7 ([[], [], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k7t7p0, Certificates.k7t7p0_check⟩
+
+private theorem k7t7_cover7 : ∀ P ∈ pathPatterns 1 0 [], HasCheckedCertificate 7 7 ([[], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k7t7_cover8
+
+private theorem k7t7_cover6 : ∀ P ∈ pathPatterns 2 0 [], HasCheckedCertificate 7 7 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t7_cover7
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k7t7_cover5 : ∀ P ∈ pathPatterns 3 0 [], HasCheckedCertificate 7 7 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t7_cover6
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k7t7_cover4 : ∀ P ∈ pathPatterns 4 0 [], HasCheckedCertificate 7 7 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t7_cover5
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k7t7_cover3 : ∀ P ∈ pathPatterns 5 0 [], HasCheckedCertificate 7 7 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t7_cover4
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k7t7_cover2 : ∀ P ∈ pathPatterns 6 0 [], HasCheckedCertificate 7 7 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t7_cover3
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k7t7_cover1 : ∀ P ∈ pathPatterns 7 0 [], HasCheckedCertificate 7 7 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k7t7_cover2
+      · intro q
+        exact Fin.elim0 q
+
+theorem coverage_k7_t7 :
+    ∀ P ∈ pathPatterns 7 0, HasCheckedCertificate 7 7 P :=
+  k7t7_cover1
+
+end CycleClique.Construction.CertifiedCoverage
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/CoverageK8.lean

@@ -0,0 +1,1290 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CertificatesK8
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CertificateCoverage
+
+namespace OAI
+
+namespace CycleClique.Construction.CertifiedCoverage
+
+private theorem k8t4_cover5 : ∀ P ∈ pathPatterns 0 4 [], HasCheckedCertificate 8 4 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p0, Certificates.k8t4p0_check⟩
+
+private theorem k8t4_cover4 : ∀ P ∈ pathPatterns 1 4 [], HasCheckedCertificate 8 4 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k8t4_cover5
+
+private theorem k8t4_cover6 : ∀ P ∈ pathPatterns 0 3 [1], HasCheckedCertificate 8 4 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p1, Certificates.k8t4p1_check⟩
+
+private theorem k8t4_cover7 : ∀ P ∈ pathPatterns 0 2 [2], HasCheckedCertificate 8 4 ([[], [], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p2, Certificates.k8t4p2_check⟩
+
+private theorem k8t4_cover8 : ∀ P ∈ pathPatterns 0 1 [3], HasCheckedCertificate 8 4 ([[], [], [3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p3, Certificates.k8t4p3_check⟩
+
+private theorem k8t4_cover9 : ∀ P ∈ pathPatterns 0 0 [4], HasCheckedCertificate 8 4 ([[], [], [4]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p4, Certificates.k8t4p4_check⟩
+
+private theorem k8t4_cover3 : ∀ P ∈ pathPatterns 2 4 [], HasCheckedCertificate 8 4 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t4_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k8t4_cover6
+        · exact by
+            intro _
+            exact k8t4_cover7
+        · exact by
+            intro _
+            exact k8t4_cover8
+        · exact by
+            intro _
+            exact k8t4_cover9
+
+private theorem k8t4_cover10 : ∀ P ∈ pathPatterns 1 3 [1], HasCheckedCertificate 8 4 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k8t4_cover11 : ∀ P ∈ pathPatterns 0 2 [1, 1], HasCheckedCertificate 8 4 ([[], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p5, Certificates.k8t4p5_check⟩
+
+private theorem k8t4_cover12 : ∀ P ∈ pathPatterns 0 1 [1, 2], HasCheckedCertificate 8 4 ([[], [1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p6, Certificates.k8t4p6_check⟩
+
+private theorem k8t4_cover13 : ∀ P ∈ pathPatterns 0 0 [1, 3], HasCheckedCertificate 8 4 ([[], [1, 3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p7, Certificates.k8t4p7_check⟩
+
+private theorem k8t4_cover14 : ∀ P ∈ pathPatterns 1 2 [2], HasCheckedCertificate 8 4 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k8t4_cover15 : ∀ P ∈ pathPatterns 0 0 [2, 2], HasCheckedCertificate 8 4 ([[], [2, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p8, Certificates.k8t4p8_check⟩
+
+private theorem k8t4_cover16 : ∀ P ∈ pathPatterns 1 1 [3], HasCheckedCertificate 8 4 ([[], [3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+
+private theorem k8t4_cover17 : ∀ P ∈ pathPatterns 1 0 [4], HasCheckedCertificate 8 4 ([[], [4]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [4] [] ∧ LexLE [] [])) h)
+
+private theorem k8t4_cover2 : ∀ P ∈ pathPatterns 3 4 [], HasCheckedCertificate 8 4 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t4_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t4_cover10
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k8t4_cover11
+              · exact by
+                  intro _
+                  exact k8t4_cover12
+              · exact by
+                  intro _
+                  exact k8t4_cover13
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t4_cover14
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+              · exact by
+                  intro _
+                  exact k8t4_cover15
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t4_cover16
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [3, 1] ∧ LexLE [3, 1] [1, 3])) h)
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t4_cover17
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t4_cover19 : ∀ P ∈ pathPatterns 0 2 [1], HasCheckedCertificate 8 4 ([[1], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p9, Certificates.k8t4p9_check⟩
+
+private theorem k8t4_cover20 : ∀ P ∈ pathPatterns 0 1 [2], HasCheckedCertificate 8 4 ([[1], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p10, Certificates.k8t4p10_check⟩
+
+private theorem k8t4_cover21 : ∀ P ∈ pathPatterns 0 0 [3], HasCheckedCertificate 8 4 ([[1], [3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p11, Certificates.k8t4p11_check⟩
+
+private theorem k8t4_cover18 : ∀ P ∈ pathPatterns 2 3 [1], HasCheckedCertificate 8 4 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k8t4_cover19
+        · exact by
+            intro _
+            exact k8t4_cover20
+        · exact by
+            intro _
+            exact k8t4_cover21
+
+private theorem k8t4_cover22 : ∀ P ∈ pathPatterns 1 2 [1, 1], HasCheckedCertificate 8 4 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k8t4_cover23 : ∀ P ∈ pathPatterns 0 1 [1, 1, 1], HasCheckedCertificate 8 4 ([[1, 1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p12, Certificates.k8t4p12_check⟩
+
+private theorem k8t4_cover24 : ∀ P ∈ pathPatterns 0 0 [1, 1, 2], HasCheckedCertificate 8 4 ([[1, 1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p13, Certificates.k8t4p13_check⟩
+
+private theorem k8t4_cover25 : ∀ P ∈ pathPatterns 1 1 [1, 2], HasCheckedCertificate 8 4 ([[1, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 2] [] ∧ LexLE [] [])) h)
+
+private theorem k8t4_cover26 : ∀ P ∈ pathPatterns 0 0 [1, 2, 1], HasCheckedCertificate 8 4 ([[1, 2, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p14, Certificates.k8t4p14_check⟩
+
+private theorem k8t4_cover27 : ∀ P ∈ pathPatterns 1 0 [1, 3], HasCheckedCertificate 8 4 ([[1, 3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 3] [] ∧ LexLE [] [])) h)
+
+private theorem k8t4_cover29 : ∀ P ∈ pathPatterns 0 0 [2], HasCheckedCertificate 8 4 ([[2], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t4p15, Certificates.k8t4p15_check⟩
+
+private theorem k8t4_cover28 : ∀ P ∈ pathPatterns 2 2 [2], HasCheckedCertificate 8 4 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [2] [1] ∧ LexLE [1] [1])) h)
+        · exact by
+            intro _
+            exact k8t4_cover29
+
+private theorem k8t4_cover30 : ∀ P ∈ pathPatterns 1 0 [2, 2], HasCheckedCertificate 8 4 ([[2, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2, 2] [] ∧ LexLE [] [])) h)
+
+private theorem k8t4_cover31 : ∀ P ∈ pathPatterns 2 1 [3], HasCheckedCertificate 8 4 ([[3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [3] [1] ∧ LexLE [1] [1])) h)
+
+private theorem k8t4_cover32 : ∀ P ∈ pathPatterns 2 0 [4], HasCheckedCertificate 8 4 ([[4]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [4] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t4_cover1 : ∀ P ∈ pathPatterns 4 4 [], HasCheckedCertificate 8 4 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t4_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t4_cover18
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k8t4_cover22
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        intro _
+                        exact k8t4_cover23
+                    · exact by
+                        intro _
+                        exact k8t4_cover24
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k8t4_cover25
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        intro _
+                        exact k8t4_cover26
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k8t4_cover27
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t4_cover28
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro h
+                      exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        intro h
+                        exact False.elim ((by decide : ¬ (LexLE [] [2, 1, 1] ∧ LexLE [2, 1, 1] [1, 1, 2])) h)
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k8t4_cover30
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t4_cover31
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro h
+                      exact False.elim ((by decide : ¬ (LexLE [] [3, 1] ∧ LexLE [3, 1] [1, 3])) h)
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t4_cover32
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k8_t4 :
+    ∀ P ∈ pathPatterns 4 4, HasCheckedCertificate 8 4 P :=
+  k8t4_cover1
+
+private theorem k8t5_cover6 : ∀ P ∈ pathPatterns 0 3 [], HasCheckedCertificate 8 5 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t5p0, Certificates.k8t5p0_check⟩
+
+private theorem k8t5_cover5 : ∀ P ∈ pathPatterns 1 3 [], HasCheckedCertificate 8 5 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k8t5_cover6
+
+private theorem k8t5_cover7 : ∀ P ∈ pathPatterns 0 2 [1], HasCheckedCertificate 8 5 ([[], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t5p1, Certificates.k8t5p1_check⟩
+
+private theorem k8t5_cover8 : ∀ P ∈ pathPatterns 0 1 [2], HasCheckedCertificate 8 5 ([[], [], [], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t5p2, Certificates.k8t5p2_check⟩
+
+private theorem k8t5_cover9 : ∀ P ∈ pathPatterns 0 0 [3], HasCheckedCertificate 8 5 ([[], [], [], [3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t5p3, Certificates.k8t5p3_check⟩
+
+private theorem k8t5_cover4 : ∀ P ∈ pathPatterns 2 3 [], HasCheckedCertificate 8 5 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t5_cover5
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k8t5_cover7
+        · exact by
+            intro _
+            exact k8t5_cover8
+        · exact by
+            intro _
+            exact k8t5_cover9
+
+private theorem k8t5_cover10 : ∀ P ∈ pathPatterns 1 2 [1], HasCheckedCertificate 8 5 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k8t5_cover11 : ∀ P ∈ pathPatterns 0 1 [1, 1], HasCheckedCertificate 8 5 ([[], [], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t5p4, Certificates.k8t5p4_check⟩
+
+private theorem k8t5_cover12 : ∀ P ∈ pathPatterns 0 0 [1, 2], HasCheckedCertificate 8 5 ([[], [], [1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t5p5, Certificates.k8t5p5_check⟩
+
+private theorem k8t5_cover13 : ∀ P ∈ pathPatterns 1 1 [2], HasCheckedCertificate 8 5 ([[], [], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k8t5_cover14 : ∀ P ∈ pathPatterns 1 0 [3], HasCheckedCertificate 8 5 ([[], [], [3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+
+private theorem k8t5_cover3 : ∀ P ∈ pathPatterns 3 3 [], HasCheckedCertificate 8 5 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t5_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t5_cover10
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k8t5_cover11
+              · exact by
+                  intro _
+                  exact k8t5_cover12
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t5_cover13
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t5_cover14
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t5_cover16 : ∀ P ∈ pathPatterns 0 1 [1], HasCheckedCertificate 8 5 ([[], [1], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t5p6, Certificates.k8t5p6_check⟩
+
+private theorem k8t5_cover17 : ∀ P ∈ pathPatterns 0 0 [2], HasCheckedCertificate 8 5 ([[], [1], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t5p7, Certificates.k8t5p7_check⟩
+
+private theorem k8t5_cover15 : ∀ P ∈ pathPatterns 2 2 [1], HasCheckedCertificate 8 5 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k8t5_cover16
+        · exact by
+            intro _
+            exact k8t5_cover17
+
+private theorem k8t5_cover18 : ∀ P ∈ pathPatterns 1 1 [1, 1], HasCheckedCertificate 8 5 ([[], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k8t5_cover19 : ∀ P ∈ pathPatterns 0 0 [1, 1, 1], HasCheckedCertificate 8 5 ([[], [1, 1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t5p8, Certificates.k8t5p8_check⟩
+
+private theorem k8t5_cover20 : ∀ P ∈ pathPatterns 1 0 [1, 2], HasCheckedCertificate 8 5 ([[], [1, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 2] [] ∧ LexLE [] [])) h)
+
+private theorem k8t5_cover21 : ∀ P ∈ pathPatterns 2 1 [2], HasCheckedCertificate 8 5 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [2] [1] ∧ LexLE [1] [1])) h)
+
+private theorem k8t5_cover22 : ∀ P ∈ pathPatterns 2 0 [3], HasCheckedCertificate 8 5 ([[], [3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t5_cover2 : ∀ P ∈ pathPatterns 4 3 [], HasCheckedCertificate 8 5 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t5_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t5_cover15
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k8t5_cover18
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        intro _
+                        exact k8t5_cover19
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k8t5_cover20
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t5_cover21
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro h
+                      exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t5_cover22
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t5_cover24 : ∀ P ∈ pathPatterns 1 1 [1], HasCheckedCertificate 8 5 ([[1], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k8t5_cover25 : ∀ P ∈ pathPatterns 0 0 [1, 1], HasCheckedCertificate 8 5 ([[1], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t5p9, Certificates.k8t5p9_check⟩
+
+private theorem k8t5_cover26 : ∀ P ∈ pathPatterns 1 0 [2], HasCheckedCertificate 8 5 ([[1], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k8t5_cover23 : ∀ P ∈ pathPatterns 3 2 [1], HasCheckedCertificate 8 5 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t5_cover24
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k8t5_cover25
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t5_cover26
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t5_cover27 : ∀ P ∈ pathPatterns 2 1 [1, 1], HasCheckedCertificate 8 5 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [1, 1] [1] ∧ LexLE [1] [1])) h)
+
+private theorem k8t5_cover28 : ∀ P ∈ pathPatterns 1 0 [1, 1, 1], HasCheckedCertificate 8 5 ([[1, 1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k8t5_cover29 : ∀ P ∈ pathPatterns 2 0 [1, 2], HasCheckedCertificate 8 5 ([[1, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t5_cover30 : ∀ P ∈ pathPatterns 3 1 [2], HasCheckedCertificate 8 5 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro h
+                exact False.elim ((by decide : ¬ (LexLE [2] [1] ∧ LexLE [1] [1])) h)
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t5_cover31 : ∀ P ∈ pathPatterns 3 0 [3], HasCheckedCertificate 8 5 ([[3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t5_cover1 : ∀ P ∈ pathPatterns 5 3 [], HasCheckedCertificate 8 5 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t5_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t5_cover23
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k8t5_cover27
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        constructor
+                        · exact by
+                            intro _
+                            exact k8t5_cover28
+                        · intro q
+                          exact Fin.elim0 q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k8t5_cover29
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t5_cover30
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro h
+                      exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t5_cover31
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k8_t5 :
+    ∀ P ∈ pathPatterns 5 3, HasCheckedCertificate 8 5 P :=
+  k8t5_cover1
+
+private theorem k8t6_cover7 : ∀ P ∈ pathPatterns 0 2 [], HasCheckedCertificate 8 6 ([[], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t6p0, Certificates.k8t6p0_check⟩
+
+private theorem k8t6_cover6 : ∀ P ∈ pathPatterns 1 2 [], HasCheckedCertificate 8 6 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k8t6_cover7
+
+private theorem k8t6_cover8 : ∀ P ∈ pathPatterns 0 1 [1], HasCheckedCertificate 8 6 ([[], [], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t6p1, Certificates.k8t6p1_check⟩
+
+private theorem k8t6_cover9 : ∀ P ∈ pathPatterns 0 0 [2], HasCheckedCertificate 8 6 ([[], [], [], [], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t6p2, Certificates.k8t6p2_check⟩
+
+private theorem k8t6_cover5 : ∀ P ∈ pathPatterns 2 2 [], HasCheckedCertificate 8 6 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t6_cover6
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k8t6_cover8
+        · exact by
+            intro _
+            exact k8t6_cover9
+
+private theorem k8t6_cover10 : ∀ P ∈ pathPatterns 1 1 [1], HasCheckedCertificate 8 6 ([[], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k8t6_cover11 : ∀ P ∈ pathPatterns 0 0 [1, 1], HasCheckedCertificate 8 6 ([[], [], [], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t6p3, Certificates.k8t6p3_check⟩
+
+private theorem k8t6_cover12 : ∀ P ∈ pathPatterns 1 0 [2], HasCheckedCertificate 8 6 ([[], [], [], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k8t6_cover4 : ∀ P ∈ pathPatterns 3 2 [], HasCheckedCertificate 8 6 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t6_cover5
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t6_cover10
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k8t6_cover11
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t6_cover12
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t6_cover14 : ∀ P ∈ pathPatterns 0 0 [1], HasCheckedCertificate 8 6 ([[], [], [1], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t6p4, Certificates.k8t6p4_check⟩
+
+private theorem k8t6_cover13 : ∀ P ∈ pathPatterns 2 1 [1], HasCheckedCertificate 8 6 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k8t6_cover14
+
+private theorem k8t6_cover15 : ∀ P ∈ pathPatterns 1 0 [1, 1], HasCheckedCertificate 8 6 ([[], [], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k8t6_cover16 : ∀ P ∈ pathPatterns 2 0 [2], HasCheckedCertificate 8 6 ([[], [], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t6_cover3 : ∀ P ∈ pathPatterns 4 2 [], HasCheckedCertificate 8 6 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t6_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t6_cover13
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k8t6_cover15
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t6_cover16
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t6_cover18 : ∀ P ∈ pathPatterns 1 0 [1], HasCheckedCertificate 8 6 ([[], [1], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k8t6_cover17 : ∀ P ∈ pathPatterns 3 1 [1], HasCheckedCertificate 8 6 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t6_cover18
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t6_cover19 : ∀ P ∈ pathPatterns 2 0 [1, 1], HasCheckedCertificate 8 6 ([[], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t6_cover20 : ∀ P ∈ pathPatterns 3 0 [2], HasCheckedCertificate 8 6 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t6_cover2 : ∀ P ∈ pathPatterns 5 2 [], HasCheckedCertificate 8 6 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t6_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t6_cover17
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k8t6_cover19
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t6_cover20
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t6_cover22 : ∀ P ∈ pathPatterns 2 0 [1], HasCheckedCertificate 8 6 ([[1], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t6_cover21 : ∀ P ∈ pathPatterns 4 1 [1], HasCheckedCertificate 8 6 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t6_cover22
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t6_cover23 : ∀ P ∈ pathPatterns 3 0 [1, 1], HasCheckedCertificate 8 6 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t6_cover24 : ∀ P ∈ pathPatterns 4 0 [2], HasCheckedCertificate 8 6 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t6_cover1 : ∀ P ∈ pathPatterns 6 2 [], HasCheckedCertificate 8 6 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t6_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t6_cover21
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k8t6_cover23
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t6_cover24
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k8_t6 :
+    ∀ P ∈ pathPatterns 6 2, HasCheckedCertificate 8 6 P :=
+  k8t6_cover1
+
+private theorem k8t7_cover8 : ∀ P ∈ pathPatterns 0 1 [], HasCheckedCertificate 8 7 ([[], [], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t7p0, Certificates.k8t7p0_check⟩
+
+private theorem k8t7_cover7 : ∀ P ∈ pathPatterns 1 1 [], HasCheckedCertificate 8 7 ([[], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k8t7_cover8
+
+private theorem k8t7_cover9 : ∀ P ∈ pathPatterns 0 0 [1], HasCheckedCertificate 8 7 ([[], [], [], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t7p1, Certificates.k8t7p1_check⟩
+
+private theorem k8t7_cover6 : ∀ P ∈ pathPatterns 2 1 [], HasCheckedCertificate 8 7 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t7_cover7
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k8t7_cover9
+
+private theorem k8t7_cover10 : ∀ P ∈ pathPatterns 1 0 [1], HasCheckedCertificate 8 7 ([[], [], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k8t7_cover5 : ∀ P ∈ pathPatterns 3 1 [], HasCheckedCertificate 8 7 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t7_cover6
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t7_cover10
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t7_cover11 : ∀ P ∈ pathPatterns 2 0 [1], HasCheckedCertificate 8 7 ([[], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t7_cover4 : ∀ P ∈ pathPatterns 4 1 [], HasCheckedCertificate 8 7 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t7_cover5
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t7_cover11
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t7_cover12 : ∀ P ∈ pathPatterns 3 0 [1], HasCheckedCertificate 8 7 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t7_cover3 : ∀ P ∈ pathPatterns 5 1 [], HasCheckedCertificate 8 7 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t7_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t7_cover12
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t7_cover13 : ∀ P ∈ pathPatterns 4 0 [1], HasCheckedCertificate 8 7 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t7_cover2 : ∀ P ∈ pathPatterns 6 1 [], HasCheckedCertificate 8 7 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t7_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t7_cover13
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k8t7_cover14 : ∀ P ∈ pathPatterns 5 0 [1], HasCheckedCertificate 8 7 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t7_cover1 : ∀ P ∈ pathPatterns 7 1 [], HasCheckedCertificate 8 7 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t7_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k8t7_cover14
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k8_t7 :
+    ∀ P ∈ pathPatterns 7 1, HasCheckedCertificate 8 7 P :=
+  k8t7_cover1
+
+private theorem k8t8_cover9 : ∀ P ∈ pathPatterns 0 0 [], HasCheckedCertificate 8 8 ([[], [], [], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k8t8p0, Certificates.k8t8p0_check⟩
+
+private theorem k8t8_cover8 : ∀ P ∈ pathPatterns 1 0 [], HasCheckedCertificate 8 8 ([[], [], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k8t8_cover9
+
+private theorem k8t8_cover7 : ∀ P ∈ pathPatterns 2 0 [], HasCheckedCertificate 8 8 ([[], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t8_cover8
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t8_cover6 : ∀ P ∈ pathPatterns 3 0 [], HasCheckedCertificate 8 8 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t8_cover7
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t8_cover5 : ∀ P ∈ pathPatterns 4 0 [], HasCheckedCertificate 8 8 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t8_cover6
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t8_cover4 : ∀ P ∈ pathPatterns 5 0 [], HasCheckedCertificate 8 8 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t8_cover5
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t8_cover3 : ∀ P ∈ pathPatterns 6 0 [], HasCheckedCertificate 8 8 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t8_cover4
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t8_cover2 : ∀ P ∈ pathPatterns 7 0 [], HasCheckedCertificate 8 8 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t8_cover3
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k8t8_cover1 : ∀ P ∈ pathPatterns 8 0 [], HasCheckedCertificate 8 8 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k8t8_cover2
+      · intro q
+        exact Fin.elim0 q
+
+theorem coverage_k8_t8 :
+    ∀ P ∈ pathPatterns 8 0, HasCheckedCertificate 8 8 P :=
+  k8t8_cover1
+
+end CycleClique.Construction.CertifiedCoverage
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/CoverageK9.lean

@@ -0,0 +1,2318 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CertificatesK9
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.CertificateCoverage
+
+namespace OAI
+
+namespace CycleClique.Construction.CertifiedCoverage
+
+private theorem k9t4_cover6 : ∀ P ∈ pathPatterns 0 5 [], HasCheckedCertificate 9 4 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p0, Certificates.k9t4p0_check⟩
+
+private theorem k9t4_cover5 : ∀ P ∈ pathPatterns 1 5 [], HasCheckedCertificate 9 4 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k9t4_cover6
+
+private theorem k9t4_cover7 : ∀ P ∈ pathPatterns 0 4 [1], HasCheckedCertificate 9 4 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p1, Certificates.k9t4p1_check⟩
+
+private theorem k9t4_cover8 : ∀ P ∈ pathPatterns 0 3 [2], HasCheckedCertificate 9 4 ([[], [], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p2, Certificates.k9t4p2_check⟩
+
+private theorem k9t4_cover9 : ∀ P ∈ pathPatterns 0 2 [3], HasCheckedCertificate 9 4 ([[], [], [3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p3, Certificates.k9t4p3_check⟩
+
+private theorem k9t4_cover10 : ∀ P ∈ pathPatterns 0 1 [4], HasCheckedCertificate 9 4 ([[], [], [4]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p4, Certificates.k9t4p4_check⟩
+
+private theorem k9t4_cover11 : ∀ P ∈ pathPatterns 0 0 [5], HasCheckedCertificate 9 4 ([[], [], [5]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p5, Certificates.k9t4p5_check⟩
+
+private theorem k9t4_cover4 : ∀ P ∈ pathPatterns 2 5 [], HasCheckedCertificate 9 4 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t4_cover5
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k9t4_cover7
+        · exact by
+            intro _
+            exact k9t4_cover8
+        · exact by
+            intro _
+            exact k9t4_cover9
+        · exact by
+            intro _
+            exact k9t4_cover10
+        · exact by
+            intro _
+            exact k9t4_cover11
+
+private theorem k9t4_cover12 : ∀ P ∈ pathPatterns 1 4 [1], HasCheckedCertificate 9 4 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t4_cover13 : ∀ P ∈ pathPatterns 0 3 [1, 1], HasCheckedCertificate 9 4 ([[], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p6, Certificates.k9t4p6_check⟩
+
+private theorem k9t4_cover14 : ∀ P ∈ pathPatterns 0 2 [1, 2], HasCheckedCertificate 9 4 ([[], [1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p7, Certificates.k9t4p7_check⟩
+
+private theorem k9t4_cover15 : ∀ P ∈ pathPatterns 0 1 [1, 3], HasCheckedCertificate 9 4 ([[], [1, 3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p8, Certificates.k9t4p8_check⟩
+
+private theorem k9t4_cover16 : ∀ P ∈ pathPatterns 0 0 [1, 4], HasCheckedCertificate 9 4 ([[], [1, 4]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p9, Certificates.k9t4p9_check⟩
+
+private theorem k9t4_cover17 : ∀ P ∈ pathPatterns 1 3 [2], HasCheckedCertificate 9 4 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t4_cover18 : ∀ P ∈ pathPatterns 0 1 [2, 2], HasCheckedCertificate 9 4 ([[], [2, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p10, Certificates.k9t4p10_check⟩
+
+private theorem k9t4_cover19 : ∀ P ∈ pathPatterns 0 0 [2, 3], HasCheckedCertificate 9 4 ([[], [2, 3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p11, Certificates.k9t4p11_check⟩
+
+private theorem k9t4_cover20 : ∀ P ∈ pathPatterns 1 2 [3], HasCheckedCertificate 9 4 ([[], [3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+
+private theorem k9t4_cover21 : ∀ P ∈ pathPatterns 1 1 [4], HasCheckedCertificate 9 4 ([[], [4]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [4] [] ∧ LexLE [] [])) h)
+
+private theorem k9t4_cover22 : ∀ P ∈ pathPatterns 1 0 [5], HasCheckedCertificate 9 4 ([[], [5]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [5] [] ∧ LexLE [] [])) h)
+
+private theorem k9t4_cover3 : ∀ P ∈ pathPatterns 3 5 [], HasCheckedCertificate 9 4 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t4_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t4_cover12
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k9t4_cover13
+              · exact by
+                  intro _
+                  exact k9t4_cover14
+              · exact by
+                  intro _
+                  exact k9t4_cover15
+              · exact by
+                  intro _
+                  exact k9t4_cover16
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t4_cover17
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+              · exact by
+                  intro _
+                  exact k9t4_cover18
+              · exact by
+                  intro _
+                  exact k9t4_cover19
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t4_cover20
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [3, 1] ∧ LexLE [3, 1] [1, 3])) h)
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [3, 2] ∧ LexLE [3, 2] [2, 3])) h)
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t4_cover21
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [4, 1] ∧ LexLE [4, 1] [1, 4])) h)
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t4_cover22
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t4_cover24 : ∀ P ∈ pathPatterns 0 3 [1], HasCheckedCertificate 9 4 ([[1], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p12, Certificates.k9t4p12_check⟩
+
+private theorem k9t4_cover25 : ∀ P ∈ pathPatterns 0 2 [2], HasCheckedCertificate 9 4 ([[1], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p13, Certificates.k9t4p13_check⟩
+
+private theorem k9t4_cover26 : ∀ P ∈ pathPatterns 0 1 [3], HasCheckedCertificate 9 4 ([[1], [3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p14, Certificates.k9t4p14_check⟩
+
+private theorem k9t4_cover27 : ∀ P ∈ pathPatterns 0 0 [4], HasCheckedCertificate 9 4 ([[1], [4]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p15, Certificates.k9t4p15_check⟩
+
+private theorem k9t4_cover23 : ∀ P ∈ pathPatterns 2 4 [1], HasCheckedCertificate 9 4 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k9t4_cover24
+        · exact by
+            intro _
+            exact k9t4_cover25
+        · exact by
+            intro _
+            exact k9t4_cover26
+        · exact by
+            intro _
+            exact k9t4_cover27
+
+private theorem k9t4_cover28 : ∀ P ∈ pathPatterns 1 3 [1, 1], HasCheckedCertificate 9 4 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t4_cover29 : ∀ P ∈ pathPatterns 0 2 [1, 1, 1], HasCheckedCertificate 9 4 ([[1, 1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p16, Certificates.k9t4p16_check⟩
+
+private theorem k9t4_cover30 : ∀ P ∈ pathPatterns 0 1 [1, 1, 2], HasCheckedCertificate 9 4 ([[1, 1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p17, Certificates.k9t4p17_check⟩
+
+private theorem k9t4_cover31 : ∀ P ∈ pathPatterns 0 0 [1, 1, 3], HasCheckedCertificate 9 4 ([[1, 1, 3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p18, Certificates.k9t4p18_check⟩
+
+private theorem k9t4_cover32 : ∀ P ∈ pathPatterns 1 2 [1, 2], HasCheckedCertificate 9 4 ([[1, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t4_cover33 : ∀ P ∈ pathPatterns 0 1 [1, 2, 1], HasCheckedCertificate 9 4 ([[1, 2, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p19, Certificates.k9t4p19_check⟩
+
+private theorem k9t4_cover34 : ∀ P ∈ pathPatterns 0 0 [1, 2, 2], HasCheckedCertificate 9 4 ([[1, 2, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p20, Certificates.k9t4p20_check⟩
+
+private theorem k9t4_cover35 : ∀ P ∈ pathPatterns 1 1 [1, 3], HasCheckedCertificate 9 4 ([[1, 3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 3] [] ∧ LexLE [] [])) h)
+
+private theorem k9t4_cover36 : ∀ P ∈ pathPatterns 0 0 [1, 3, 1], HasCheckedCertificate 9 4 ([[1, 3, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p21, Certificates.k9t4p21_check⟩
+
+private theorem k9t4_cover37 : ∀ P ∈ pathPatterns 1 0 [1, 4], HasCheckedCertificate 9 4 ([[1, 4]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 4] [] ∧ LexLE [] [])) h)
+
+private theorem k9t4_cover39 : ∀ P ∈ pathPatterns 0 1 [2], HasCheckedCertificate 9 4 ([[2], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p22, Certificates.k9t4p22_check⟩
+
+private theorem k9t4_cover40 : ∀ P ∈ pathPatterns 0 0 [3], HasCheckedCertificate 9 4 ([[2], [3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p23, Certificates.k9t4p23_check⟩
+
+private theorem k9t4_cover38 : ∀ P ∈ pathPatterns 2 3 [2], HasCheckedCertificate 9 4 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [2] [1] ∧ LexLE [1] [1])) h)
+        · exact by
+            intro _
+            exact k9t4_cover39
+        · exact by
+            intro _
+            exact k9t4_cover40
+
+private theorem k9t4_cover41 : ∀ P ∈ pathPatterns 0 0 [2, 1, 2], HasCheckedCertificate 9 4 ([[2, 1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t4p24, Certificates.k9t4p24_check⟩
+
+private theorem k9t4_cover42 : ∀ P ∈ pathPatterns 1 1 [2, 2], HasCheckedCertificate 9 4 ([[2, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2, 2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t4_cover43 : ∀ P ∈ pathPatterns 1 0 [2, 3], HasCheckedCertificate 9 4 ([[2, 3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2, 3] [] ∧ LexLE [] [])) h)
+
+private theorem k9t4_cover44 : ∀ P ∈ pathPatterns 2 2 [3], HasCheckedCertificate 9 4 ([[3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [3] [1] ∧ LexLE [1] [1])) h)
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [3] [2] ∧ LexLE [2] [2])) h)
+
+private theorem k9t4_cover45 : ∀ P ∈ pathPatterns 2 1 [4], HasCheckedCertificate 9 4 ([[4]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [4] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [4] [1] ∧ LexLE [1] [1])) h)
+
+private theorem k9t4_cover46 : ∀ P ∈ pathPatterns 2 0 [5], HasCheckedCertificate 9 4 ([[5]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [5] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t4_seq2 : amountSequenceForall 3 5 (fun tail =>
+    (LexLE [] ([] ++ tail) ∧ LexLE ([] ++ tail) ([] ++ tail).reverse) →
+    ∀ P ∈ pathPatterns (3 - ([] ++ tail).length) (5 - ([] ++ tail).sum) ([] ++ tail),
+      HasCheckedCertificate 9 4 ([] ++ (([] ++ tail) :: P))) :=
+by
+  constructor
+  · exact by
+      intro _
+      exact k9t4_cover3
+  · intro q
+    fin_cases q
+    · exact by
+        constructor
+        · exact by
+            intro _
+            exact k9t4_cover23
+        · intro q
+          fin_cases q
+          · exact by
+              constructor
+              · exact by
+                  intro _
+                  exact k9t4_cover28
+              · intro q
+                fin_cases q
+                · exact by
+                    intro _
+                    exact k9t4_cover29
+                · exact by
+                    intro _
+                    exact k9t4_cover30
+                · exact by
+                    intro _
+                    exact k9t4_cover31
+          · exact by
+              constructor
+              · exact by
+                  intro _
+                  exact k9t4_cover32
+              · intro q
+                fin_cases q
+                · exact by
+                    intro _
+                    exact k9t4_cover33
+                · exact by
+                    intro _
+                    exact k9t4_cover34
+          · exact by
+              constructor
+              · exact by
+                  intro _
+                  exact k9t4_cover35
+              · intro q
+                fin_cases q
+                · exact by
+                    intro _
+                    exact k9t4_cover36
+          · exact by
+              constructor
+              · exact by
+                  intro _
+                  exact k9t4_cover37
+              · intro q
+                exact Fin.elim0 q
+    · exact by
+        constructor
+        · exact by
+            intro _
+            exact k9t4_cover38
+        · intro q
+          fin_cases q
+          · exact by
+              constructor
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+              · intro q
+                fin_cases q
+                · exact by
+                    intro h
+                    exact False.elim ((by decide : ¬ (LexLE [] [2, 1, 1] ∧ LexLE [2, 1, 1] [1, 1, 2])) h)
+                · exact by
+                    intro _
+                    exact k9t4_cover41
+          · exact by
+              constructor
+              · exact by
+                  intro _
+                  exact k9t4_cover42
+              · intro q
+                fin_cases q
+                · exact by
+                    intro h
+                    exact False.elim ((by decide : ¬ (LexLE [] [2, 2, 1] ∧ LexLE [2, 2, 1] [1, 2, 2])) h)
+          · exact by
+              constructor
+              · exact by
+                  intro _
+                  exact k9t4_cover43
+              · intro q
+                exact Fin.elim0 q
+    · exact by
+        constructor
+        · exact by
+            intro _
+            exact k9t4_cover44
+        · intro q
+          fin_cases q
+          · exact by
+              constructor
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [3, 1] ∧ LexLE [3, 1] [1, 3])) h)
+              · intro q
+                fin_cases q
+                · exact by
+                    intro h
+                    exact False.elim ((by decide : ¬ (LexLE [] [3, 1, 1] ∧ LexLE [3, 1, 1] [1, 1, 3])) h)
+          · exact by
+              constructor
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [3, 2] ∧ LexLE [3, 2] [2, 3])) h)
+              · intro q
+                exact Fin.elim0 q
+    · exact by
+        constructor
+        · exact by
+            intro _
+            exact k9t4_cover45
+        · intro q
+          fin_cases q
+          · exact by
+              constructor
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [4, 1] ∧ LexLE [4, 1] [1, 4])) h)
+              · intro q
+                exact Fin.elim0 q
+    · exact by
+        constructor
+        · exact by
+            intro _
+            exact k9t4_cover46
+        · intro q
+          exact Fin.elim0 q
+
+private theorem k9t4_cover1 : ∀ P ∈ pathPatterns 4 5 [], HasCheckedCertificate 9 4 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact k9t4_seq2
+
+
+theorem coverage_k9_t4 :
+    ∀ P ∈ pathPatterns 4 5, HasCheckedCertificate 9 4 P :=
+  k9t4_cover1
+
+private theorem k9t5_cover6 : ∀ P ∈ pathPatterns 0 4 [], HasCheckedCertificate 9 5 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p0, Certificates.k9t5p0_check⟩
+
+private theorem k9t5_cover5 : ∀ P ∈ pathPatterns 1 4 [], HasCheckedCertificate 9 5 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k9t5_cover6
+
+private theorem k9t5_cover7 : ∀ P ∈ pathPatterns 0 3 [1], HasCheckedCertificate 9 5 ([[], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p1, Certificates.k9t5p1_check⟩
+
+private theorem k9t5_cover8 : ∀ P ∈ pathPatterns 0 2 [2], HasCheckedCertificate 9 5 ([[], [], [], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p2, Certificates.k9t5p2_check⟩
+
+private theorem k9t5_cover9 : ∀ P ∈ pathPatterns 0 1 [3], HasCheckedCertificate 9 5 ([[], [], [], [3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p3, Certificates.k9t5p3_check⟩
+
+private theorem k9t5_cover10 : ∀ P ∈ pathPatterns 0 0 [4], HasCheckedCertificate 9 5 ([[], [], [], [4]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p4, Certificates.k9t5p4_check⟩
+
+private theorem k9t5_cover4 : ∀ P ∈ pathPatterns 2 4 [], HasCheckedCertificate 9 5 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t5_cover5
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k9t5_cover7
+        · exact by
+            intro _
+            exact k9t5_cover8
+        · exact by
+            intro _
+            exact k9t5_cover9
+        · exact by
+            intro _
+            exact k9t5_cover10
+
+private theorem k9t5_cover11 : ∀ P ∈ pathPatterns 1 3 [1], HasCheckedCertificate 9 5 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover12 : ∀ P ∈ pathPatterns 0 2 [1, 1], HasCheckedCertificate 9 5 ([[], [], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p5, Certificates.k9t5p5_check⟩
+
+private theorem k9t5_cover13 : ∀ P ∈ pathPatterns 0 1 [1, 2], HasCheckedCertificate 9 5 ([[], [], [1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p6, Certificates.k9t5p6_check⟩
+
+private theorem k9t5_cover14 : ∀ P ∈ pathPatterns 0 0 [1, 3], HasCheckedCertificate 9 5 ([[], [], [1, 3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p7, Certificates.k9t5p7_check⟩
+
+private theorem k9t5_cover15 : ∀ P ∈ pathPatterns 1 2 [2], HasCheckedCertificate 9 5 ([[], [], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover16 : ∀ P ∈ pathPatterns 0 0 [2, 2], HasCheckedCertificate 9 5 ([[], [], [2, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p8, Certificates.k9t5p8_check⟩
+
+private theorem k9t5_cover17 : ∀ P ∈ pathPatterns 1 1 [3], HasCheckedCertificate 9 5 ([[], [], [3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover18 : ∀ P ∈ pathPatterns 1 0 [4], HasCheckedCertificate 9 5 ([[], [], [4]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [4] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover3 : ∀ P ∈ pathPatterns 3 4 [], HasCheckedCertificate 9 5 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t5_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover11
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k9t5_cover12
+              · exact by
+                  intro _
+                  exact k9t5_cover13
+              · exact by
+                  intro _
+                  exact k9t5_cover14
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover15
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+              · exact by
+                  intro _
+                  exact k9t5_cover16
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover17
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [3, 1] ∧ LexLE [3, 1] [1, 3])) h)
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover18
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t5_cover20 : ∀ P ∈ pathPatterns 0 2 [1], HasCheckedCertificate 9 5 ([[], [1], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p9, Certificates.k9t5p9_check⟩
+
+private theorem k9t5_cover21 : ∀ P ∈ pathPatterns 0 1 [2], HasCheckedCertificate 9 5 ([[], [1], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p10, Certificates.k9t5p10_check⟩
+
+private theorem k9t5_cover22 : ∀ P ∈ pathPatterns 0 0 [3], HasCheckedCertificate 9 5 ([[], [1], [3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p11, Certificates.k9t5p11_check⟩
+
+private theorem k9t5_cover19 : ∀ P ∈ pathPatterns 2 3 [1], HasCheckedCertificate 9 5 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k9t5_cover20
+        · exact by
+            intro _
+            exact k9t5_cover21
+        · exact by
+            intro _
+            exact k9t5_cover22
+
+private theorem k9t5_cover23 : ∀ P ∈ pathPatterns 1 2 [1, 1], HasCheckedCertificate 9 5 ([[], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover24 : ∀ P ∈ pathPatterns 0 1 [1, 1, 1], HasCheckedCertificate 9 5 ([[], [1, 1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p12, Certificates.k9t5p12_check⟩
+
+private theorem k9t5_cover25 : ∀ P ∈ pathPatterns 0 0 [1, 1, 2], HasCheckedCertificate 9 5 ([[], [1, 1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p13, Certificates.k9t5p13_check⟩
+
+private theorem k9t5_cover26 : ∀ P ∈ pathPatterns 1 1 [1, 2], HasCheckedCertificate 9 5 ([[], [1, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover27 : ∀ P ∈ pathPatterns 0 0 [1, 2, 1], HasCheckedCertificate 9 5 ([[], [1, 2, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p14, Certificates.k9t5p14_check⟩
+
+private theorem k9t5_cover28 : ∀ P ∈ pathPatterns 1 0 [1, 3], HasCheckedCertificate 9 5 ([[], [1, 3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 3] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover30 : ∀ P ∈ pathPatterns 0 0 [2], HasCheckedCertificate 9 5 ([[], [2], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p15, Certificates.k9t5p15_check⟩
+
+private theorem k9t5_cover29 : ∀ P ∈ pathPatterns 2 2 [2], HasCheckedCertificate 9 5 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [2] [1] ∧ LexLE [1] [1])) h)
+        · exact by
+            intro _
+            exact k9t5_cover30
+
+private theorem k9t5_cover31 : ∀ P ∈ pathPatterns 1 0 [2, 2], HasCheckedCertificate 9 5 ([[], [2, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2, 2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover32 : ∀ P ∈ pathPatterns 2 1 [3], HasCheckedCertificate 9 5 ([[], [3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [3] [1] ∧ LexLE [1] [1])) h)
+
+private theorem k9t5_cover33 : ∀ P ∈ pathPatterns 2 0 [4], HasCheckedCertificate 9 5 ([[], [4]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [4] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t5_cover2 : ∀ P ∈ pathPatterns 4 4 [], HasCheckedCertificate 9 5 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t5_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover19
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t5_cover23
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        intro _
+                        exact k9t5_cover24
+                    · exact by
+                        intro _
+                        exact k9t5_cover25
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t5_cover26
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        intro _
+                        exact k9t5_cover27
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t5_cover28
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover29
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro h
+                      exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        intro h
+                        exact False.elim ((by decide : ¬ (LexLE [] [2, 1, 1] ∧ LexLE [2, 1, 1] [1, 1, 2])) h)
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t5_cover31
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover32
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro h
+                      exact False.elim ((by decide : ¬ (LexLE [] [3, 1] ∧ LexLE [3, 1] [1, 3])) h)
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover33
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t5_cover35 : ∀ P ∈ pathPatterns 1 2 [1], HasCheckedCertificate 9 5 ([[1], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover36 : ∀ P ∈ pathPatterns 0 1 [1, 1], HasCheckedCertificate 9 5 ([[1], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p16, Certificates.k9t5p16_check⟩
+
+private theorem k9t5_cover37 : ∀ P ∈ pathPatterns 0 0 [1, 2], HasCheckedCertificate 9 5 ([[1], [1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p17, Certificates.k9t5p17_check⟩
+
+private theorem k9t5_cover38 : ∀ P ∈ pathPatterns 1 1 [2], HasCheckedCertificate 9 5 ([[1], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover39 : ∀ P ∈ pathPatterns 1 0 [3], HasCheckedCertificate 9 5 ([[1], [3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover34 : ∀ P ∈ pathPatterns 3 3 [1], HasCheckedCertificate 9 5 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover35
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k9t5_cover36
+              · exact by
+                  intro _
+                  exact k9t5_cover37
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover38
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [1] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover39
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t5_cover41 : ∀ P ∈ pathPatterns 0 0 [2], HasCheckedCertificate 9 5 ([[1, 1], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p18, Certificates.k9t5p18_check⟩
+
+private theorem k9t5_cover40 : ∀ P ∈ pathPatterns 2 2 [1, 1], HasCheckedCertificate 9 5 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [1, 1] [1] ∧ LexLE [1] [1])) h)
+        · exact by
+            intro _
+            exact k9t5_cover41
+
+private theorem k9t5_cover42 : ∀ P ∈ pathPatterns 1 1 [1, 1, 1], HasCheckedCertificate 9 5 ([[1, 1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover43 : ∀ P ∈ pathPatterns 0 0 [1, 1, 1, 1], HasCheckedCertificate 9 5 ([[1, 1, 1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t5p19, Certificates.k9t5p19_check⟩
+
+private theorem k9t5_cover44 : ∀ P ∈ pathPatterns 1 0 [1, 1, 2], HasCheckedCertificate 9 5 ([[1, 1, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1, 2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover45 : ∀ P ∈ pathPatterns 2 1 [1, 2], HasCheckedCertificate 9 5 ([[1, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 2] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [1, 2] [1] ∧ LexLE [1] [1])) h)
+
+private theorem k9t5_cover46 : ∀ P ∈ pathPatterns 1 0 [1, 2, 1], HasCheckedCertificate 9 5 ([[1, 2, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 2, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover47 : ∀ P ∈ pathPatterns 2 0 [1, 3], HasCheckedCertificate 9 5 ([[1, 3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 3] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t5_cover49 : ∀ P ∈ pathPatterns 1 0 [2], HasCheckedCertificate 9 5 ([[2], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t5_cover48 : ∀ P ∈ pathPatterns 3 2 [2], HasCheckedCertificate 9 5 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro h
+                exact False.elim ((by decide : ¬ (LexLE [2] [1] ∧ LexLE [1] [1])) h)
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [2] [1, 1] ∧ LexLE [1, 1] [1, 1])) h)
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover49
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t5_cover50 : ∀ P ∈ pathPatterns 2 0 [2, 2], HasCheckedCertificate 9 5 ([[2, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2, 2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t5_cover51 : ∀ P ∈ pathPatterns 3 1 [3], HasCheckedCertificate 9 5 ([[3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro h
+                exact False.elim ((by decide : ¬ (LexLE [3] [1] ∧ LexLE [1] [1])) h)
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t5_cover52 : ∀ P ∈ pathPatterns 3 0 [4], HasCheckedCertificate 9 5 ([[4]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [4] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t5_cover1 : ∀ P ∈ pathPatterns 5 4 [], HasCheckedCertificate 9 5 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t5_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover34
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t5_cover40
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        constructor
+                        · exact by
+                            intro _
+                            exact k9t5_cover42
+                        · intro q
+                          fin_cases q
+                          · exact by
+                              intro _
+                              exact k9t5_cover43
+                    · exact by
+                        constructor
+                        · exact by
+                            intro _
+                            exact k9t5_cover44
+                        · intro q
+                          exact Fin.elim0 q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t5_cover45
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        constructor
+                        · exact by
+                            intro _
+                            exact k9t5_cover46
+                        · intro q
+                          exact Fin.elim0 q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t5_cover47
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover48
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro h
+                      exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        constructor
+                        · exact by
+                            intro h
+                            exact False.elim ((by decide : ¬ (LexLE [] [2, 1, 1] ∧ LexLE [2, 1, 1] [1, 1, 2])) h)
+                        · intro q
+                          exact Fin.elim0 q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t5_cover50
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover51
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro h
+                      exact False.elim ((by decide : ¬ (LexLE [] [3, 1] ∧ LexLE [3, 1] [1, 3])) h)
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t5_cover52
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k9_t5 :
+    ∀ P ∈ pathPatterns 5 4, HasCheckedCertificate 9 5 P :=
+  k9t5_cover1
+
+private theorem k9t6_cover7 : ∀ P ∈ pathPatterns 0 3 [], HasCheckedCertificate 9 6 ([[], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t6p0, Certificates.k9t6p0_check⟩
+
+private theorem k9t6_cover6 : ∀ P ∈ pathPatterns 1 3 [], HasCheckedCertificate 9 6 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k9t6_cover7
+
+private theorem k9t6_cover8 : ∀ P ∈ pathPatterns 0 2 [1], HasCheckedCertificate 9 6 ([[], [], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t6p1, Certificates.k9t6p1_check⟩
+
+private theorem k9t6_cover9 : ∀ P ∈ pathPatterns 0 1 [2], HasCheckedCertificate 9 6 ([[], [], [], [], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t6p2, Certificates.k9t6p2_check⟩
+
+private theorem k9t6_cover10 : ∀ P ∈ pathPatterns 0 0 [3], HasCheckedCertificate 9 6 ([[], [], [], [], [3]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t6p3, Certificates.k9t6p3_check⟩
+
+private theorem k9t6_cover5 : ∀ P ∈ pathPatterns 2 3 [], HasCheckedCertificate 9 6 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t6_cover6
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k9t6_cover8
+        · exact by
+            intro _
+            exact k9t6_cover9
+        · exact by
+            intro _
+            exact k9t6_cover10
+
+private theorem k9t6_cover11 : ∀ P ∈ pathPatterns 1 2 [1], HasCheckedCertificate 9 6 ([[], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t6_cover12 : ∀ P ∈ pathPatterns 0 1 [1, 1], HasCheckedCertificate 9 6 ([[], [], [], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t6p4, Certificates.k9t6p4_check⟩
+
+private theorem k9t6_cover13 : ∀ P ∈ pathPatterns 0 0 [1, 2], HasCheckedCertificate 9 6 ([[], [], [], [1, 2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t6p5, Certificates.k9t6p5_check⟩
+
+private theorem k9t6_cover14 : ∀ P ∈ pathPatterns 1 1 [2], HasCheckedCertificate 9 6 ([[], [], [], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t6_cover15 : ∀ P ∈ pathPatterns 1 0 [3], HasCheckedCertificate 9 6 ([[], [], [], [3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+
+private theorem k9t6_cover4 : ∀ P ∈ pathPatterns 3 3 [], HasCheckedCertificate 9 6 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t6_cover5
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover11
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k9t6_cover12
+              · exact by
+                  intro _
+                  exact k9t6_cover13
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover14
+            · intro q
+              fin_cases q
+              · exact by
+                  intro h
+                  exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover15
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t6_cover17 : ∀ P ∈ pathPatterns 0 1 [1], HasCheckedCertificate 9 6 ([[], [], [1], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t6p6, Certificates.k9t6p6_check⟩
+
+private theorem k9t6_cover18 : ∀ P ∈ pathPatterns 0 0 [2], HasCheckedCertificate 9 6 ([[], [], [1], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t6p7, Certificates.k9t6p7_check⟩
+
+private theorem k9t6_cover16 : ∀ P ∈ pathPatterns 2 2 [1], HasCheckedCertificate 9 6 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k9t6_cover17
+        · exact by
+            intro _
+            exact k9t6_cover18
+
+private theorem k9t6_cover19 : ∀ P ∈ pathPatterns 1 1 [1, 1], HasCheckedCertificate 9 6 ([[], [], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t6_cover20 : ∀ P ∈ pathPatterns 0 0 [1, 1, 1], HasCheckedCertificate 9 6 ([[], [], [1, 1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t6p8, Certificates.k9t6p8_check⟩
+
+private theorem k9t6_cover21 : ∀ P ∈ pathPatterns 1 0 [1, 2], HasCheckedCertificate 9 6 ([[], [], [1, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t6_cover22 : ∀ P ∈ pathPatterns 2 1 [2], HasCheckedCertificate 9 6 ([[], [], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [2] [1] ∧ LexLE [1] [1])) h)
+
+private theorem k9t6_cover23 : ∀ P ∈ pathPatterns 2 0 [3], HasCheckedCertificate 9 6 ([[], [], [3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t6_cover3 : ∀ P ∈ pathPatterns 4 3 [], HasCheckedCertificate 9 6 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t6_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover16
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t6_cover19
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        intro _
+                        exact k9t6_cover20
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t6_cover21
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover22
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro h
+                      exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover23
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t6_cover25 : ∀ P ∈ pathPatterns 1 1 [1], HasCheckedCertificate 9 6 ([[], [1], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t6_cover26 : ∀ P ∈ pathPatterns 0 0 [1, 1], HasCheckedCertificate 9 6 ([[], [1], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t6p9, Certificates.k9t6p9_check⟩
+
+private theorem k9t6_cover27 : ∀ P ∈ pathPatterns 1 0 [2], HasCheckedCertificate 9 6 ([[], [1], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t6_cover24 : ∀ P ∈ pathPatterns 3 2 [1], HasCheckedCertificate 9 6 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover25
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k9t6_cover26
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover27
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t6_cover28 : ∀ P ∈ pathPatterns 2 1 [1, 1], HasCheckedCertificate 9 6 ([[], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro h
+            exact False.elim ((by decide : ¬ (LexLE [1, 1] [1] ∧ LexLE [1] [1])) h)
+
+private theorem k9t6_cover29 : ∀ P ∈ pathPatterns 1 0 [1, 1, 1], HasCheckedCertificate 9 6 ([[], [1, 1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t6_cover30 : ∀ P ∈ pathPatterns 2 0 [1, 2], HasCheckedCertificate 9 6 ([[], [1, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t6_cover31 : ∀ P ∈ pathPatterns 3 1 [2], HasCheckedCertificate 9 6 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro h
+                exact False.elim ((by decide : ¬ (LexLE [2] [1] ∧ LexLE [1] [1])) h)
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t6_cover32 : ∀ P ∈ pathPatterns 3 0 [3], HasCheckedCertificate 9 6 ([[], [3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t6_cover2 : ∀ P ∈ pathPatterns 5 3 [], HasCheckedCertificate 9 6 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t6_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover24
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t6_cover28
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        constructor
+                        · exact by
+                            intro _
+                            exact k9t6_cover29
+                        · intro q
+                          exact Fin.elim0 q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t6_cover30
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover31
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro h
+                      exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover32
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t6_cover35 : ∀ P ∈ pathPatterns 0 0 [1], HasCheckedCertificate 9 6 ([[1], [1], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t6p10, Certificates.k9t6p10_check⟩
+
+private theorem k9t6_cover34 : ∀ P ∈ pathPatterns 2 1 [1], HasCheckedCertificate 9 6 ([[1], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k9t6_cover35
+
+private theorem k9t6_cover36 : ∀ P ∈ pathPatterns 1 0 [1, 1], HasCheckedCertificate 9 6 ([[1], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t6_cover37 : ∀ P ∈ pathPatterns 2 0 [2], HasCheckedCertificate 9 6 ([[1], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t6_cover33 : ∀ P ∈ pathPatterns 4 2 [1], HasCheckedCertificate 9 6 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover34
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t6_cover36
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover37
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t6_cover38 : ∀ P ∈ pathPatterns 3 1 [1, 1], HasCheckedCertificate 9 6 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro h
+                exact False.elim ((by decide : ¬ (LexLE [1, 1] [1] ∧ LexLE [1] [1])) h)
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t6_cover39 : ∀ P ∈ pathPatterns 2 0 [1, 1, 1], HasCheckedCertificate 9 6 ([[1, 1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 1, 1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t6_cover40 : ∀ P ∈ pathPatterns 3 0 [1, 2], HasCheckedCertificate 9 6 ([[1, 2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t6_cover41 : ∀ P ∈ pathPatterns 4 1 [2], HasCheckedCertificate 9 6 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro h
+                exact False.elim ((by decide : ¬ (LexLE [2] [1] ∧ LexLE [1] [1])) h)
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t6_cover42 : ∀ P ∈ pathPatterns 4 0 [3], HasCheckedCertificate 9 6 ([[3]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [3] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t6_cover1 : ∀ P ∈ pathPatterns 6 3 [], HasCheckedCertificate 9 6 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t6_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover33
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t6_cover38
+                  · intro q
+                    fin_cases q
+                    · exact by
+                        constructor
+                        · exact by
+                            intro _
+                            exact k9t6_cover39
+                        · intro q
+                          exact Fin.elim0 q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t6_cover40
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover41
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro h
+                      exact False.elim ((by decide : ¬ (LexLE [] [2, 1] ∧ LexLE [2, 1] [1, 2])) h)
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t6_cover42
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k9_t6 :
+    ∀ P ∈ pathPatterns 6 3, HasCheckedCertificate 9 6 P :=
+  k9t6_cover1
+
+private theorem k9t7_cover8 : ∀ P ∈ pathPatterns 0 2 [], HasCheckedCertificate 9 7 ([[], [], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t7p0, Certificates.k9t7p0_check⟩
+
+private theorem k9t7_cover7 : ∀ P ∈ pathPatterns 1 2 [], HasCheckedCertificate 9 7 ([[], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k9t7_cover8
+
+private theorem k9t7_cover9 : ∀ P ∈ pathPatterns 0 1 [1], HasCheckedCertificate 9 7 ([[], [], [], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t7p1, Certificates.k9t7p1_check⟩
+
+private theorem k9t7_cover10 : ∀ P ∈ pathPatterns 0 0 [2], HasCheckedCertificate 9 7 ([[], [], [], [], [], [2]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t7p2, Certificates.k9t7p2_check⟩
+
+private theorem k9t7_cover6 : ∀ P ∈ pathPatterns 2 2 [], HasCheckedCertificate 9 7 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t7_cover7
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k9t7_cover9
+        · exact by
+            intro _
+            exact k9t7_cover10
+
+private theorem k9t7_cover11 : ∀ P ∈ pathPatterns 1 1 [1], HasCheckedCertificate 9 7 ([[], [], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t7_cover12 : ∀ P ∈ pathPatterns 0 0 [1, 1], HasCheckedCertificate 9 7 ([[], [], [], [], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t7p3, Certificates.k9t7p3_check⟩
+
+private theorem k9t7_cover13 : ∀ P ∈ pathPatterns 1 0 [2], HasCheckedCertificate 9 7 ([[], [], [], [], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+
+private theorem k9t7_cover5 : ∀ P ∈ pathPatterns 3 2 [], HasCheckedCertificate 9 7 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t7_cover6
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover11
+            · intro q
+              fin_cases q
+              · exact by
+                  intro _
+                  exact k9t7_cover12
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover13
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t7_cover15 : ∀ P ∈ pathPatterns 0 0 [1], HasCheckedCertificate 9 7 ([[], [], [], [1], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t7p4, Certificates.k9t7p4_check⟩
+
+private theorem k9t7_cover14 : ∀ P ∈ pathPatterns 2 1 [1], HasCheckedCertificate 9 7 ([[], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k9t7_cover15
+
+private theorem k9t7_cover16 : ∀ P ∈ pathPatterns 1 0 [1, 1], HasCheckedCertificate 9 7 ([[], [], [], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t7_cover17 : ∀ P ∈ pathPatterns 2 0 [2], HasCheckedCertificate 9 7 ([[], [], [], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t7_cover4 : ∀ P ∈ pathPatterns 4 2 [], HasCheckedCertificate 9 7 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t7_cover5
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover14
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t7_cover16
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover17
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t7_cover19 : ∀ P ∈ pathPatterns 1 0 [1], HasCheckedCertificate 9 7 ([[], [], [1], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t7_cover18 : ∀ P ∈ pathPatterns 3 1 [1], HasCheckedCertificate 9 7 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover19
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t7_cover20 : ∀ P ∈ pathPatterns 2 0 [1, 1], HasCheckedCertificate 9 7 ([[], [], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t7_cover21 : ∀ P ∈ pathPatterns 3 0 [2], HasCheckedCertificate 9 7 ([[], [], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t7_cover3 : ∀ P ∈ pathPatterns 5 2 [], HasCheckedCertificate 9 7 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t7_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover18
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t7_cover20
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover21
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t7_cover23 : ∀ P ∈ pathPatterns 2 0 [1], HasCheckedCertificate 9 7 ([[], [1], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t7_cover22 : ∀ P ∈ pathPatterns 4 1 [1], HasCheckedCertificate 9 7 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover23
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t7_cover24 : ∀ P ∈ pathPatterns 3 0 [1, 1], HasCheckedCertificate 9 7 ([[], [1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t7_cover25 : ∀ P ∈ pathPatterns 4 0 [2], HasCheckedCertificate 9 7 ([[], [2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t7_cover2 : ∀ P ∈ pathPatterns 6 2 [], HasCheckedCertificate 9 7 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t7_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover22
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t7_cover24
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover25
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t7_cover27 : ∀ P ∈ pathPatterns 3 0 [1], HasCheckedCertificate 9 7 ([[1], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t7_cover26 : ∀ P ∈ pathPatterns 5 1 [1], HasCheckedCertificate 9 7 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover27
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t7_cover28 : ∀ P ∈ pathPatterns 4 0 [1, 1], HasCheckedCertificate 9 7 ([[1, 1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1, 1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t7_cover29 : ∀ P ∈ pathPatterns 5 0 [2], HasCheckedCertificate 9 7 ([[2]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [2] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t7_cover1 : ∀ P ∈ pathPatterns 7 2 [], HasCheckedCertificate 9 7 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t7_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover26
+            · intro q
+              fin_cases q
+              · exact by
+                  constructor
+                  · exact by
+                      intro _
+                      exact k9t7_cover28
+                  · intro q
+                    exact Fin.elim0 q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t7_cover29
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k9_t7 :
+    ∀ P ∈ pathPatterns 7 2, HasCheckedCertificate 9 7 P :=
+  k9t7_cover1
+
+private theorem k9t8_cover9 : ∀ P ∈ pathPatterns 0 1 [], HasCheckedCertificate 9 8 ([[], [], [], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t8p0, Certificates.k9t8p0_check⟩
+
+private theorem k9t8_cover8 : ∀ P ∈ pathPatterns 1 1 [], HasCheckedCertificate 9 8 ([[], [], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro _
+      exact k9t8_cover9
+
+private theorem k9t8_cover10 : ∀ P ∈ pathPatterns 0 0 [1], HasCheckedCertificate 9 8 ([[], [], [], [], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_zero
+  exact ⟨_, Certificates.k9t8p1, Certificates.k9t8p1_check⟩
+
+private theorem k9t8_cover7 : ∀ P ∈ pathPatterns 2 1 [], HasCheckedCertificate 9 8 ([[], [], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t8_cover8
+      · intro q
+        fin_cases q
+        · exact by
+            intro _
+            exact k9t8_cover10
+
+private theorem k9t8_cover11 : ∀ P ∈ pathPatterns 1 0 [1], HasCheckedCertificate 9 8 ([[], [], [], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      intro h
+      exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+
+private theorem k9t8_cover6 : ∀ P ∈ pathPatterns 3 1 [], HasCheckedCertificate 9 8 ([[], [], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t8_cover7
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t8_cover11
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t8_cover12 : ∀ P ∈ pathPatterns 2 0 [1], HasCheckedCertificate 9 8 ([[], [], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t8_cover5 : ∀ P ∈ pathPatterns 4 1 [], HasCheckedCertificate 9 8 ([[], [], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t8_cover6
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t8_cover12
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t8_cover13 : ∀ P ∈ pathPatterns 3 0 [1], HasCheckedCertificate 9 8 ([[], [], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t8_cover4 : ∀ P ∈ pathPatterns 5 1 [], HasCheckedCertificate 9 8 ([[], [], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t8_cover5
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t8_cover13
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t8_cover14 : ∀ P ∈ pathPatterns 4 0 [1], HasCheckedCertificate 9 8 ([[], [], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t8_cover3 : ∀ P ∈ pathPatterns 6 1 [], HasCheckedCertificate 9 8 ([[], []] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t8_cover4
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t8_cover14
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t8_cover15 : ∀ P ∈ pathPatterns 5 0 [1], HasCheckedCertificate 9 8 ([[], [1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t8_cover2 : ∀ P ∈ pathPatterns 7 1 [], HasCheckedCertificate 9 8 ([[]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t8_cover3
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t8_cover15
+            · intro q
+              exact Fin.elim0 q
+
+private theorem k9t8_cover16 : ∀ P ∈ pathPatterns 6 0 [1], HasCheckedCertificate 9 8 ([[1]] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro h
+          exact False.elim ((by decide : ¬ (LexLE [1] [] ∧ LexLE [] [])) h)
+      · intro q
+        exact Fin.elim0 q
+
+private theorem k9t8_cover1 : ∀ P ∈ pathPatterns 8 1 [], HasCheckedCertificate 9 8 ([] ++ P) := by
+  apply pathPatterns_forall_step
+  exact by
+      constructor
+      · exact by
+          intro _
+          exact k9t8_cover2
+      · intro q
+        fin_cases q
+        · exact by
+            constructor
+            · exact by
+                intro _
+                exact k9t8_cover16
+            · intro q
+              exact Fin.elim0 q
+
+theorem coverage_k9_t8 :
+    ∀ P ∈ pathPatterns 8 1, HasCheckedCertificate 9 8 P :=
+  k9t8_cover1
+
+end CycleClique.Construction.CertifiedCoverage
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/CycleTwoPaths.lean

@@ -0,0 +1,109 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.LongestPaths
+
+namespace OAI
+
+/-! Closing two internally disjoint indexed paths into their exact cycle. -/
+
+namespace CycleClique.Construction
+private def twoPathLabel {V : Type*} {a b : ℕ} (_hb : 2 ≤ b)
+    (f : Fin (a + 1) → V) (g : Fin (b + 1) → V) (i : Fin (a + b)) : V :=
+  if hi : i.val ≤ a then f ⟨i.val, by omega⟩ else g ⟨i.val - a, by have := i.isLt; omega⟩
+
+private theorem twoPathLabel_left {V : Type*} {a b : ℕ} (hb : 2 ≤ b)
+    (f : Fin (a + 1) → V) (g : Fin (b + 1) → V) {i : Fin (a + b)}
+    (hi : i.val ≤ a) : twoPathLabel hb f g i = f ⟨i.val, by omega⟩ := by
+  simp only [twoPathLabel, dite_eq_left hi]
+
+private theorem twoPathLabel_right {V : Type*} {a b : ℕ} (hb : 2 ≤ b)
+    (f : Fin (a + 1) → V) (g : Fin (b + 1) → V) {i : Fin (a + b)}
+    (hi : a < i.val) : twoPathLabel hb f g i = g ⟨i.val - a, by have := i.isLt; omega⟩ := by
+  simp only [twoPathLabel, dite_eq_right (by omega : ¬ i.val ≤ a)]
+
+theorem cycle_of_two_indexed_paths {V : Type*} {H : SimpleGraph V} {a b : ℕ}
+    (hb : 2 ≤ b) (f : Fin (a + 1) → V) (g : Fin (b + 1) → V)
+    (hf : IsIndexedPath H f) (hg : IsIndexedPath H g)
+    (hstart : g 0 = f (Fin.last a)) (hend : g (Fin.last b) = f 0)
+    (hdisjoint : ∀ i : Fin (b + 1), 0 < i.val → i.val < b →
+      ∀ j : Fin (a + 1), f j ≠ g i) : HasCycle H (a + b) := by
+  let : NeZero b := ⟨by omega⟩
+  refine ⟨twoPathLabel hb f g, ?_, ?_⟩
+  · intro i j hij
+    apply Fin.ext
+    by_cases hi : i.val ≤ a
+    · by_cases hj : j.val ≤ a
+      · rw [twoPathLabel_left hb f g hi, twoPathLabel_left hb f g hj] at hij
+        exact congrArg (fun x : Fin (a + 1) => x.val) (hf.1 hij)
+      · rw [twoPathLabel_left hb f g hi, twoPathLabel_right hb f g (by omega)] at hij
+        exact False.elim (hdisjoint ⟨j.val - a, by have := j.isLt; omega⟩
+          (by dsimp; omega) (by dsimp; have := j.isLt; omega) _ hij)
+    · by_cases hj : j.val ≤ a
+      · rw [twoPathLabel_right hb f g (by omega), twoPathLabel_left hb f g hj] at hij
+        exact False.elim (hdisjoint ⟨i.val - a, by have := i.isLt; omega⟩
+          (by dsimp; omega) (by dsimp; have := i.isLt; omega) _ hij.symm)
+      · rw [twoPathLabel_right hb f g (by omega), twoPathLabel_right hb f g (by omega)] at hij
+        have hval := congrArg Fin.val (hg.1 hij)
+        dsimp at hval
+        omega
+  · intro i
+    by_cases hlast : i.val + 1 = a + b
+    · have hn : (cycleNext i).val = 0 := by simp [cycleNext, hlast]
+      have hleft : twoPathLabel hb f g i = g ⟨b - 1, by omega⟩ := by
+        rw [twoPathLabel_right hb f g (by omega)]
+        congr 1
+        apply Fin.ext
+        dsimp
+        omega
+      have hright : twoPathLabel hb f g (cycleNext i) = f 0 := by
+        rw [twoPathLabel_left hb f g (by omega)]
+        congr 1
+        apply Fin.ext
+        simpa only [Fin.val_zero] using hn
+      rw [hleft, hright, ← hend]
+      have h := hg.2 ⟨b - 1, by omega⟩
+      have hi : (⟨b - 1, by omega⟩ : Fin b).succ = Fin.last b := by
+        apply Fin.ext
+        change b - 1 + 1 = b
+        omega
+      rw [hi] at h
+      exact h
+    · have hn : (cycleNext i).val = i.val + 1 := Nat.mod_eq_of_lt (by have := i.isLt; omega)
+      by_cases hbefore : i.val < a
+      · let p : Fin a := ⟨i.val, hbefore⟩
+        have hleft : twoPathLabel hb f g i = f p.castSucc := by
+          rw [twoPathLabel_left hb f g (by omega)]
+          rfl
+        have hright : twoPathLabel hb f g (cycleNext i) = f p.succ := by
+          rw [twoPathLabel_left hb f g (by omega)]
+          congr 1
+          exact Fin.ext hn
+        rw [hleft, hright]
+        exact hf.2 p
+      · by_cases heq : i.val = a
+        · have hleft : twoPathLabel hb f g i = f (Fin.last a) := by
+            rw [twoPathLabel_left hb f g (by omega)]
+            congr 1
+            exact Fin.ext heq
+          have hright : twoPathLabel hb f g (cycleNext i) = g (Fin.succ (0 : Fin b)) := by
+            rw [twoPathLabel_right hb f g (by omega)]
+            congr 1
+            apply Fin.ext
+            simp only [Fin.val_succ, Fin.val_zero]
+            omega
+          rw [hleft, hright, ← hstart]
+          exact hg.2 0
+        · let p : Fin b := ⟨i.val - a, by have := i.isLt; omega⟩
+          have hleft : twoPathLabel hb f g i = g p.castSucc := by
+            rw [twoPathLabel_right hb f g (by omega)]
+            rfl
+          have hright : twoPathLabel hb f g (cycleNext i) = g p.succ := by
+            rw [twoPathLabel_right hb f g (by omega)]
+            congr 1
+            apply Fin.ext
+            dsimp [p]
+            omega
+          rw [hleft, hright]
+          exact hg.2 p
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/Definitions.lean

@@ -0,0 +1,62 @@
+import Mathlib.Combinatorics.SimpleGraph.Clique
+import Mathlib.Data.Fintype.EquivFin
+import Mathlib.Tactic
+
+namespace OAI
+
+/-!
+# Exact cycle–clique Ramsey statements
+
+The red edges are the edges of `G`; a blue clique is an independent set
+in `G`. The cycle is a non-induced copy on exactly `m` distinct vertices.
+For the main theorem all cycle lengths are at least three.
+-/
+
+namespace CycleClique.Construction
+variable {V W : Type*}
+
+/-- Cyclic successor, defined also for the empty index type. -/
+def cycleNext {m : ℕ} (i : Fin m) : Fin m :=
+  ⟨(i.val + 1) % m, Nat.mod_lt _ (lt_of_le_of_lt (Nat.zero_le _) i.isLt)⟩
+
+/-- An injectively labelled cycle, including its closing edge. -/
+def HasCycle (G : SimpleGraph V) (m : ℕ) : Prop :=
+  ∃ f : Fin m → V, Function.Injective f ∧ ∀ i, G.Adj (f i) (f (cycleNext i))
+
+/-- An independent set of exactly `n` vertices. -/
+def HasIndependent (G : SimpleGraph V) (n : ℕ) : Prop :=
+  ∃ f : Fin n → V, Function.Injective f ∧ ∀ i j, ¬ G.Adj (f i) (f j)
+
+/-- The red-cycle/blue-clique property at order `N`. -/
+def RamseyProperty (m n N : ℕ) : Prop :=
+  ∀ G : SimpleGraph (Fin N), HasCycle G m ∨ HasIndependent G n
+
+/-- Specifying the least forcing order avoids an existence convention for `sInf`. -/
+def IsRamseyNumber (m n N : ℕ) : Prop :=
+  RamseyProperty m n N ∧ ∀ M < N, ¬ RamseyProperty m n M
+
+theorem HasCycle.map {G : SimpleGraph V} {H : SimpleGraph W} {m : ℕ}
+    (h : HasCycle G m) (f : V → W) (hf : Function.Injective f)
+    (hadj : ∀ {x y}, G.Adj x y → H.Adj (f x) (f y)) : HasCycle H m := by
+  obtain ⟨c, hc, he⟩ := h
+  exact ⟨f ∘ c, hf.comp hc, fun i => hadj (he i)⟩
+
+theorem HasIndependent.map {G : SimpleGraph V} {H : SimpleGraph W} {n : ℕ}
+    (h : HasIndependent G n) (f : V → W) (hf : Function.Injective f)
+    (hadj : ∀ {x y}, H.Adj (f x) (f y) → G.Adj x y) : HasIndependent H n := by
+  obtain ⟨c, hc, he⟩ := h
+  exact ⟨f ∘ c, hf.comp hc, fun i j h => he i j (hadj h)⟩
+
+theorem HasIndependent.card_le [Fintype V] {G : SimpleGraph V} {n : ℕ}
+    (h : HasIndependent G n) : n ≤ Fintype.card V := by
+  obtain ⟨f, hf, _⟩ := h
+  simpa using Fintype.card_le_of_injective f hf
+
+theorem HasCycle.card_le [Fintype V] {G : SimpleGraph V} {m : ℕ}
+    (h : HasCycle G m) : m ≤ Fintype.card V := by
+  obtain ⟨f, hf, _⟩ := h
+  simpa using Fintype.card_le_of_injective f hf
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/DeletedComponent.lean

@@ -0,0 +1,70 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.LongestPaths
+
+namespace OAI
+
+/-! Components after deleting the two common neighbours' endpoints. -/
+
+namespace CycleClique.Construction
+/-- A neighbour of a vertex in a component after deleting `y,z` is
+either one of these two vertices or a neighbour in that component. -/
+theorem deleted_component_neighbor_cover {V : Type*} {H : SimpleGraph V} {y z : V}
+    (C : (H.induce {v | v ≠ y ∧ v ≠ z}).ConnectedComponent)
+    (u : C) {v : V} (h : H.Adj u.val.val v) :
+    v = y ∨ v = z ∨ ∃ w : C, C.toSimpleGraph.Adj u w ∧ w.val.val = v := by
+  by_cases hy : v = y
+  · exact Or.inl hy
+  by_cases hz : v = z
+  · exact Or.inr (Or.inl hz)
+  let w : {v : V | v ≠ y ∧ v ≠ z} := ⟨v, hy, hz⟩
+  have hadj : (H.induce {v | v ≠ y ∧ v ≠ z}).Adj u.val w := h
+  have hw := C.mem_supp_of_adj_mem_supp u.property hadj
+  exact Or.inr (Or.inr ⟨⟨w, hw⟩, hadj, rfl⟩)
+
+theorem deleted_component_degree_loss {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {y z : V}
+    (C : (H.induce {v | v ≠ y ∧ v ≠ z}).ConnectedComponent) (u : C) :
+    (H.neighborSet u.val.val).ncard ≤ (C.toSimpleGraph.neighborSet u).ncard + 2 := by
+  classical
+  let f : C → V := fun v => v.val.val
+  have hf : Function.Injective f := by
+    intro a b h
+    apply Subtype.ext
+    exact Subtype.ext h
+  let N : Finset V := (C.toSimpleGraph.neighborFinset u).map ⟨f, hf⟩
+  have hsub : H.neighborFinset u.val.val ⊆ N ∪ {y, z} := by
+    intro v hv
+    have hadj := (H.mem_neighborFinset u.val.val v).mp hv
+    rcases deleted_component_neighbor_cover C u hadj with rfl | rfl | ⟨w, hw, rfl⟩
+    · simp
+    · simp
+    · exact Finset.mem_union_left _ (Finset.mem_map.mpr
+        ⟨w, (C.toSimpleGraph.mem_neighborFinset u w).mpr hw, rfl⟩)
+  have hcard := (Finset.card_le_card hsub).trans (Finset.card_union_le N {y, z})
+  have hpair : ({y, z} : Finset V).card ≤ 2 := Finset.card_le_two
+  have hN : N.card = (C.toSimpleGraph.neighborFinset u).card := Finset.card_map _
+  rw [hN] at hcard
+  have hdegree : (H.neighborFinset u.val.val).card ≤
+      (C.toSimpleGraph.neighborFinset u).card + 2 := by omega
+  simpa only [SimpleGraph.card_neighborFinset_eq_degree,
+    SimpleGraph.ncard_neighborSet] using hdegree
+
+theorem deleted_component_min_degree {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {y z : V} {s : ℕ}
+    (hdegree : ∀ v, s ≤ (H.neighborSet v).ncard)
+    (C : (H.induce {v | v ≠ y ∧ v ≠ z}).ConnectedComponent) :
+    ∀ u : C, s - 2 ≤ (C.toSimpleGraph.neighborSet u).ncard := by
+  intro u
+  have h := deleted_component_degree_loss C u
+  have h' := hdegree u.val.val
+  omega
+
+theorem deleted_component_cliqueNum_le {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {y z : V}
+    (C : (H.induce {v | v ≠ y ∧ v ≠ z}).ConnectedComponent) :
+    C.toSimpleGraph.cliqueNum ≤ H.cliqueNum := by
+  exact ((H.induce {v | v ≠ y ∧ v ≠ z}).cliqueNum_induce_le C.supp).trans
+    (H.cliqueNum_induce_le _)
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/DeletionOrder.lean

@@ -0,0 +1,83 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.ComponentVertices
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.EndpointAttachment
+
+namespace OAI
+
+/-! A component of the two-vertex deletion is not a clique and has order at least `2s-2`. -/
+
+namespace CycleClique.Construction
+theorem not_clique_of_two_deleted_neighborhoods {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {U : Finset V} {y z : V} {s : ℕ}
+    (hU : U.Nonempty) (hy : y ∉ U) (hno : H.cliqueNum < s)
+    (hdegree : ∀ u ∈ U, s ≤ (H.neighborSet u).ncard)
+    (hcover : ∀ u ∈ U, ∀ v, H.Adj u v → v ∈ U ∨ v = y ∨ v = z) :
+    ¬ H.IsClique (U : Set V) := by
+  classical
+  intro hclique
+  have hUbound := hclique.card_le_cliqueNum
+  have hcover' : ∀ u ∈ U, ∀ v, H.Adj u v → v ∈ (U.erase u) ∪ {y, z} := by
+    intro u hu v huv
+    rcases hcover u hu v huv with hv | rfl | rfl
+    · exact Finset.mem_union_left _ (Finset.mem_erase.mpr ⟨huv.ne.symm, hv⟩)
+    · simp
+    · simp
+  have hcard : ∀ u ∈ U, ((U.erase u) ∪ {y, z}).card ≤ U.card + 1 := by
+    intro u hu
+    have hc := Finset.card_union_le (U.erase u) {y, z}
+    have he := Finset.card_erase_add_one hu
+    have hp : ({y, z} : Finset V).card ≤ 2 := Finset.card_le_two
+    omega
+  obtain ⟨u, hu⟩ := hU
+  have hbound := degree_le_of_neighbor_cover (hcover' u hu)
+  have hc := hcard u hu
+  have hd := hdegree u hu
+  have hsize : U.card + 1 = s := by omega
+  have hadj : ∀ v ∈ U, H.Adj y v := by
+    intro v hv
+    apply SimpleGraph.Adj.symm
+    apply degree_cover_forces_neighbor (hcover' v hv)
+      (show ((U.erase v) ∪ {y, z}).card ≤ (H.neighborSet v).ncard from
+        (hcard v hv).trans (hsize.le.trans (hdegree v hv)))
+    simp
+  have hlarge := clique_extension_size hclique hy hadj
+  omega
+
+theorem two_deleted_component_order {V : Type*} [Fintype V] [DecidableEq V]
+    {H : SimpleGraph V} {U : Finset V} {y z : V} {s : ℕ}
+    (hnotclique : ¬ H.IsClique (U : Set V))
+    (hcover : ∀ u ∈ U, ∀ v, H.Adj u v → v ∈ U ∨ v = y ∨ v = z)
+    (hexpand : ∀ a b, a ≠ b → ¬ H.Adj a b →
+      2 * s ≤ (closedNeighborhood H {a, b}).card) :
+    2 * s - 2 ≤ U.card := by
+  classical
+  have hex : ∃ a ∈ U, ∃ b ∈ U, a ≠ b ∧ ¬ H.Adj a b := by
+    by_contra hn
+    apply hnotclique
+    intro a ha b hb hab
+    by_contra hnab
+    exact hn ⟨a, ha, b, hb, hab, hnab⟩
+  obtain ⟨a, ha, b, hb, hab, hnot⟩ := hex
+  have hsub : closedNeighborhood H {a, b} ⊆ U ∪ {y, z} := by
+    intro v hv
+    rcases mem_closedNeighborhood.mp hv with hv | ⟨w, hw, hwv⟩
+    · simp only [Finset.mem_insert, Finset.mem_singleton] at hv
+      rcases hv with rfl | rfl
+      · exact Finset.mem_union_left _ ha
+      · exact Finset.mem_union_left _ hb
+    · have hwU : w ∈ U := by
+        simp only [Finset.mem_insert, Finset.mem_singleton] at hw
+        rcases hw with rfl | rfl
+        · exact ha
+        · exact hb
+      rcases hcover w hwU v hwv with hv | rfl | rfl
+      · exact Finset.mem_union_left _ hv
+      · simp
+      · simp
+  have hc := (Finset.card_le_card hsub).trans (Finset.card_union_le U {y, z})
+  have hp : ({y, z} : Finset V).card ≤ 2 := Finset.card_le_two
+  have hlow := hexpand a b hab hnot
+  omega
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/DenseLayers.lean

@@ -0,0 +1,101 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.LayerSums
+
+namespace OAI
+
+/-!
+# A dense distance layer
+
+The parity-union expansion and the numerical growth contradiction force
+a dense layer among the first `s` layers. The even case is weakly dense;
+the odd case is strictly dense, as in Proposition `clq:layer-interface`.
+-/
+
+namespace CycleClique.Construction
+theorem exists_dense_distance_layer_even {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {s : ℕ} (hs : 1 ≤ s)
+    (hInd : IndependenceBound G (2 * s))
+    (hexpand : ∀ I : Finset V, G.IsIndepSet (I : Set V) → I.Nonempty →
+      2 * s * I.card + 1 ≤ (closedNeighborhood G I).card) (root : V) :
+    ∃ i, 1 ≤ i ∧ i ≤ s ∧ (distanceLayer G root i).Nonempty ∧
+      s * (G.induce (distanceLayer G root i : Set V)).indepNum ≤
+        (distanceLayer G root i).card := by
+  classical
+  let α := fun j => (G.induce (distanceLayer G root j : Set V)).indepNum
+  let p := alternatingSum α
+  have hzero : α 0 = 1 := distanceLayer_zero_indepNum G root
+  have hpzero : p 0 = 1 := by simpa [p] using hzero
+  have hpbound : p s ≤ 2 * s := by
+    simpa [p, α, alternatingSum, parityIndices] using
+      parity_layer_independence_bound hInd root s
+  have hone := distanceLayer_one_nonempty (by omega : 1 ≤ 2 * s) hexpand root
+  by_contra hn
+  have hsmall : ∀ j, 1 ≤ j → j ≤ s → (distanceLayer G root j).Nonempty →
+      (distanceLayer G root j).card < s * α j := by
+    intro j hj hjs hne
+    by_contra h
+    exact hn ⟨j, hj, hjs, hne, (show s * α j ≤ (distanceLayer G root j).card by omega)⟩
+  apply even_layer_growth_contradiction hs p hpzero hpbound
+  intro i his
+  have hle : ∀ j ∈ Finset.range (i + 1),
+      (distanceLayer G root (j + 1)).card ≤ s * α (j + 1) := by
+    intro j hj
+    by_cases hne : (distanceLayer G root (j + 1)).Nonempty
+    · exact (hsmall (j + 1) (by omega) (by have := Finset.mem_range.mp hj; omega) hne).le
+    · rw [Finset.not_nonempty_iff_eq_empty.mp hne, Finset.card_empty]
+      exact Nat.zero_le _
+  have hsum := Finset.sum_lt_sum hle
+    (show ∃ j ∈ Finset.range (i + 1),
+      (distanceLayer G root (j + 1)).card < s * α (j + 1) from
+      ⟨0, Finset.mem_range.mpr (by omega), by
+        simpa using hsmall 1 (by omega) (by omega) hone⟩)
+  have hpartition := alternatingSum_shifted_partition α hzero (i := i + 1) (by omega)
+  simp only [Nat.add_sub_cancel] at hpartition
+  rw [← Finset.mul_sum, hpartition] at hsum
+  have hexp := distanceLayer_order_sum (by omega : 1 ≤ 2 * s) hexpand root
+    (i := i + 1) (by omega)
+  simp only [Nat.add_sub_cancel] at hexp
+  exact lt_of_le_of_lt hexp hsum
+
+theorem exists_dense_distance_layer_odd {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {s : ℕ} (hs : 2 ≤ s)
+    (hInd : IndependenceBound G (2 * s + 1))
+    (hexpand : ∀ I : Finset V, G.IsIndepSet (I : Set V) → I.Nonempty →
+      (2 * s + 1) * I.card + 1 ≤ (closedNeighborhood G I).card) (root : V) :
+    ∃ i, 1 ≤ i ∧ i ≤ s ∧ (distanceLayer G root i).Nonempty ∧
+      s * (G.induce (distanceLayer G root i : Set V)).indepNum <
+        (distanceLayer G root i).card := by
+  classical
+  let α := fun j => (G.induce (distanceLayer G root j : Set V)).indepNum
+  let p := alternatingSum α
+  have hzero : α 0 = 1 := distanceLayer_zero_indepNum G root
+  have hpzero : p 0 = 1 := by simpa [p] using hzero
+  have hpbound : p s ≤ 2 * s + 1 := by
+    simpa [p, α, alternatingSum, parityIndices] using
+      parity_layer_independence_bound hInd root s
+  by_contra hn
+  have hsmall : ∀ j, 1 ≤ j → j ≤ s → (distanceLayer G root j).Nonempty →
+      (distanceLayer G root j).card ≤ s * α j := by
+    intro j hj hjs hne
+    by_contra h
+    exact hn ⟨j, hj, hjs, hne, (show s * α j < (distanceLayer G root j).card by omega)⟩
+  apply odd_layer_growth_contradiction hs p hpzero hpbound
+  intro i his
+  have hle : ∀ j ∈ Finset.range (i + 1),
+      (distanceLayer G root (j + 1)).card ≤ s * α (j + 1) := by
+    intro j hj
+    by_cases hne : (distanceLayer G root (j + 1)).Nonempty
+    · exact hsmall (j + 1) (by omega) (by have := Finset.mem_range.mp hj; omega) hne
+    · rw [Finset.not_nonempty_iff_eq_empty.mp hne, Finset.card_empty]
+      exact Nat.zero_le _
+  have hsum := Finset.sum_le_sum hle
+  have hpartition := alternatingSum_shifted_partition α hzero (i := i + 1) (by omega)
+  simp only [Nat.add_sub_cancel] at hpartition
+  rw [← Finset.mul_sum, hpartition] at hsum
+  have hexp := distanceLayer_order_sum (by omega : 1 ≤ 2 * s + 1) hexpand root
+    (i := i + 1) (by omega)
+  simp only [Nat.add_sub_cancel] at hexp
+  exact hexp.trans hsum
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/DenseSubgraph.lean

@@ -0,0 +1,139 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.DenseLayers
+
+namespace OAI
+
+/-!
+# The dense layer interface
+
+This assembles the minimum-order choice, connectivity, nonbipartiteness,
+minimum degree, and independent-pair expansion. These are exactly the
+properties used in the path argument in manuscript Section 3.
+-/
+
+namespace CycleClique.Construction
+theorem independent_pair_finset {V : Type*} [DecidableEq V] {G : SimpleGraph V} {x y : V}
+    (hxy : ¬ G.Adj x y) : G.IsIndepSet (({x, y} : Finset V) : Set V) := by
+  classical
+  intro a ha b hb hne hadj
+  simp only [Finset.mem_coe, Finset.mem_insert, Finset.mem_singleton] at ha hb
+  rcases ha with rfl | rfl <;> rcases hb with rfl | rfl
+  · exact hne rfl
+  · exact hxy hadj
+  · exact hxy hadj.symm
+  · exact hne rfl
+
+theorem complete_of_indepNum_le_one {V : Type*} [Fintype V]
+    {G : SimpleGraph V} (hα : G.indepNum ≤ 1) : G = ⊤ := by
+  classical
+  apply SimpleGraph.isClique_univ.mp
+  intro x _ y _ hxy
+  by_contra hn
+  have h := (independent_pair_finset hn).card_le_indepNum
+  simp only [Finset.card_pair hxy] at h
+  omega
+
+theorem dense_indepNum_two {V : Type*} [Fintype V] [Nonempty V]
+    {G : SimpleGraph V} {s : ℕ}
+    (hclique : G.cliqueNum < s) (hdense : s * G.indepNum ≤ Fintype.card V) :
+    2 ≤ G.indepNum := by
+  classical
+  have hpos := indepNum_pos_of_nonempty G
+  by_contra hn
+  have htop := complete_of_indepNum_le_one (G := G) (by omega)
+  have hfull : G.IsClique ((Finset.univ : Finset V) : Set V) := by rw [htop]; simp
+  have hc := hfull.card_le_cliqueNum
+  simp only [Finset.card_univ] at hc
+  have hmul := Nat.mul_le_mul_left s hpos
+  simp only [Nat.mul_one] at hmul
+  omega
+
+/-- Full even-parameter layer interface. -/
+theorem dense_layer_interface_even {V : Type*} [Fintype V] [DecidableEq V]
+    {G : SimpleGraph V} {s : ℕ} (hs : 4 ≤ s)
+    (hclique : G.cliqueNum < s) (hInd : IndependenceBound G (2 * s))
+    (hexpand : ∀ I : Finset V, G.IsIndepSet (I : Set V) → I.Nonempty →
+      2 * s * I.card + 1 ≤ (closedNeighborhood G I).card) (root : V) :
+    ∃ i, 1 ≤ i ∧ i ≤ s ∧ ∃ Y : Finset V,
+      Y ⊆ distanceLayer G root i ∧ Y.Nonempty ∧
+      (G.induce (Y : Set V)).Connected ∧
+      ¬ (G.induce (Y : Set V)).IsBipartite ∧ 2 * s ≤ Y.card ∧
+      (∀ v : Y, s ≤ ((G.induce (Y : Set V)).neighborSet v).ncard) ∧
+      (∀ u v : Y, u ≠ v → ¬ G.Adj u.val v.val →
+        2 * s ≤ (closedNeighborhood (G.induce (Y : Set V)) {u, v}).card) := by
+  classical
+  obtain ⟨i, hi, his, hD, hdense⟩ := exists_dense_distance_layer_even
+    (by omega) hInd hexpand root
+  obtain ⟨Y, hYD, hYne, hYdense, hYmin⟩ := exists_minimal_dense_even _ hD hdense
+  let : Nonempty Y := hYne.to_subtype
+  let H := G.induce (Y : Set V)
+  have hcard : Fintype.card Y = Y.card := Fintype.card_coe _
+  have hdense' : s * H.indepNum ≤ Fintype.card Y := by simpa [hcard] using hYdense
+  have hmin : ∀ Z : Finset Y, Z.Nonempty → Z.card < Fintype.card Y →
+      Z.card < s * (H.induce (Z : Set Y)).indepNum := by
+    simpa only [hcard] using hYmin
+  have hconn := minimal_dense_connected_even hdense' hmin
+  have hnonbip := dense_nonbipartite (by omega) hdense'
+  have hHclique : H.cliqueNum < s := (G.cliqueNum_induce_le _).trans_lt hclique
+  have hα := dense_indepNum_two hHclique hdense'
+  have horder : 2 * s ≤ Fintype.card Y := by nlinarith
+  have hdegree : ∀ v : Y, s ≤ (H.neighborSet v).ncard := by
+    apply dense_expansion_degree (by omega) horder
+    intro v hv
+    have h := (minimal_dense_expansion_even hdense' hmin {v} (by simp) (by simp)).2 hv
+    simpa using h
+  have hpair : ∀ u v : Y, u ≠ v → ¬ G.Adj u.val v.val →
+      2 * s ≤ (closedNeighborhood H {u, v}).card := by
+    intro u v huv hnot
+    have h := (minimal_dense_expansion_even hdense' hmin {u, v}
+      (independent_pair_finset hnot) (by simp)).1
+    simpa only [Finset.card_pair huv, Nat.mul_comm s 2] using h
+  refine ⟨i, hi, his, Y, hYD, hYne, hconn, hnonbip, ?_, hdegree, hpair⟩
+  simpa only [hcard] using horder
+
+/-- Full odd-parameter layer interface. -/
+theorem dense_layer_interface_odd {V : Type*} [Fintype V] [DecidableEq V]
+    {G : SimpleGraph V} {s : ℕ} (hs : 4 ≤ s)
+    (hclique : G.cliqueNum < s) (hInd : IndependenceBound G (2 * s + 1))
+    (hexpand : ∀ I : Finset V, G.IsIndepSet (I : Set V) → I.Nonempty →
+      (2 * s + 1) * I.card + 1 ≤ (closedNeighborhood G I).card) (root : V) :
+    ∃ i, 1 ≤ i ∧ i ≤ s ∧ ∃ Y : Finset V,
+      Y ⊆ distanceLayer G root i ∧ Y.Nonempty ∧
+      (G.induce (Y : Set V)).Connected ∧
+      ¬ (G.induce (Y : Set V)).IsBipartite ∧ 2 * s + 1 ≤ Y.card ∧
+      (∀ v : Y, s ≤ ((G.induce (Y : Set V)).neighborSet v).ncard) ∧
+      (∀ u v : Y, u ≠ v → ¬ G.Adj u.val v.val →
+        2 * s ≤ (closedNeighborhood (G.induce (Y : Set V)) {u, v}).card) := by
+  classical
+  obtain ⟨i, hi, his, hD, hdense⟩ := exists_dense_distance_layer_odd
+    (by omega) hInd hexpand root
+  obtain ⟨Y, hYD, hYne, hYdense, hYmin⟩ := exists_minimal_dense_odd _ hD hdense
+  let : Nonempty Y := hYne.to_subtype
+  let H := G.induce (Y : Set V)
+  have hcard : Fintype.card Y = Y.card := Fintype.card_coe _
+  have hdense' : s * H.indepNum < Fintype.card Y := by simpa [hcard] using hYdense
+  have hmin : ∀ Z : Finset Y, Z.Nonempty → Z.card < Fintype.card Y →
+      Z.card ≤ s * (H.induce (Z : Set Y)).indepNum := by
+    simpa only [hcard] using hYmin
+  have hconn := minimal_dense_connected_odd hdense' hmin
+  have hnonbip := dense_nonbipartite (by omega) hdense'.le
+  have hHclique : H.cliqueNum < s := (G.cliqueNum_induce_le _).trans_lt hclique
+  have hα := dense_indepNum_two hHclique hdense'.le
+  have horder : 2 * s + 1 ≤ Fintype.card Y := by nlinarith
+  have hdegree : ∀ v : Y, s ≤ (H.neighborSet v).ncard := by
+    apply dense_expansion_degree (by omega) (by omega)
+    intro v _
+    have h := minimal_dense_expansion_odd hdense' hmin {v} (by simp) (by simp)
+    simpa using h
+  have hpair : ∀ u v : Y, u ≠ v → ¬ G.Adj u.val v.val →
+      2 * s ≤ (closedNeighborhood H {u, v}).card := by
+    intro u v huv hnot
+    have h := minimal_dense_expansion_odd hdense' hmin {u, v}
+      (independent_pair_finset hnot) (by simp)
+    simp only [Finset.card_pair huv, Nat.mul_comm s 2] at h
+    omega
+  refine ⟨i, hi, his, Y, hYD, hYne, hconn, hnonbip, ?_, hdegree, hpair⟩
+  simpa only [hcard] using horder
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/DistanceLayers.lean

@@ -0,0 +1,125 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.LayerSelection
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.IndependentPacking
+import Mathlib.Combinatorics.SimpleGraph.Metric
+
+namespace OAI
+
+/-!
+# Distance layers and independent parity unions
+
+Distance layers are restricted to the root's connected component.
+Vertices in different layers of the same parity are anticomplete, so
+maximum independent sets chosen there can be combined.
+-/
+
+namespace CycleClique.Construction
+noncomputable def independentOn {V : Type*} [Fintype V]
+    (G : SimpleGraph V) (D : Finset V) : Finset V := by
+  classical
+  exact (Classical.choose (G.induce (D : Set V)).exists_isNIndepSet_indepNum).map
+    ⟨Subtype.val, Subtype.val_injective⟩
+
+theorem independentOn_subset {V : Type*} [Fintype V]
+    (G : SimpleGraph V) (D : Finset V) : independentOn G D ⊆ D := by
+  classical
+  intro x hx
+  obtain ⟨i, _, rfl⟩ := Finset.mem_map.mp hx
+  exact i.property
+
+theorem independentOn_independent {V : Type*} [Fintype V]
+    (G : SimpleGraph V) (D : Finset V) : G.IsIndepSet (independentOn G D : Set V) := by
+  classical
+  intro x hx y hy hxy h
+  obtain ⟨i, hi, rfl⟩ := Finset.mem_map.mp hx
+  obtain ⟨j, hj, rfl⟩ := Finset.mem_map.mp hy
+  exact (Classical.choose_spec (G.induce (D : Set V)).exists_isNIndepSet_indepNum).isIndepSet
+    hi hj (fun h => hxy (congrArg Subtype.val h)) h
+
+theorem independentOn_card {V : Type*} [Fintype V]
+    (G : SimpleGraph V) (D : Finset V) :
+    (independentOn G D).card = (G.induce (D : Set V)).indepNum := by
+  classical
+  rw [independentOn, Finset.card_map]
+  exact (Classical.choose_spec (G.induce (D : Set V)).exists_isNIndepSet_indepNum).card_eq
+
+/-- The exact-distance layer within the root component. -/
+noncomputable def distanceLayer {V : Type*} [Fintype V]
+    (G : SimpleGraph V) (root : V) (j : ℕ) : Finset V := by
+  classical
+  exact Finset.univ.filter fun v => G.Reachable root v ∧ G.dist root v = j
+
+@[simp] theorem mem_distanceLayer {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {root v : V} {j : ℕ} :
+    v ∈ distanceLayer G root j ↔ G.Reachable root v ∧ G.dist root v = j := by
+  classical
+  simp [distanceLayer]
+
+theorem distanceLayer_zero {V : Type*} [Fintype V] (G : SimpleGraph V) (root : V) :
+    distanceLayer G root 0 = {root} := by
+  classical
+  ext v
+  simp only [mem_distanceLayer, Finset.mem_singleton]
+  constructor
+  · rintro ⟨hr, hd⟩
+    rcases G.dist_eq_zero_iff_eq_or_not_reachable.mp hd with h | h
+    · exact h.symm
+    · exact False.elim (h hr)
+  · rintro rfl
+    simp
+
+theorem distanceLayers_disjoint {V : Type*} [Fintype V]
+    (G : SimpleGraph V) (root : V) {i j : ℕ} (hij : i ≠ j) :
+    Disjoint (distanceLayer G root i) (distanceLayer G root j) := by
+  classical
+  apply Finset.disjoint_left.mpr
+  intro v hv hi
+  exact hij ((mem_distanceLayer.mp hv).2.symm.trans (mem_distanceLayer.mp hi).2)
+
+/-- Distinct layers of one parity have no edges between them. -/
+theorem same_parity_layers_anticomplete {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {root : V} {i j : ℕ} (hij : i ≠ j) (hparity : i % 2 = j % 2)
+    {x y : V} (hx : x ∈ distanceLayer G root i) (hy : y ∈ distanceLayer G root j) :
+    ¬ G.Adj x y := by
+  intro h
+  have hdiff := h.diff_dist_adj (u := root)
+  rw [(mem_distanceLayer.mp hx).2, (mem_distanceLayer.mp hy).2] at hdiff
+  omega
+
+/-- Neighbours of a vertex in layer `i` belong to one of the first
+`i + 2` layers. -/
+theorem distanceLayer_neighbor_le {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {root x y : V} {i : ℕ}
+    (hx : x ∈ distanceLayer G root i) (hxy : G.Adj x y) :
+    ∃ j ≤ i + 1, y ∈ distanceLayer G root j := by
+  have hx' := mem_distanceLayer.mp hx
+  refine ⟨G.dist root y, ?_, mem_distanceLayer.mpr ⟨hx'.1.trans hxy.reachable, rfl⟩⟩
+  have hdiff := hxy.diff_dist_adj (u := root)
+  rw [hx'.2] at hdiff
+  omega
+
+/-- Alternating maximum-independent-set sums are at most the ambient
+independence bound. -/
+theorem parity_layer_independence_bound {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {k : ℕ} (hbound : IndependenceBound G k) (root : V) (i : ℕ) :
+    ∑ j ∈ (Finset.range (i + 1)).filter (fun j => j % 2 = i % 2),
+      (G.induce (distanceLayer G root j : Set V)).indepNum ≤ k := by
+  classical
+  let F := (Finset.range (i + 1)).filter (fun j => j % 2 = i % 2)
+  let I := fun j => independentOn G (distanceLayer G root j)
+  have hind : ∀ j ∈ F, G.IsIndepSet (I j : Set V) := fun j _ => independentOn_independent _ _
+  have hdis : (F : Set ℕ).PairwiseDisjoint I := by
+    intro j _ l _ hjl
+    exact (distanceLayers_disjoint G root hjl).mono
+      (independentOn_subset _ _) (independentOn_subset _ _)
+  have hanti : ∀ j ∈ F, ∀ l ∈ F, j ≠ l → ∀ x ∈ I j, ∀ y ∈ I l, ¬ G.Adj x y := by
+    intro j hj l hl hjl x hx y hy
+    apply same_parity_layers_anticomplete hjl
+      (((Finset.mem_filter.mp hj).2).trans (Finset.mem_filter.mp hl).2.symm)
+    · exact independentOn_subset _ _ hx
+    · exact independentOn_subset _ _ hy
+  have h := independent_packing hbound F I hind hdis hanti
+  simpa only [I, independentOn_card] using h
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/EndpointAllowedAttachment.lean

@@ -0,0 +1,75 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.EndpointFullAttachment
+
+namespace OAI
+
+/-! Attachment conclusions restricted to neighbours in the longest path's vertex set. -/
+
+namespace CycleClique.Construction
+theorem endpoint_attachment_vertex_of_prefix_preserved {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {x w v : V} {W : Finset V} {r : ℕ}
+    {f g : Fin (r + 1) → V} (hf : IsSpanningPath H x W f) (t : Fin r)
+    (hfinal : ∀ i : Fin (r + 1), f i ∈ pathEnds H x W r ↔ t.val < i.val)
+    (hg : IsSpanningPath H x W g) (hglast : g (Fin.last r) = w)
+    (hfix : ∀ j : Fin (r + 1), j.val ≤ t.val → g j = f j)
+    (hvW : v ∈ W) (hwv : H.Adj w v) :
+    v ∈ pathEnds H x W r ∨ v = f t.castSucc := by
+  by_cases hv : v ∈ pathEnds H x W r
+  · exact Or.inl hv
+  · right
+    have hvW' : v ∈ (W : Set V) := hvW
+    rw [← hf.2.2.2] at hvW'
+    obtain ⟨j, hjv⟩ := hvW'
+    have hjbefore : j.val ≤ t.val := by
+      by_contra hn
+      exact hv (hjv ▸ (hfinal j).mpr (by omega))
+    by_cases heq : j.val = t.val
+    · have hj : j = t.castSucc := Fin.ext heq
+      exact hjv.symm.trans (congrArg f hj)
+    · let p : Fin r := ⟨j.val, by have := t.isLt; omega⟩
+      have hgp : g p.castSucc = v := (hfix p.castSucc (by dsimp [p]; omega)).trans
+        ((congrArg f (Fin.ext rfl)).trans hjv)
+      have hrot := successor_mem_pathEnds hg p (by rw [hglast, hgp]; exact hwv)
+      rw [hfix p.succ (by dsimp [p]; omega)] at hrot
+      have hbound := (hfinal p.succ).mp hrot
+      dsimp [p] at hbound
+      omega
+
+theorem partial_endpoint_attachment_in_W {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {x w v : V} {W : Finset V} {r : ℕ}
+    {f : Fin (r + 1) → V} (hf : IsSpanningPath H x W f) (t : Fin r)
+    (hfinal : ∀ i : Fin (r + 1), f i ∈ pathEnds H x W r ↔ t.val < i.val)
+    (hclique : H.IsClique (pathEnds H x W r : Set V))
+    (hw : w ∈ pathEnds H x W r) (hne : w ≠ f t.succ)
+    (hvW : v ∈ W) (hwv : H.Adj w v) :
+    v ∈ pathEnds H x W r ∨ v = f t.castSucc := by
+  have hwW : w ∈ (W : Set V) := pathEnds_subset H x W r hw
+  rw [← hf.2.2.2] at hwW
+  obtain ⟨i, hiw⟩ := hwW
+  have hitail : t.val < i.val := (hfinal i).mp (hiw ▸ hw)
+  have hi : t.val + 1 < i.val := by
+    have hneq : i ≠ t.succ := fun h => hne (hiw.symm.trans (congrArg f h))
+    have hval : i.val ≠ t.val + 1 := fun h => hneq (Fin.ext h)
+    omega
+  obtain ⟨g, hg, hlast, hfix⟩ := spanningPath_swap_tail hf t hfinal hclique i hi
+  apply endpoint_attachment_vertex_of_prefix_preserved hf t hfinal hg (hlast.trans hiw)
+    (fun j hj => hfix j (by omega)) hvW hwv
+
+theorem full_endpoint_attachment_in_W {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {x w v : V} {W : Finset V} {r : ℕ}
+    {f : Fin (r + 1) → V} (hf : IsSpanningPath H x W f) (t : Fin r)
+    (hfinal : ∀ i : Fin (r + 1), f i ∈ pathEnds H x W r ↔ t.val < i.val)
+    (hclique : H.IsClique (pathEnds H x W r : Set V))
+    (hsecond : ∃ w ∈ pathEnds H x W r,
+      w ≠ f t.succ ∧ H.Adj (f t.castSucc) w)
+    (hw : w ∈ pathEnds H x W r) (hvW : v ∈ W) (hwv : H.Adj w v) :
+    v ∈ pathEnds H x W r ∨ v = f t.castSucc := by
+  by_cases heq : w = f t.succ
+  · subst w
+    obtain ⟨w₁, hw₁, hne, hadj⟩ := hsecond
+    obtain ⟨g, hg, hlast, hfix⟩ := spanningPath_first_tail_last hf t hfinal hclique hw₁ hne hadj
+    exact endpoint_attachment_vertex_of_prefix_preserved hf t hfinal hg hlast hfix hvW hwv
+  · exact partial_endpoint_attachment_in_W hf t hfinal hclique hw heq hvW hwv
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/EndpointAttachment.lean

@@ -0,0 +1,178 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.EndpointTail
+
+namespace OAI
+
+/-! The degree calculations forcing a second attachment and a common neighbour. -/
+
+namespace CycleClique.Construction
+theorem degree_le_of_neighbor_cover {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {v : V} {S : Finset V}
+    (hcover : ∀ w, H.Adj v w → w ∈ S) : (H.neighborSet v).ncard ≤ S.card := by
+  classical
+  have hsub : H.neighborFinset v ⊆ S := fun w hw =>
+    hcover w ((H.mem_neighborFinset v w).mp hw)
+  simpa only [SimpleGraph.ncard_neighborSet,
+    SimpleGraph.card_neighborFinset_eq_degree] using Finset.card_le_card hsub
+
+theorem degree_cover_forces_neighbor {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {v w : V} {S : Finset V}
+    (hcover : ∀ a, H.Adj v a → a ∈ S)
+    (hdegree : S.card ≤ (H.neighborSet v).ncard) (hw : w ∈ S) : H.Adj v w := by
+  classical
+  have hsub : H.neighborFinset v ⊆ S := fun a ha =>
+    hcover a ((H.mem_neighborFinset v a).mp ha)
+  have hcard : S.card ≤ (H.neighborFinset v).card := by
+    simpa only [SimpleGraph.ncard_neighborSet,
+      SimpleGraph.card_neighborFinset_eq_degree] using hdegree
+  have heq := Finset.eq_of_subset_of_card_le hsub hcard
+  exact (H.mem_neighborFinset v w).mp (heq.symm ▸ hw)
+
+theorem clique_extension_size {V : Type*} [Fintype V] [DecidableEq V]
+    {H : SimpleGraph V} {E : Finset V} {u : V}
+    (hclique : H.IsClique (E : Set V)) (hu : u ∉ E)
+    (hadj : ∀ w ∈ E, H.Adj u w) : E.card + 1 ≤ H.cliqueNum := by
+  have hQ : H.IsClique ((insert u E : Finset V) : Set V) := by
+    rw [Finset.coe_insert]
+    exact hclique.insert (fun w hw _ => hadj w hw)
+  have h := hQ.card_le_cliqueNum
+  simpa only [Finset.card_insert_of_notMem hu] using h
+
+private theorem erased_pair_cover_card {V : Type*} [DecidableEq V]
+    {E : Finset V} {w y z : V} (hw : w ∈ E) :
+    ((E.erase w) ∪ {y, z}).card ≤ E.card + 1 := by
+  have h := Finset.card_union_le (E.erase w) {y, z}
+  have he := Finset.card_erase_add_one hw
+  have hp : ({y, z} : Finset V).card ≤ 2 := Finset.card_le_two
+  omega
+
+/-- The attachment vertex has a second neighbour in the endpoint
+clique; this is the two-case degree calculation in the manuscript. -/
+theorem endpoint_second_attachment {V : Type*} [Fintype V] [DecidableEq V]
+    {H : SimpleGraph V} {E : Finset V} {u w₀ y z : V} {s : ℕ}
+    (hs : 4 ≤ s) (hsize : s - 2 ≤ E.card ∧ E.card ≤ s - 1)
+    (hclique : H.IsClique (E : Set V)) (hno : H.cliqueNum < s)
+    (hy : y ∉ E) (hz : z ∉ E) (hw₀ : w₀ ∈ E)
+    (hdegree : ∀ w ∈ E, s ≤ (H.neighborSet w).ncard)
+    (hpartial : ∀ w ∈ E, w ≠ w₀ → ∀ v, H.Adj w v →
+      v ∈ (E.erase w) ∪ {u, y, z})
+    (hzero : ¬ H.Adj w₀ y → ¬ H.Adj w₀ z → (H.neighborSet w₀).ncard ≤ E.card) :
+    ∃ w ∈ E, w ≠ w₀ ∧ H.Adj u w := by
+  classical
+  by_contra hn
+  have hnotu : ∀ w ∈ E, w ≠ w₀ → ¬ H.Adj w u := by
+    intro w hw hne hwu
+    exact hn ⟨w, hw, hne, hwu.symm⟩
+  have hcover : ∀ w ∈ E, w ≠ w₀ → ∀ v, H.Adj w v →
+      v ∈ (E.erase w) ∪ {y, z} := by
+    intro w hw hne v hwv
+    rcases Finset.mem_union.mp (hpartial w hw hne v hwv) with hv | hv
+    · exact Finset.mem_union_left _ hv
+    · simp only [Finset.mem_insert, Finset.mem_singleton] at hv
+      rcases hv with rfl | rfl | rfl
+      · exact False.elim (hnotu w hw hne hwv)
+      · simp
+      · simp
+  by_cases hsmall : E.card = s - 2
+  · obtain ⟨w, hw, hne⟩ := Finset.exists_mem_ne (by omega : 1 < E.card) w₀
+    have hbound := degree_le_of_neighbor_cover (hcover w hw hne)
+    have hcard := erased_pair_cover_card (y := y) (z := z) hw
+    have hlow := hdegree w hw
+    omega
+  · have hlarge : E.card = s - 1 := by omega
+    have hboth : ∀ w ∈ E, w ≠ w₀ → H.Adj w y ∧ H.Adj w z := by
+      intro w hw hne
+      have hc := erased_pair_cover_card (y := y) (z := z) hw
+      have hd := hdegree w hw
+      have hforce : ∀ a ∈ (E.erase w) ∪ {y, z}, H.Adj w a := fun a ha =>
+        degree_cover_forces_neighbor (hcover w hw hne)
+          (show ((E.erase w) ∪ {y, z}).card ≤ (H.neighborSet w).ncard by omega) ha
+      exact ⟨hforce y (by simp), hforce z (by simp)⟩
+    have hsome : H.Adj w₀ y ∨ H.Adj w₀ z := by
+      by_contra hn
+      have hny : ¬ H.Adj w₀ y := fun h => hn (Or.inl h)
+      have hnz : ¬ H.Adj w₀ z := fun h => hn (Or.inr h)
+      have h := hzero hny hnz
+      have h' := hdegree w₀ hw₀
+      omega
+    rcases hsome with hwy | hwz
+    · have hadj : ∀ w ∈ E, H.Adj y w := by
+        intro w hw
+        by_cases heq : w = w₀
+        · subst w; exact hwy.symm
+        · exact (hboth w hw heq).1.symm
+      have h := clique_extension_size hclique hy hadj
+      omega
+    · have hadj : ∀ w ∈ E, H.Adj z w := by
+        intro w hw
+        by_cases heq : w = w₀
+        · subst w; exact hwz.symm
+        · exact (hboth w hw heq).2.symm
+      have h := clique_extension_size hclique hz hadj
+      omega
+
+/-- Once all endpoints attach only through `u`, one endpoint sees both
+deleted vertices. -/
+theorem endpoint_common_deleted_neighbor {V : Type*} [Fintype V] [DecidableEq V]
+    {H : SimpleGraph V} {E : Finset V} {u y z : V} {s : ℕ}
+    (hs : 4 ≤ s) (hsize : s - 2 ≤ E.card ∧ E.card ≤ s - 1)
+    (hclique : H.IsClique (E : Set V)) (hno : H.cliqueNum < s) (hu : u ∉ E)
+    (hdegree : ∀ w ∈ E, s ≤ (H.neighborSet w).ncard)
+    (hcover : ∀ w ∈ E, ∀ v, H.Adj w v → v ∈ (E.erase w) ∪ {u, y, z}) :
+    ∃ w ∈ E, H.Adj w y ∧ H.Adj w z := by
+  classical
+  by_cases hsmall : E.card = s - 2
+  · obtain ⟨w, hw⟩ := Finset.card_pos.mp (by omega : 0 < E.card)
+    have hc := Finset.card_union_le (E.erase w) {u, y, z}
+    have he := Finset.card_erase_add_one hw
+    have ht : ({u, y, z} : Finset V).card ≤ 3 := Finset.card_le_three
+    have hd := hdegree w hw
+    have hforce : ∀ a ∈ (E.erase w) ∪ {u, y, z}, H.Adj w a := fun a ha =>
+      degree_cover_forces_neighbor (hcover w hw)
+        (show ((E.erase w) ∪ {u, y, z}).card ≤ (H.neighborSet w).ncard by omega) ha
+    exact ⟨w, hw, hforce y (by simp), hforce z (by simp)⟩
+  · have hlarge : E.card = s - 1 := by omega
+    by_contra hn
+    have hadju : ∀ w ∈ E, H.Adj u w := by
+      intro w hw
+      by_contra hnu
+      have hnotu : ¬ H.Adj w u := fun h => hnu h.symm
+      have hpair : ¬ H.Adj w y ∨ ¬ H.Adj w z := by
+        by_cases hwy : H.Adj w y
+        · exact Or.inr (fun hwz => hn ⟨w, hw, hwy, hwz⟩)
+        · exact Or.inl hwy
+      have hbound : (H.neighborSet w).ncard ≤ E.card := by
+        rcases hpair with hny | hnz
+        · have hsub : ∀ v, H.Adj w v → v ∈ insert z (E.erase w) := by
+            intro v hwv
+            rcases Finset.mem_union.mp (hcover w hw v hwv) with hv | hv
+            · exact Finset.mem_insert_of_mem hv
+            · simp only [Finset.mem_insert, Finset.mem_singleton] at hv
+              rcases hv with rfl | rfl | rfl
+              · exact False.elim (hnotu hwv)
+              · exact False.elim (hny hwv)
+              · simp
+          have h := degree_le_of_neighbor_cover hsub
+          have hc := Finset.card_insert_le z (E.erase w)
+          have he := Finset.card_erase_add_one hw
+          omega
+        · have hsub : ∀ v, H.Adj w v → v ∈ insert y (E.erase w) := by
+            intro v hwv
+            rcases Finset.mem_union.mp (hcover w hw v hwv) with hv | hv
+            · exact Finset.mem_insert_of_mem hv
+            · simp only [Finset.mem_insert, Finset.mem_singleton] at hv
+              rcases hv with rfl | rfl | rfl
+              · exact False.elim (hnotu hwv)
+              · simp
+              · exact False.elim (hnz hwv)
+          have h := degree_le_of_neighbor_cover hsub
+          have hc := Finset.card_insert_le y (E.erase w)
+          have he := Finset.card_erase_add_one hw
+          omega
+      have hlow := hdegree w hw
+      omega
+    have h := clique_extension_size hclique hu hadju
+    omega
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/EndpointDegreeCover.lean

@@ -0,0 +1,67 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.RestrictedLongest
+
+namespace OAI
+
+/-! Degree bounds when two deleted vertices are the only neighbours outside the longest path. -/
+
+namespace CycleClique.Construction
+theorem endpoint_neighbor_card_le {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {x e : V} {W S : Finset V} {r : ℕ}
+    (he : e ∈ pathEnds H x W r)
+    (hS : ∀ v ∈ S, H.Adj e v ∧ v ∈ W) : S.card ≤ (pathEnds H x W r).card := by
+  classical
+  obtain ⟨f, hf, hlast⟩ := mem_pathEnds.mp he
+  have hex : ∀ v : S, ∃ i : Fin r, f i.castSucc = v.val := by
+    intro v
+    obtain ⟨hadj, hvW⟩ := hS v.val v.property
+    have hv : v.val ∈ Set.range f := by rw [hf.2.2.2]; exact hvW
+    obtain ⟨j, hj⟩ := hv
+    have hjlt : j.val < r := by
+      have hneq : j ≠ Fin.last r := by
+        intro heq
+        subst j
+        exact hadj.ne (hlast.symm.trans hj)
+      have hval : j.val ≠ r := fun h => hneq (Fin.ext h)
+      omega
+    exact ⟨⟨j.val, hjlt⟩, by simpa using hj⟩
+  let pivot : S → Fin r := fun v => Classical.choose (hex v)
+  have hpivot : ∀ v : S, f (pivot v).castSucc = v.val := fun v => Classical.choose_spec (hex v)
+  let suc : S → pathEnds H x W r := fun v =>
+    ⟨f (pivot v).succ, successor_mem_pathEnds hf (pivot v) (by
+      rw [hlast, hpivot]
+      exact (hS v.val v.property).1)⟩
+  have hinj : Function.Injective suc := by
+    intro a b hab
+    have hfin := hf.1 (congrArg Subtype.val hab)
+    have hp : pivot a = pivot b := Fin.succ_injective r hfin
+    apply Subtype.ext
+    rw [← hpivot a, ← hpivot b, hp]
+  simpa only [Fintype.card_coe] using Fintype.card_le_of_injective suc hinj
+
+theorem endpoint_degree_le_card_add_two {V : Type*} [Fintype V]
+    {H : SimpleGraph V} {x e y z : V} {W : Finset V} {r : ℕ}
+    (he : e ∈ pathEnds H x W r)
+    (hcover : ∀ v, H.Adj e v → v ∈ W ∨ v = y ∨ v = z) :
+    (H.neighborSet e).ncard ≤ (pathEnds H x W r).card + 2 := by
+  classical
+  let S := (H.neighborFinset e).filter fun v => v ∈ W
+  have hS : ∀ v ∈ S, H.Adj e v ∧ v ∈ W := by
+    intro v hv
+    exact ⟨(H.mem_neighborFinset e v).mp (Finset.mem_filter.mp hv).1,
+      (Finset.mem_filter.mp hv).2⟩
+  have hSbound := endpoint_neighbor_card_le he hS
+  have hsub : H.neighborFinset e ⊆ S ∪ {y, z} := by
+    intro v hv
+    rcases hcover v ((H.mem_neighborFinset e v).mp hv) with hvW | rfl | rfl
+    · exact Finset.mem_union_left _ (Finset.mem_filter.mpr ⟨hv, hvW⟩)
+    · simp
+    · simp
+  have hcard := (Finset.card_le_card hsub).trans (Finset.card_union_le S {y, z})
+  have hp : ({y, z} : Finset V).card ≤ 2 := Finset.card_le_two
+  have hdegree : (H.neighborFinset e).card ≤ (pathEnds H x W r).card + 2 := by omega
+  simpa only [SimpleGraph.card_neighborFinset_eq_degree,
+    SimpleGraph.ncard_neighborSet] using hdegree
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/EndpointFullAttachment.lean

@@ -0,0 +1,96 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.EndpointAttachment
+
+namespace OAI
+
+/-! Rotating from a second attachment extends the prefix exclusion to every endpoint. -/
+
+namespace CycleClique.Construction
+theorem spanningPath_first_tail_last {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {x : V} {W : Finset V} {r : ℕ}
+    {f : Fin (r + 1) → V} (hf : IsSpanningPath G x W f) (t : Fin r)
+    (hfinal : ∀ i : Fin (r + 1), f i ∈ pathEnds G x W r ↔ t.val < i.val)
+    (hclique : G.IsClique (pathEnds G x W r : Set V))
+    {w : V} (hw : w ∈ pathEnds G x W r) (hne : w ≠ f t.succ)
+    (hadj : G.Adj (f t.castSucc) w) :
+    ∃ g : Fin (r + 1) → V, IsSpanningPath G x W g ∧
+      g (Fin.last r) = f t.succ ∧
+      ∀ j : Fin (r + 1), j.val ≤ t.val → g j = f j := by
+  have hwW : w ∈ (W : Set V) := pathEnds_subset G x W r hw
+  rw [← hf.2.2.2] at hwW
+  obtain ⟨i, hiw⟩ := hwW
+  have hitail : t.val < i.val := (hfinal i).mp (hiw ▸ hw)
+  have hi : t.val + 1 < i.val := by
+    have hneq : i ≠ t.succ := fun h => hne (hiw.symm.trans (congrArg f h))
+    have hval : i.val ≠ t.val + 1 := fun h => hneq (Fin.ext h)
+    omega
+  obtain ⟨g, hg, hglast, hgfix⟩ := spanningPath_swap_tail hf t hfinal hclique i hi
+  have hrot := rotate_path g hg.1 hg.2.1 t (by
+    rw [hglast, hiw, hgfix t.castSucc (by simp)]
+    exact hadj.symm)
+  refine ⟨g ∘ rotationIndex t, ⟨hrot.1, hrot.2.1,
+    hrot.2.2.1.trans hg.2.2.1, hrot.2.2.2.2.trans hg.2.2.2⟩,
+    hrot.2.2.2.1.trans (hgfix t.succ (by simp)), ?_⟩
+  intro j hj
+  have hidx : rotationIndex t j = j := by
+    apply Fin.ext
+    dsimp [rotationIndex]
+    split_ifs
+    omega
+  change g (rotationIndex t j) = f j
+  rw [hidx]
+  exact hgfix j (by omega)
+
+theorem endpoint_attachment_of_prefix_preserved {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {x w : V} {W : Finset V} {r : ℕ}
+    {f g : Fin (r + 1) → V} (hf : IsSpanningPath G x W f) (t : Fin r)
+    (hfinal : ∀ i : Fin (r + 1), f i ∈ pathEnds G x W r ↔ t.val < i.val)
+    (hg : IsSpanningPath G x W g) (hglast : g (Fin.last r) = w)
+    (hfix : ∀ j : Fin (r + 1), j.val ≤ t.val → g j = f j)
+    (hneighbors : ∀ v, G.Adj w v → v ∈ W) :
+    ∀ v, G.Adj w v → v ∈ pathEnds G x W r ∨ v = f t.castSucc := by
+  intro v hwv
+  by_cases hv : v ∈ pathEnds G x W r
+  · exact Or.inl hv
+  · right
+    have hvW : v ∈ (W : Set V) := hneighbors v hwv
+    rw [← hf.2.2.2] at hvW
+    obtain ⟨j, hjv⟩ := hvW
+    have hjbefore : j.val ≤ t.val := by
+      by_contra hn
+      exact hv (hjv ▸ (hfinal j).mpr (by omega))
+    by_cases heq : j.val = t.val
+    · have hj : j = t.castSucc := Fin.ext heq
+      exact hjv.symm.trans (congrArg f hj)
+    · let p : Fin r := ⟨j.val, by have := t.isLt; omega⟩
+      have hgp : g p.castSucc = v := (hfix p.castSucc (by dsimp [p]; omega)).trans
+        ((congrArg f (Fin.ext rfl)).trans hjv)
+      have hrot := successor_mem_pathEnds hg p (by rw [hglast, hgp]; exact hwv)
+      rw [hfix p.succ (by dsimp [p]; omega)] at hrot
+      have hbound := (hfinal p.succ).mp hrot
+      dsimp [p] at hbound
+      omega
+
+/-- Every endpoint has no neighbour outside the endpoint clique other
+than the one attachment vertex. -/
+theorem full_endpoint_attachment {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {x : V} {W : Finset V} {r : ℕ}
+    {f : Fin (r + 1) → V} (hf : IsSpanningPath G x W f) (t : Fin r)
+    (hfinal : ∀ i : Fin (r + 1), f i ∈ pathEnds G x W r ↔ t.val < i.val)
+    (hclique : G.IsClique (pathEnds G x W r : Set V))
+    (hneighbors : ∀ e ∈ pathEnds G x W r, ∀ v, G.Adj e v → v ∈ W)
+    (hsecond : ∃ w ∈ pathEnds G x W r,
+      w ≠ f t.succ ∧ G.Adj (f t.castSucc) w) :
+    ∀ w ∈ pathEnds G x W r, ∀ v, G.Adj w v →
+      v ∈ pathEnds G x W r ∨ v = f t.castSucc := by
+  intro w hw
+  by_cases heq : w = f t.succ
+  · subst w
+    obtain ⟨w₁, hw₁, hne, hadj⟩ := hsecond
+    obtain ⟨g, hg, hlast, hfix⟩ := spanningPath_first_tail_last hf t hfinal hclique hw₁ hne hadj
+    exact endpoint_attachment_of_prefix_preserved hf t hfinal hg hlast hfix
+      (hneighbors _ hw)
+  · exact partial_endpoint_attachment hf t hfinal hclique hneighbors w hw heq
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/EndpointStructure.lean

@@ -0,0 +1,116 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.EndpointDegreeCover
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.EndpointAllowedAttachment
+
+namespace OAI
+
+/-! Assembling the endpoint clique and its single attachment. -/
+
+namespace CycleClique.Construction
+theorem endpoint_structure {V : Type*} [Fintype V] [DecidableEq V]
+    {H : SimpleGraph V} {U W : Finset V} {x y z : V} {r s : ℕ}
+    (hs : 4 ≤ s) (hno : H.cliqueNum < s)
+    (hdegree : ∀ v, s ≤ (H.neighborSet v).ncard)
+    (hexpand : ∀ a b, a ≠ b → ¬ H.Adj a b →
+      2 * s ≤ (closedNeighborhood H {a, b}).card)
+    (hyU : y ∉ U) (hzU : z ∉ U) (hWU : W ⊆ U)
+    (hcover : ∀ u ∈ U, ∀ v, H.Adj u v → v ∈ U ∨ v = y ∨ v = z)
+    {f : Fin (r + 1) → V} (hf : IsSpanningPath H x W f)
+    (hcard : W.card = r + 1) (hshort : W.card + 2 < 2 * s)
+    (hmax : ∀ q (g : Fin (q + 1) → V), IsIndexedPath H g → g 0 = x →
+      (∀ i, g i ∈ U) → q ≤ r) :
+    let E := pathEnds H x W r
+    H.IsClique (E : Set V) ∧ s - 2 ≤ E.card ∧ E.card ≤ s - 1 ∧
+      ∃ u ∈ U, u ∉ E ∧
+        (∃ a ∈ E, ∃ b ∈ E, a ≠ b ∧ H.Adj a u ∧ H.Adj b u) ∧
+        (∀ e ∈ E, ∀ v, H.Adj e v → v ∈ E ∨ v = u ∨ v = y ∨ v = z) ∧
+        ∃ w ∈ E, H.Adj w y ∧ H.Adj w z := by
+  classical
+  let E := pathEnds H x W r
+  have hEW : E ⊆ W := pathEnds_subset H x W r
+  have hEU : E ⊆ U := hEW.trans hWU
+  have hyE : y ∉ E := fun hy => hyU (hEU hy)
+  have hzE : z ∉ E := fun hz => hzU (hEU hz)
+  have he : f (Fin.last r) ∈ E := mem_pathEnds.mpr ⟨f, hf, rfl⟩
+  have hcoverE : ∀ e ∈ E, ∀ v, H.Adj e v → v ∈ W ∨ v = y ∨ v = z :=
+    restricted_endpoint_neighbor_cover hWU hcover hmax
+  have hclique : H.IsClique (E : Set V) := by
+    apply clique_of_endpoint_neighbor_cover (s := s) hEW
+      (Z := {y, z})
+    · intro e he v hev
+      rcases hcoverE e he v hev with hv | rfl | rfl
+      · exact Finset.mem_union_left _ hv
+      · simp
+      · simp
+    · have hp : ({y, z} : Finset V).card ≤ 2 := Finset.card_le_two
+      omega
+    · exact hexpand
+  have hupper : E.card ≤ s - 1 := by
+    have := hclique.card_le_cliqueNum
+    omega
+  have hlower : s - 2 ≤ E.card := by
+    have hbound := endpoint_degree_le_card_add_two he (hcoverE _ he)
+    change (H.neighborSet (f (Fin.last r))).ncard ≤ E.card + 2 at hbound
+    have hlow := hdegree (f (Fin.last r))
+    omega
+  have hr : 1 ≤ r := by
+    have hbound := Finset.card_le_card hEW
+    omega
+  obtain ⟨t, hfinal⟩ := pathEnds_final_segment hr hf hclique
+  let u := f t.castSucc
+  let w₀ := f t.succ
+  have huU : u ∈ U := by
+    apply hWU
+    change f t.castSucc ∈ (W : Set V)
+    rw [← hf.2.2.2]
+    exact ⟨t.castSucc, rfl⟩
+  have huE : u ∉ E := by
+    intro hu
+    have h := (hfinal t.castSucc).mp hu
+    simp only [Fin.val_castSucc] at h
+    omega
+  have hw₀ : w₀ ∈ E := (hfinal t.succ).mpr (by simp)
+  have huw₀ : H.Adj u w₀ := hf.2.1 t
+  have hpartial : ∀ e ∈ E, e ≠ w₀ → ∀ v, H.Adj e v →
+      v ∈ (E.erase e) ∪ {u, y, z} := by
+    intro e he hne v hev
+    rcases hcoverE e he v hev with hvW | rfl | rfl
+    · rcases partial_endpoint_attachment_in_W hf t hfinal hclique he hne hvW hev with hvE | hveq
+      · exact Finset.mem_union_left _ (Finset.mem_erase.mpr ⟨hev.ne.symm, hvE⟩)
+      · subst v
+        exact Finset.mem_union_right _ (Finset.mem_insert_self _ _)
+    · simp
+    · simp
+  have hzero : ¬ H.Adj w₀ y → ¬ H.Adj w₀ z → (H.neighborSet w₀).ncard ≤ E.card := by
+    intro hny hnz
+    apply endpoint_degree_le hw₀
+    intro v hwv
+    rcases hcoverE w₀ hw₀ v hwv with hv | rfl | rfl
+    · exact hv
+    · exact False.elim (hny hwv)
+    · exact False.elim (hnz hwv)
+  have hsecond := endpoint_second_attachment hs ⟨hlower, hupper⟩ hclique hno
+    hyE hzE hw₀ (fun e _ => hdegree e) hpartial hzero
+  have hfull : ∀ e ∈ E, ∀ v, H.Adj e v → v ∈ E ∨ v = u ∨ v = y ∨ v = z := by
+    intro e he v hev
+    rcases hcoverE e he v hev with hvW | hvy | hvz
+    · rcases full_endpoint_attachment_in_W hf t hfinal hclique hsecond he hvW hev with hv | hvu
+      · exact Or.inl hv
+      · exact Or.inr (Or.inl hvu)
+    · exact Or.inr (Or.inr (Or.inl hvy))
+    · exact Or.inr (Or.inr (Or.inr hvz))
+  have hfull' : ∀ e ∈ E, ∀ v, H.Adj e v → v ∈ (E.erase e) ∪ {u, y, z} := by
+    intro e he v hev
+    rcases hfull e he v hev with hv | rfl | rfl | rfl
+    · exact Finset.mem_union_left _ (Finset.mem_erase.mpr ⟨hev.ne.symm, hv⟩)
+    · simp
+    · simp
+    · simp
+  have hcommon := endpoint_common_deleted_neighbor hs ⟨hlower, hupper⟩ hclique hno
+    huE (fun e _ => hdegree e) hfull'
+  obtain ⟨b, hb, hbne, hub⟩ := hsecond
+  exact ⟨hclique, hlower, hupper, u, huU, huE,
+    ⟨w₀, hw₀, b, hb, hbne.symm, huw₀.symm, hub.symm⟩, hfull, hcommon⟩
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/EndpointTail.lean

@@ -0,0 +1,178 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.LongestPaths
+
+namespace OAI
+
+/-! The endpoint clique is a final segment, and its tail can be reordered. -/
+
+namespace CycleClique.Construction
+/-- A nonempty successor-closed subset of a finite interval, excluding
+zero, starts immediately after a well-defined boundary index. -/
+theorem successor_closed_final_segment {r : ℕ} (P : Fin (r + 1) → Prop)
+    (hzero : ¬ P 0) (hlast : P (Fin.last r))
+    (hnext : ∀ i : Fin r, P i.castSucc → P i.succ) :
+    ∃ t : Fin r, ∀ i : Fin (r + 1), P i ↔ t.val < i.val := by
+  classical
+  let A : Finset (Fin (r + 1)) := Finset.univ.filter P
+  have hA : A.Nonempty := ⟨Fin.last r, by simpa [A] using hlast⟩
+  let a := A.min' hA
+  have ha : P a := (Finset.mem_filter.mp (A.min'_mem hA)).2
+  have hapos : 1 ≤ a.val := by
+    by_contra hn
+    have heq : a = 0 := by
+      apply Fin.ext
+      simpa only [Fin.val_zero] using (show a.val = 0 by omega)
+    exact hzero (heq ▸ ha)
+  have hmin : ∀ i, P i → a.val ≤ i.val := by
+    intro i hi
+    exact Finset.min'_le A i (by simpa [A] using hi)
+  have hup : ∀ j, ∀ hj : j < r + 1, a.val ≤ j → P ⟨j, hj⟩ := by
+    intro j
+    induction j with
+    | zero => intro hj hle; omega
+    | succ j ih =>
+      intro hj hle
+      by_cases heq : a.val = j + 1
+      · have heq' : a = ⟨j + 1, hj⟩ := Fin.ext heq
+        exact heq' ▸ ha
+      · have hjr : j < r := by omega
+        have hprev := ih (by omega) (by omega)
+        exact hnext ⟨j, hjr⟩ hprev
+  refine ⟨⟨a.val - 1, by have := a.isLt; omega⟩, ?_⟩
+  intro i
+  constructor
+  · intro hi
+    have := hmin i hi
+    dsimp
+    omega
+  · intro hi
+    apply hup i.val i.isLt
+    dsimp at hi
+    omega
+
+theorem pathEnds_final_segment {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {x : V} {W : Finset V} {r : ℕ}
+    (hr : 1 ≤ r) {f : Fin (r + 1) → V} (hf : IsSpanningPath G x W f)
+    (hclique : G.IsClique (pathEnds G x W r : Set V)) :
+    ∃ t : Fin r, ∀ i : Fin (r + 1), f i ∈ pathEnds G x W r ↔ t.val < i.val := by
+  apply successor_closed_final_segment (fun i => f i ∈ pathEnds G x W r)
+  · rw [hf.2.2.1]
+    exact start_not_pathEnds hr
+  · exact mem_pathEnds.mpr ⟨f, hf, rfl⟩
+  · intro i hi
+    exact pathEnds_successor_closed hf hclique hi
+
+/-- Permuting the clique tail while fixing its first vertex preserves
+the path and all of its prefix. -/
+theorem spanningPath_permute_tail {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {x : V} {W E : Finset V} {r : ℕ}
+    {f : Fin (r + 1) → V} (hf : IsSpanningPath G x W f)
+    (t : Fin r) (hfinal : ∀ i : Fin (r + 1), f i ∈ E ↔ t.val < i.val)
+    (hclique : G.IsClique (E : Set V)) (σ : Equiv.Perm (Fin (r + 1)))
+    (hfix : ∀ i : Fin (r + 1), i.val ≤ t.val + 1 → σ i = i) :
+    IsSpanningPath G x W (f ∘ σ) := by
+  have htail : ∀ i : Fin (r + 1), t.val < i.val → t.val < (σ i).val := by
+    intro i hi
+    by_contra hn
+    have hs : σ (σ i) = σ i := hfix (σ i) (by omega)
+    have heq : i = σ i := σ.injective hs.symm
+    have hv := congrArg Fin.val heq
+    omega
+  refine ⟨hf.1.comp σ.injective, ?_, ?_, ?_⟩
+  · intro i
+    change G.Adj (f (σ i.castSucc)) (f (σ i.succ))
+    by_cases hbefore : i.val ≤ t.val
+    · rw [hfix i.castSucc (by change i.val ≤ t.val + 1; omega),
+        hfix i.succ (by change i.val + 1 ≤ t.val + 1; omega)]
+      exact hf.2.1 i
+    · apply hclique ((hfinal _).mpr (htail _ (by simpa using (by omega : t.val < i.val))))
+        ((hfinal _).mpr (htail _ (by simp; omega)))
+      intro heq
+      have hidx := σ.injective (hf.1 heq)
+      have hv := congrArg Fin.val hidx
+      simp only [Fin.val_castSucc, Fin.val_succ] at hv
+      omega
+  · change f (σ 0) = x
+    rw [hfix 0 (by simp)]
+    exact hf.2.2.1
+  · ext v
+    constructor
+    · rintro ⟨i, rfl⟩
+      rw [← hf.2.2.2]
+      exact ⟨σ i, rfl⟩
+    · intro hv
+      rw [← hf.2.2.2] at hv
+      obtain ⟨i, rfl⟩ := hv
+      exact ⟨σ.symm i, by simp⟩
+
+/-- Any tail vertex other than the first can be made last while the
+prefix and the first tail vertex stay fixed. -/
+theorem spanningPath_swap_tail {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {x : V} {W E : Finset V} {r : ℕ}
+    {f : Fin (r + 1) → V} (hf : IsSpanningPath G x W f)
+    (t : Fin r) (hfinal : ∀ i : Fin (r + 1), f i ∈ E ↔ t.val < i.val)
+    (hclique : G.IsClique (E : Set V)) (i : Fin (r + 1))
+    (hi : t.val + 1 < i.val) :
+    ∃ g : Fin (r + 1) → V, IsSpanningPath G x W g ∧
+      g (Fin.last r) = f i ∧
+      ∀ j : Fin (r + 1), j.val ≤ t.val + 1 → g j = f j := by
+  classical
+  let σ := Equiv.swap i (Fin.last r)
+  have hfix : ∀ j : Fin (r + 1), j.val ≤ t.val + 1 → σ j = j := by
+    intro j hj
+    apply Equiv.swap_apply_of_ne_of_ne
+    · intro h
+      have := congrArg Fin.val h
+      omega
+    · intro h
+      have := congrArg Fin.val h
+      simp only [Fin.val_last] at this
+      have := i.isLt
+      omega
+  exact ⟨f ∘ σ, spanningPath_permute_tail hf t hfinal hclique σ hfix,
+    by simp [σ], fun j hj => congrArg f (hfix j hj)⟩
+
+/-- Every endpoint except the first vertex of the fixed clique tail
+has no neighbour in the preceding prefix except its attachment vertex. -/
+theorem partial_endpoint_attachment {V : Type*} [Fintype V]
+    {G : SimpleGraph V} {x : V} {W : Finset V} {r : ℕ}
+    {f : Fin (r + 1) → V} (hf : IsSpanningPath G x W f)
+    (t : Fin r)
+    (hfinal : ∀ i : Fin (r + 1), f i ∈ pathEnds G x W r ↔ t.val < i.val)
+    (hclique : G.IsClique (pathEnds G x W r : Set V))
+    (hneighbors : ∀ e ∈ pathEnds G x W r, ∀ v, G.Adj e v → v ∈ W) :
+    ∀ w ∈ pathEnds G x W r, w ≠ f t.succ →
+      ∀ v, G.Adj w v → v ∈ pathEnds G x W r ∨ v = f t.castSucc := by
+  intro w hw hwfirst v hwv
+  have hwW : w ∈ (W : Set V) := pathEnds_subset G x W r hw
+  rw [← hf.2.2.2] at hwW
+  obtain ⟨i, hiw⟩ := hwW
+  have hitail : t.val < i.val := (hfinal i).mp (hiw ▸ hw)
+  have hi : t.val + 1 < i.val := by
+    have hneq : i ≠ t.succ := fun h => hwfirst (hiw.symm.trans (congrArg f h))
+    have hval : i.val ≠ t.val + 1 := fun h => hneq (Fin.ext h)
+    omega
+  obtain ⟨g, hg, hglast, hgfix⟩ := spanningPath_swap_tail hf t hfinal hclique i hi
+  by_cases hv : v ∈ pathEnds G x W r
+  · exact Or.inl hv
+  · right
+    have hvW : v ∈ (W : Set V) := hneighbors w hw v hwv
+    rw [← hf.2.2.2] at hvW
+    obtain ⟨j, hjv⟩ := hvW
+    have hjbefore : j.val ≤ t.val := by
+      by_contra hn
+      exact hv (hjv ▸ (hfinal j).mpr (by omega))
+    by_cases heq : j.val = t.val
+    · have hj : j = t.castSucc := Fin.ext heq
+      exact hjv.symm.trans (congrArg f hj)
+    · let p : Fin r := ⟨j.val, by have := t.isLt; omega⟩
+      have hgp : g p.castSucc = v := (hgfix p.castSucc (by dsimp [p]; omega)).trans
+        ((congrArg f (Fin.ext rfl)).trans hjv)
+      have hrot := successor_mem_pathEnds hg p (by rw [hglast, hiw, hgp]; exact hwv)
+      rw [hgfix p.succ (by dsimp [p]; omega)] at hrot
+      have hbound := (hfinal p.succ).mp hrot
+      dsimp [p] at hbound
+      omega
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/ExteriorCounts.lean

@@ -0,0 +1,70 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.FiveCycleGeometry
+
+namespace OAI
+
+/-! Expansion counts after deleting the clique neighbours of an independent set. -/
+
+namespace CycleClique.Construction
+theorem exterior_closed_expansion_bound {V : Type*} [Fintype V] [DecidableEq V]
+    {G : SimpleGraph V} {Q A I B : Finset V} {k : ℕ}
+    (hexpand : k * I.card + 1 ≤ (closedNeighborhood G I).card)
+    (hIA : I ⊆ A) (hAQ : Disjoint A Q)
+    (hcover : ∀ i ∈ I, ∀ q ∈ Q, G.Adj i q → q ∈ B) :
+    k * I.card + 1 ≤ B.card + (exteriorClosedNeighborhood G Q A).card := by
+  classical
+  have hsub : closedNeighborhood G I ⊆ B ∪ exteriorClosedNeighborhood G Q A := by
+    intro v hv
+    by_cases hvQ : v ∈ Q
+    · apply Finset.mem_union_left
+      rcases mem_closedNeighborhood.mp hv with hvI | ⟨i, hi, hiv⟩
+      · exact False.elim (Finset.disjoint_left.mp hAQ (hIA hvI) hvQ)
+      · exact hcover i hi v hvQ hiv
+    · apply Finset.mem_union_right
+      apply mem_exteriorClosedNeighborhood.mpr
+      refine ⟨?_, hvQ⟩
+      rcases mem_closedNeighborhood.mp hv with hvI | ⟨i, hi, hiv⟩
+      · exact Or.inl (hIA hvI)
+      · exact Or.inr ⟨i, hIA hi, hiv⟩
+  exact hexpand.trans ((Finset.card_le_card hsub).trans (Finset.card_union_le _ _))
+
+theorem one_clique_neighbor_expansion {V : Type*} [Fintype V] [DecidableEq V]
+    {G : SimpleGraph V} {Q A : Finset V} {q : V} {k : ℕ}
+    (hA : A.Nonempty) (hAQ : Disjoint A Q)
+    (hcover : ∀ a ∈ A, ∀ x ∈ Q, G.Adj a x → x = q)
+    (hexpand : ∀ I : Finset V, G.IsIndepSet (I : Set V) → I.Nonempty →
+      k * I.card + 1 ≤ (closedNeighborhood G I).card) :
+    k * (G.induce (A : Set V)).indepNum ≤ (exteriorClosedNeighborhood G Q A).card := by
+  classical
+  let I := independentOn G A
+  have hIcard : I.card = (G.induce (A : Set V)).indepNum := independentOn_card G A
+  have hpos : 0 < (G.induce (A : Set V)).indepNum := by
+    let : Nonempty A := hA.to_subtype
+    exact indepNum_pos_of_nonempty _
+  have hIne : I.Nonempty := Finset.card_pos.mp (by omega)
+  have h := exterior_closed_expansion_bound (B := {q})
+    (hexpand I (independentOn_independent G A) hIne) (independentOn_subset G A) hAQ
+    (fun i hi x hx hadj => Finset.mem_singleton.mpr
+      (hcover i (independentOn_subset G A hi) x hx hadj))
+  rw [Finset.card_singleton, hIcard] at h
+  omega
+
+theorem exterior_disjoint_sum_bound {V ι : Type*} [Fintype V] [DecidableEq V]
+    {G : SimpleGraph V} {Q : Finset V} (F : Finset ι) (A : ι → Finset V)
+    (hdis : (F : Set ι).PairwiseDisjoint (fun i => exteriorClosedNeighborhood G Q (A i))) :
+    Q.card + ∑ i ∈ F, (exteriorClosedNeighborhood G Q (A i)).card ≤ Fintype.card V := by
+  classical
+  let C := F.biUnion (fun i => exteriorClosedNeighborhood G Q (A i))
+  have hCcard : C.card = ∑ i ∈ F, (exteriorClosedNeighborhood G Q (A i)).card :=
+    Finset.card_biUnion hdis
+  have hQC : Disjoint Q C := by
+    apply Finset.disjoint_left.mpr
+    intro x hx hxC
+    obtain ⟨i, _, hi⟩ := Finset.mem_biUnion.mp hxC
+    exact (mem_exteriorClosedNeighborhood.mp hi).2 hx
+  have hbound : (Q ∪ C).card ≤ Fintype.card V := by
+    simpa only [Finset.card_univ] using Finset.card_le_card (Finset.subset_univ (Q ∪ C))
+  rwa [Finset.card_union_of_disjoint hQC, hCcard] at hbound
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/FastCertificateMatrix.lean

@@ -0,0 +1,114 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.TemplateMatrix
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.RequiredCertificates
+import Mathlib.Data.Nat.Bitwise
+
+namespace OAI
+
+/-! Natural-number masks provide a compact, checked representation of
+finite forbidden matrices. The supplied masks are validated separately. -/
+
+namespace CycleClique.Construction
+/-- Decode the first `w` bits of a natural-number mask. -/
+def decode (w b : ℕ) : Finset ℕ :=
+  (Finset.range w).filter (fun d => Nat.testBit b d)
+
+@[simp] theorem decode_zero (w : ℕ) : decode w 0 = ∅ := by
+  simp [decode]
+
+theorem decode_or (w b c : ℕ) : decode w (b ||| c) = decode w b ∪ decode w c := by
+  ext d
+  simp [decode, Nat.testBit_or, and_or_left]
+
+def templateMaskEntry {n : ℕ} (T : TemplateData (Fin n)) (b : ℕ) :
+    Fin n → Fin n → ℕ := fun i j =>
+  if (i = T.x ∧ j = T.y) ∨ (i = T.y ∧ j = T.x) then b else 0
+
+def templateMaskMatrix {n : ℕ} :
+    List (TemplateData (Fin n) × ℕ) → Fin n → Fin n → ℕ
+  | [] => fun _ _ => 0
+  | Tb :: E => fun i j => templateMaskEntry Tb.1 Tb.2 i j ||| templateMaskMatrix E i j
+
+theorem templateMaskMatrix_append {n : ℕ}
+    (A B : List (TemplateData (Fin n) × ℕ)) :
+    templateMaskMatrix (A ++ B) =
+      fun i j => templateMaskMatrix A i j ||| templateMaskMatrix B i j := by
+  induction A with
+  | nil =>
+    funext i j
+    simp only [List.nil_append, templateMaskMatrix, Nat.zero_or]
+  | cons Tb A ih =>
+    funext i j
+    simp only [List.cons_append, templateMaskMatrix, ih, Nat.or_assoc]
+
+theorem decode_templateMaskEntry {n w b : ℕ} {T : TemplateData (Fin n)}
+    (hdecode : decode w b = Finset.Icc T.lo T.hi) (i j : Fin n) :
+    decode w (templateMaskEntry T b i j) = templateEntryMatrix T i j := by
+  unfold templateMaskEntry templateEntryMatrix
+  split_ifs
+  · exact hdecode
+  · exact decode_zero w
+
+theorem decode_templateMaskMatrix {n : ℕ} (w : ℕ)
+    (E : List (TemplateData (Fin n) × ℕ))
+    (hE : ∀ Tb ∈ E, decode w Tb.2 = Finset.Icc Tb.1.lo Tb.1.hi) :
+    (fun i j => decode w (templateMaskMatrix E i j)) = templateMatrix (E.map Prod.fst) := by
+  induction E with
+  | nil =>
+    funext i j
+    exact decode_zero w
+  | cons Tb E ih =>
+    have hT := hE Tb (by simp)
+    have htail := ih (fun Tc hTc => hE Tc (by simp [hTc]))
+    funext i j
+    change decode w (templateMaskEntry Tb.1 Tb.2 i j ||| templateMaskMatrix E i j) =
+      templateEntryMatrix Tb.1 i j ∪ templateMatrix (E.map Prod.fst) i j
+    rw [decode_or, decode_templateMaskEntry hT, congrFun (congrFun htail i) j]
+
+def requiredMaskEntry {n : ℕ} (p : RequiredPathData (Fin n)) (b : ℕ) :
+    Fin n → Fin n → ℕ := fun i j =>
+  if (i = p.x ∧ j = p.y) ∨ (i = p.y ∧ j = p.x) then b else 0
+
+def requiredMaskMatrix {n : ℕ} :
+    List (RequiredPathData (Fin n) × ℕ) → Fin n → Fin n → ℕ
+  | [] => fun _ _ => 0
+  | pb :: E => fun i j => requiredMaskEntry pb.1 pb.2 i j ||| requiredMaskMatrix E i j
+
+theorem requiredMaskMatrix_append {n : ℕ}
+    (A B : List (RequiredPathData (Fin n) × ℕ)) :
+    requiredMaskMatrix (A ++ B) =
+      fun i j => requiredMaskMatrix A i j ||| requiredMaskMatrix B i j := by
+  induction A with
+  | nil =>
+    funext i j
+    simp only [List.nil_append, requiredMaskMatrix, Nat.zero_or]
+  | cons pb A ih =>
+    funext i j
+    simp only [List.cons_append, requiredMaskMatrix, ih, Nat.or_assoc]
+
+theorem decode_requiredMaskEntry {n w b : ℕ} (k : ℕ) {p : RequiredPathData (Fin n)}
+    (hdecode : decode w b = {p.parameter k}) (i j : Fin n) :
+    decode w (requiredMaskEntry p b i j) = requiredEntryMatrix k p i j := by
+  unfold requiredMaskEntry requiredEntryMatrix
+  split_ifs
+  · exact hdecode
+  · exact decode_zero w
+
+theorem decode_requiredMaskMatrix {n : ℕ} (w k : ℕ)
+    (E : List (RequiredPathData (Fin n) × ℕ))
+    (hE : ∀ pb ∈ E, decode w pb.2 = {pb.1.parameter k}) :
+    (fun i j => decode w (requiredMaskMatrix E i j)) = requiredMatrix k (E.map Prod.fst) := by
+  induction E with
+  | nil =>
+    funext i j
+    exact decode_zero w
+  | cons pb E ih =>
+    have hp := hE pb (by simp)
+    have htail := ih (fun pc hpc => hE pc (by simp [hpc]))
+    funext i j
+    change decode w (requiredMaskEntry pb.1 pb.2 i j ||| requiredMaskMatrix E i j) =
+      requiredEntryMatrix k pb.1 i j ∪ requiredMatrix k (E.map Prod.fst) i j
+    rw [decode_or, decode_requiredMaskEntry k hp, congrFun (congrFun htail i) j]
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/FastLayoutGraph.lean

@@ -0,0 +1,35 @@
+import Mathlib.Combinatorics.SimpleGraph.Basic
+
+namespace OAI
+
+/-! A checked adjacency table gives a computable graph presentation whose
+edge tests require only two array lookups. -/
+
+namespace CycleClique.Construction
+def adjacencyTableLookup (A : Array (Array Bool)) (i j : ℕ) : Bool :=
+  (A.getD i #[]).getD j false
+
+/-- Present `H` by a separately checked finite adjacency table. -/
+def adjacencyTableGraph {n : ℕ} (H : SimpleGraph (Fin n))
+    (A : Array (Array Bool))
+    (hEq : ∀ i j : Fin n, H.Adj i j ↔ adjacencyTableLookup A i.val j.val = true) :
+    SimpleGraph (Fin n) where
+  Adj i j := adjacencyTableLookup A i.val j.val = true
+  symm := ⟨fun i j hij => (hEq j i).mp ((hEq i j).mpr hij).symm⟩
+  loopless := ⟨fun i hii => H.irrefl ((hEq i i).mpr hii)⟩
+
+instance {n : ℕ} (H : SimpleGraph (Fin n)) (A : Array (Array Bool))
+    (hEq : ∀ i j : Fin n, H.Adj i j ↔ adjacencyTableLookup A i.val j.val = true) :
+    DecidableRel (adjacencyTableGraph H A hEq).Adj :=
+  fun i j => inferInstanceAs (Decidable (adjacencyTableLookup A i.val j.val = true))
+
+theorem adjacencyTableGraph_eq {n : ℕ} (H : SimpleGraph (Fin n))
+    (A : Array (Array Bool))
+    (hEq : ∀ i j : Fin n, H.Adj i j ↔ adjacencyTableLookup A i.val j.val = true) :
+    adjacencyTableGraph H A hEq = H := by
+  ext i j
+  exact (hEq i j).symm
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/FastMatrixRows.lean

@@ -0,0 +1,52 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.FastCertificateMatrix
+
+namespace OAI
+
+/-! A matrix row depends only on certificates incident with its index. -/
+
+namespace CycleClique.Construction
+def templateIncident {n : ℕ} (i : Fin n) (Tb : TemplateData (Fin n) × ℕ) : Bool :=
+  decide (i = Tb.1.x ∨ i = Tb.1.y)
+
+theorem templateMaskMatrix_filter_row {n : ℕ}
+    (E : List (TemplateData (Fin n) × ℕ)) (i j : Fin n) :
+    templateMaskMatrix (E.filter (templateIncident i)) i j = templateMaskMatrix E i j := by
+  induction E with
+  | nil => rfl
+  | cons Tb E ih =>
+    by_cases h : i = Tb.1.x ∨ i = Tb.1.y
+    · have hh : templateIncident i Tb = true := by simp [templateIncident, h]
+      simp only [List.filter_cons, hh, ite_true, templateMaskMatrix, ih]
+    · have hh : templateIncident i Tb = false := by simp [templateIncident, h]
+      have he : templateMaskEntry Tb.1 Tb.2 i j = 0 := by
+        simp only [templateMaskEntry]
+        split_ifs with he
+        · exact False.elim (h (he.elim (fun hx => Or.inl hx.1) (fun hy => Or.inr hy.1)))
+        · rfl
+      simp only [List.filter_cons, hh, Bool.false_eq_true, ite_false, templateMaskMatrix, he,
+        Nat.zero_or, ih]
+
+def requiredIncident {n : ℕ} (i : Fin n) (p : RequiredPathData (Fin n)) : Bool :=
+  decide (i = p.x ∨ i = p.y)
+
+theorem requiredMatrix_filter_row {n : ℕ} (k : ℕ)
+    (E : List (RequiredPathData (Fin n))) (i j : Fin n) :
+    requiredMatrix k (E.filter (requiredIncident i)) i j = requiredMatrix k E i j := by
+  induction E with
+  | nil => rfl
+  | cons p E ih =>
+    by_cases h : i = p.x ∨ i = p.y
+    · have hh : requiredIncident i p = true := by simp [requiredIncident, h]
+      simp only [List.filter_cons, hh, ite_true, requiredMatrix, ih]
+    · have hh : requiredIncident i p = false := by simp [requiredIncident, h]
+      have he : requiredEntryMatrix k p i j = ∅ := by
+        simp only [requiredEntryMatrix]
+        split_ifs with he
+        · exact False.elim (h (he.elim (fun hx => Or.inl hx.1) (fun hy => Or.inr hy.1)))
+        · rfl
+      simp only [List.filter_cons, hh, Bool.false_eq_true, ite_false, requiredMatrix, he,
+        Finset.empty_union, ih]
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/FiniteAttachments.lean

@@ -0,0 +1,111 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.FiniteBad
+
+namespace OAI
+
+/-! Hypothetical outside parameters zero and one become, respectively, a
+required edge and a fresh common neighbor in a finite labelled state. -/
+
+namespace CycleClique.Construction
+variable {n : ℕ}
+
+def addedEdgeGraph (H : SimpleGraph (Fin n)) (i j : Fin n) : SimpleGraph (Fin n) where
+  Adj a b := a ≠ b ∧ (H.Adj a b ∨ (a = i ∧ b = j) ∨ (a = j ∧ b = i))
+  symm := ⟨by
+    intro a b h
+    refine ⟨h.1.symm, ?_⟩
+    rcases h.2 with h | h | h
+    · exact Or.inl h.symm
+    · exact Or.inr (Or.inr h.symm)
+    · exact Or.inr (Or.inl h.symm)⟩
+  loopless := ⟨fun _ h => h.1 rfl⟩
+
+instance (H : SimpleGraph (Fin n)) [DecidableRel H.Adj] (i j : Fin n) :
+    DecidableRel (addedEdgeGraph H i j).Adj := fun _ _ => inferInstanceAs (Decidable (_ ∧ _))
+
+def freshGraph (H : SimpleGraph (Fin n)) (i j : Fin n) : SimpleGraph (Fin (n + 1)) where
+  Adj := Fin.cases (Fin.cases False (fun b => b = i ∨ b = j))
+    (fun a => Fin.cases (a = i ∨ a = j) (fun b => H.Adj a b))
+  symm := ⟨by
+    intro a b
+    refine Fin.cases ?_ (fun a => ?_) a <;> refine Fin.cases ?_ (fun b => ?_) b
+    · exact id
+    · exact id
+    · exact id
+    · exact fun h => h.symm⟩
+  loopless := ⟨by
+    intro a
+    refine Fin.cases ?_ (fun a => ?_) a
+    · exact id
+    · exact H.loopless.irrefl a⟩
+
+instance (H : SimpleGraph (Fin n)) [DecidableRel H.Adj] (i j : Fin n) :
+    DecidableRel (freshGraph H i j).Adj := by
+  intro a b
+  refine Fin.cases ?_ (fun a => ?_) a <;> refine Fin.cases ?_ (fun b => ?_) b <;>
+    dsimp only [freshGraph, Fin.cases_zero, Fin.cases_succ] <;> infer_instance
+
+def freshMatrix (M : ForbiddenMatrix n) : ForbiddenMatrix (n + 1) :=
+  Fin.cases (fun _ => ∅) (fun a => Fin.cases ∅ (fun b => M a b))
+
+variable {V : Type*} {G : SimpleGraph V} {H : SimpleGraph (Fin n)}
+
+def addedEdgeHom (f : H →g G) {i j : Fin n} (hij : G.Adj (f i) (f j)) :
+    addedEdgeGraph H i j →g G where
+  toFun := f
+  map_rel' := by
+    intro a b h
+    rcases h.2 with h | ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩
+    · exact f.map_adj h
+    · exact hij
+    · exact hij.symm
+
+def freshHom (f : H →g G) {i j : Fin n} (z : V)
+    (hiz : G.Adj (f i) z) (hjz : G.Adj (f j) z) : freshGraph H i j →g G where
+  toFun := Fin.cases z f
+  map_rel' := by
+    intro a b
+    refine Fin.cases ?_ (fun a => ?_) a <;> refine Fin.cases ?_ (fun b => ?_) b
+    · exact False.elim
+    · intro h; rcases h with rfl | rfl; exact hiz.symm; exact hjz.symm
+    · intro h; rcases h with rfl | rfl; exact hiz; exact hjz
+    · exact f.map_adj
+
+theorem freshHom_injective [DecidableEq V] (f : H →g G) (hf : Function.Injective f)
+    {X : Finset V} (hfX : ∀ i, f i ∈ X) {i j : Fin n} {z : V}
+    (hz : z ∉ X) (hiz : G.Adj (f i) z) (hjz : G.Adj (f j) z) :
+    Function.Injective (freshHom f z hiz hjz) := by
+  intro a b
+  refine Fin.cases ?_ (fun a => ?_) a <;> refine Fin.cases ?_ (fun b => ?_) b
+  · exact fun _ => rfl
+  · intro h
+    change z = f b at h
+    exact False.elim (hz (h.symm ▸ hfX b))
+  · intro h
+    change f a = z at h
+    exact False.elim (hz (h ▸ hfX a))
+  · intro h; exact congrArg Fin.succ (hf h)
+
+theorem freshHom_mem [DecidableEq V] (f : H →g G) {X : Finset V}
+    (hfX : ∀ i, f i ∈ X) {i j : Fin n} {z : V}
+    (hiz : G.Adj (f i) z) (hjz : G.Adj (f j) z) :
+    ∀ a, freshHom f z hiz hjz a ∈ insert z X := by
+  intro a
+  refine Fin.cases ?_ (fun a => ?_) a
+  · exact Finset.mem_insert_self _ _
+  · exact Finset.mem_insert_of_mem (hfX a)
+
+theorem freshMatrix_sound [DecidableEq V] (f : H →g G) {X : Finset V}
+    {M : ForbiddenMatrix n} (hM : M.Sound G X f) {i j : Fin n} {z : V}
+    (hiz : G.Adj (f i) z) (hjz : G.Adj (f j) z) :
+    (freshMatrix M).Sound G (insert z X) (freshHom f z hiz hjz) := by
+  have hbig := hM.enlarge_ground (Finset.subset_insert z X)
+  intro a b
+  refine Fin.cases ?_ (fun a => ?_) a <;> refine Fin.cases ?_ (fun b => ?_) b
+  · intro d hd; exact False.elim (Finset.notMem_empty d hd)
+  · intro d hd; exact False.elim (Finset.notMem_empty d hd)
+  · intro d hd; exact False.elim (Finset.notMem_empty d hd)
+  · exact hbig a b
+
+end CycleClique.Construction
+
+end OAI

lean/OAI/Combinatorics/Ramsey/CycleClique/Construction/FiniteBad.lean

@@ -0,0 +1,47 @@
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.PackingCertificate
+import OAI.Combinatorics.Ramsey.CycleClique.Construction.RequiredCertificates
+
+namespace OAI
+
+/-! The terminal certificate for a finite state is either a required edge
+whose outside parameter zero is forbidden, or an excessive packing. -/
+
+namespace CycleClique.Construction
+structure BadData (n : ℕ) where
+  edge : Option (Fin n × Fin n)
+  packing : Finset (Fin n × ℕ)
+  deriving DecidableEq
+
+def BadData.Check {n : ℕ} (H : SimpleGraph (Fin n)) (M : ForbiddenMatrix n)
+    (k t : ℕ) (b : BadData n) : Prop :=
+  match b.edge with
+  | some (i, j) => H.Adj i j ∧ 0 ∈ M i j
+  | none => PackingCheck M k t b.packing
+
+instance {n : ℕ} (H : SimpleGraph (Fin n)) [DecidableRel H.Adj]
+    (M : ForbiddenMatrix n) (k t : ℕ) (b : BadData n) : Decidable (b.Check H M k t) := by
+  unfold BadData.Check
+  split <;> infer_instance
+
+variable {V : Type} [Fintype V] {G : SimpleGraph V}
+
+theorem BadData.false_of_check (hCE : CEAlphaTwo) {n k t : ℕ}
+    (hk : 5 ≤ k) (ht : 1 ≤ t) (hcycle : ¬ HasCycle G (k + 1))
+    (hclique : G.cliqueNum ≤ t) (hbound : IndependenceBound G k)
+    {H : SimpleGraph (Fin n)} (f : H →g G) (hf : Function.Injective f)
+    {X : Finset V} (hfX : ∀ i, f i ∈ X) (hX : X.card = n)
+    {M : ForbiddenMatrix n} (hM : M.Sound G X f)
+    (hexpand : ∀ I : Finset V, G.IsIndepSet (I : Set V) → I.Nonempty →
+      k * I.card + 1 ≤ (closedNeighborhood G I).card)
+    (b : BadData n) (hb : b.Check H M k t) : False := by
+  cases hbe : b.edge with
+  | none =>
+    exact packingCheck_false hCE hk ht hcycle hclique hbound hf hfX hX hM hexpand
+      b.packing (by simpa only [Check, hbe] using hb)
+  | some ij =>
+    have hh : H.Adj ij.1 ij.2 ∧ 0 ∈ M ij.1 ij.2 := by simpa only [Check, hbe] using hb
+    exact hM.no_required_edge hh.2 (f.map_adj hh.1)
+
+end CycleClique.Construction
+
+end OAI