openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Reduction /CompletionLemmas.lean
| import Mathlib.Data.Fintype.Prod | |
| import Mathlib.Logic.Equiv.Fintype | |
| import Mathlib.Logic.Equiv.Sum | |
| import OAI.Computability.PerfectCompleteness.Algebra.MatrixInverseConstantsLemmas | |
| import OAI.Computability.PerfectCompleteness.Machines.FixedUnaryRepresentationMachine | |
| import OAI.Computability.UniqueGames.Machines.MachineCloudPadding | |
| namespace OAI | |
| namespace PerfectCompleteness.Completion | |
| variable {L A B : Type*} | |
| def fiberEquivTwo (e : A ≃ B × Fin 2) (b : B) : | |
| {a : A // (e a).1 = b} ≃ Fin 2 where | |
| toFun a := (e a.val).2 | |
| invFun j := ⟨e.symm (b, j), by simp⟩ | |
| left_inv a := by | |
| apply Subtype.ext | |
| apply e.injective | |
| simp only [Equiv.apply_symm_apply] | |
| exact Prod.ext a.property.symm rfl | |
| right_inv j := by simp | |
| theorem exists_slot_embedding [Fintype L] [Fintype B] [DecidableEq B] | |
| (p : L → B) (hsmall : ∀ b, Fintype.card {l : L // p l = b} ≤ 2) : | |
| ∃ slots : L ↪ B × Fin 2, ∀ l, (slots l).1 = p l := by | |
| classical | |
| have hslots (b : B) : Nonempty ({l : L // p l = b} ↪ Fin 2) := | |
| Function.Embedding.nonempty_of_card_le (by simpa using hsmall b) | |
| let fiberSlots (b : B) : {l : L // p l = b} ↪ Fin 2 := | |
| Classical.choice (hslots b) | |
| let fiberMap : (Σ b : B, {l : L // p l = b}) ↪ Σ _ : B, Fin 2 := | |
| Function.Embedding.sigmaMap (Function.Embedding.refl B) fiberSlots | |
| let slots : L ↪ B × Fin 2 := | |
| (Equiv.sigmaFiberEquiv p).symm.toEmbedding.trans | |
| (fiberMap.trans (Equiv.sigmaEquivProd B (Fin 2)).toEmbedding) | |
| exact ⟨slots, fun _ => rfl⟩ | |
| theorem exists_exact_two_completion [Fintype L] [Fintype A] [Fintype B] | |
| [DecidableEq B] (legal : L ↪ A) (p : L → B) | |
| (hsmall : ∀ b, Fintype.card {l : L // p l = b} ≤ 2) | |
| (hcard : Fintype.card A = 2 * Fintype.card B) : | |
| ∃ pHat : A → B, | |
| (∀ l, pHat (legal l) = p l) ∧ | |
| ∀ b, Fintype.card {a : A // pHat a = b} = 2 := by | |
| classical | |
| obtain ⟨slots, hslots⟩ := exists_slot_embedding p hsmall | |
| have hcardSlots : Fintype.card A = Fintype.card (B × Fin 2) := by | |
| rw [Fintype.card_prod, Fintype.card_fin, Nat.mul_comm] | |
| exact hcard | |
| let base : A ≃ B × Fin 2 := Fintype.equivOfCardEq hcardSlots | |
| obtain ⟨σ, hσ⟩ := Equiv.Perm.exists_extending_pair | |
| (fun l : L => base (legal l)) (fun l : L => slots l) | |
| (base.injective.comp legal.injective) slots.injective | |
| let e : A ≃ B × Fin 2 := base.trans σ | |
| refine ⟨fun a => (e a).1, ?_, ?_⟩ | |
| · intro l | |
| change (σ (base (legal l))).1 = p l | |
| rw [hσ l] | |
| exact hslots l | |
| · intro b | |
| exact (Fintype.card_congr (fiberEquivTwo e b)).trans (Fintype.card_fin 2) | |
| end PerfectCompleteness.Completion | |
| namespace PerfectCompleteness.FixedUnaryRepresentationPlacement | |
| open Turing UniqueGamesTheorem.Foundations.Complexity | |
| open MachineComposition MachineCloudPadding | |
| abbrev Mode := FixedUnaryRepresentationMachine.Mode | |
| abbrev Tape (width : Nat) := FixedUnaryRepresentationMachine.Tape width | |
| abbrev Label (mode : Mode) (width : Nat) := | |
| FixedUnaryRepresentationMachine.Label mode (List.finRange width) | |
| abbrev CleanupLabel (width : Nat) := FixedUnaryRepresentationMachine.CleanupLabel width | |
| abbrev State (A : Type) := A × Option Bool | |
| abbrev Alphabet {K : Type} (_ : K) := Bool | |
| variable {width : Nat} {K Λ A : Type} | |
| def nativeProgram (mode : Mode) : Label mode width → | |
| TM2.Stmt (Alphabet (K := Tape width)) (Label mode width) (State A) := | |
| FixedUnaryRepresentationMachine.instruction mode (List.finRange width) id none | |
| def instruction (mode : Mode) (tape : Tape width → K) | |
| (labels : Label mode width → Λ) (exit : Option Λ) : | |
| Label mode width → TM2.Stmt (Alphabet (K := K)) Λ (State A) := | |
| fun label => Placement.statement tape labels exit (nativeProgram mode label) | |
| def entry (mode : Mode) (labels : Label mode width → Λ) (exit : Option Λ) : Option Λ := | |
| Placement.label labels exit | |
| (FixedUnaryRepresentationMachine.entry mode (List.finRange width) id none) | |
| def tapes (view : K → Option (Tape width)) (extra : K → List Bool) | |
| (mode : Mode) (values : Fin width → Nat) (destinations : Fin width → List Bool) : | |
| K → List Bool := | |
| Placement.tapes view (FixedUnaryRepresentationMachine.stacks mode values destinations) extra | |
| theorem tapes_eq_base (tape : Tape width → K) (view : K → Option (Tape width)) | |
| (right : ∀ j k, view j = some k → tape k = j) (base : K → List Bool) | |
| (mode : Mode) (values : Fin width → Nat) (destinations : Fin width → List Bool) | |
| (contents : ∀ k, base (tape k) = | |
| FixedUnaryRepresentationMachine.stacks mode values destinations k) : | |
| tapes view base mode values destinations = base := by | |
| funext j | |
| cases viewed : view j with | |
| | none => simp only [tapes, Placement.tapes, viewed] | |
| | some k => | |
| simp only [tapes, Placement.tapes, viewed] | |
| rw [← right j k viewed] | |
| exact (contents k).symm | |
| def cleanupNativeProgram : CleanupLabel width → | |
| TM2.Stmt (Alphabet (K := Tape width)) (CleanupLabel width) (State A) := | |
| FixedUnaryRepresentationMachine.cleanupInstruction id none | |
| def cleanupInstruction (tape : Tape width → K) | |
| (labels : CleanupLabel width → Λ) (exit : Option Λ) : | |
| CleanupLabel width → TM2.Stmt (Alphabet (K := K)) Λ (State A) := | |
| fun label => Placement.statement tape labels exit (cleanupNativeProgram label) | |
| def cleanupEntry (labels : CleanupLabel width → Λ) (exit : Option Λ) : Option Λ := | |
| Placement.label labels exit (FixedUnaryRepresentationMachine.cleanupEntry id none) | |
| variable [DecidableEq K] | |
| theorem familyTrace (mode : Mode) (tape : Tape width → K) (view : K → Option (Tape width)) | |
| (left : ∀ k, view (tape k) = some k) | |
| (right : ∀ j k, view j = some k → tape k = j) | |
| (labels : Label mode width → Λ) (exit : Option Λ) | |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) | |
| (atLabels : ∀ label, program (labels label) = instruction mode tape labels exit label) | |
| (extra : K → List Bool) (values : Fin width → Nat) | |
| (destinations : Fin width → List Bool) (ambient : A) : | |
| (advance (TM2.step program))^[FixedUnaryRepresentationMachine.steps mode values (List.finRange width)] | |
| (some ⟨entry mode labels exit, (ambient, none), tapes view extra mode values destinations⟩) = | |
| some ⟨exit, (ambient, none), tapes view extra mode values | |
| (fun position => FixedUnaryRepresentationMachine.targetWord mode (values position) ++ | |
| destinations position)⟩ := by | |
| have native := FixedUnaryRepresentationMachine.familyTrace mode values id none | |
| (nativeProgram (width := width) (A := A) mode) (fun _ => rfl) destinations ambient | |
| have placed := Placement.trace tape view left right labels exit extra | |
| (nativeProgram (width := width) (A := A) mode) program atLabels _ _ _ native | |
| simpa only [Placement.configuration, Placement.label, entry, tapes] using placed | |
| def familyInTime (mode : Mode) (tape : Tape width → K) (view : K → Option (Tape width)) | |
| (left : ∀ k, view (tape k) = some k) | |
| (right : ∀ j k, view j = some k → tape k = j) | |
| (labels : Label mode width → Λ) (exit : Option Λ) | |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) | |
| (atLabels : ∀ label, program (labels label) = instruction mode tape labels exit label) | |
| (extra : K → List Bool) (values : Fin width → Nat) | |
| (destinations : Fin width → List Bool) (ambient : A) | |
| (maximum : Nat) (bounded : ∀ position, values position ≤ maximum) : | |
| StateTransition.EvalsToInTime (TM2.step program) | |
| ⟨entry mode labels exit, (ambient, none), tapes view extra mode values destinations⟩ | |
| (some ⟨exit, (ambient, none), tapes view extra mode values | |
| (fun position => FixedUnaryRepresentationMachine.targetWord mode (values position) ++ | |
| destinations position)⟩) | |
| (width * (2 * maximum + 3)) where | |
| steps := FixedUnaryRepresentationMachine.steps mode values (List.finRange width) | |
| evals_in_steps := familyTrace mode tape view left right labels exit program atLabels extra | |
| values destinations ambient | |
| steps_le_m := by | |
| simpa only [List.length_finRange] using | |
| FixedUnaryRepresentationMachine.steps_le mode values (List.finRange width) maximum bounded | |
| theorem cleanupTrace (mode : Mode) (tape : Tape width → K) (view : K → Option (Tape width)) | |
| (left : ∀ k, view (tape k) = some k) | |
| (right : ∀ j k, view j = some k → tape k = j) | |
| (labels : CleanupLabel width → Λ) (exit : Option Λ) | |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) | |
| (atLabels : ∀ label, program (labels label) = cleanupInstruction tape labels exit label) | |
| (extra : K → List Bool) (values : Fin width → Nat) | |
| (destinations : Fin width → List Bool) (ambient : A) : | |
| (advance (TM2.step program))^[MachineDrainMany.steps | |
| (FixedUnaryRepresentationMachine.cleanupTapes width) | |
| (FixedUnaryRepresentationMachine.stacks mode values destinations)] | |
| (some ⟨cleanupEntry labels exit, (ambient, none), tapes view extra mode values destinations⟩) = | |
| some ⟨exit, (ambient, none), tapes view extra mode values (fun _ => [])⟩ := by | |
| have native := FixedUnaryRepresentationMachine.cleanupTrace mode values id none | |
| (cleanupNativeProgram (width := width) (A := A)) (fun _ => rfl) destinations ambient | |
| have placed := Placement.trace tape view left right labels exit extra | |
| (cleanupNativeProgram (width := width) (A := A)) program atLabels _ _ _ native | |
| simpa only [Placement.configuration, Placement.label, cleanupEntry, tapes] using placed | |
| end PerfectCompleteness.FixedUnaryRepresentationPlacement | |
| namespace PerfectCompleteness.InitialParameters | |
| open UniqueGamesTheorem.Appendix UniqueGamesTheorem.Fourier | |
| noncomputable section | |
| def epsilon (δ : ℚ) : ℝ := (δ : ℝ) / 3 | |
| def simultaneous (δ : ℚ) : ℝ := epsilon δ ^ 2 / 2 | |
| def useful (δ : ℚ) : ℝ := simultaneous δ / 2 | |
| def inverse (δ : ℚ) : ℝ := simultaneous δ ^ 2 / 32 | |
| theorem epsilon_pos {δ : ℚ} (hδ : 0 < δ) : 0 < epsilon δ := by | |
| have : (0 : ℝ) < δ := by exact_mod_cast hδ | |
| unfold epsilon | |
| positivity | |
| theorem simultaneous_pos {δ : ℚ} (hδ : 0 < δ) : 0 < simultaneous δ := by | |
| have := epsilon_pos hδ | |
| unfold simultaneous | |
| positivity | |
| theorem useful_pos {δ : ℚ} (hδ : 0 < δ) : 0 < useful δ := by | |
| have := simultaneous_pos hδ | |
| unfold useful | |
| positivity | |
| theorem inverse_pos {δ : ℚ} (hδ : 0 < δ) : 0 < inverse δ := by | |
| have := simultaneous_pos hδ | |
| unfold inverse | |
| positivity | |
| theorem epsilon_lt_one {δ : ℚ} (hδ : δ < 1) : epsilon δ < 1 := by | |
| have : (δ : ℝ) < 1 := by exact_mod_cast hδ | |
| unfold epsilon | |
| linarith | |
| theorem exists_initial {δ : ℚ} (hδ : 0 < δ) (hδ' : δ < 1) : | |
| ∃ depth r : Nat, 2 ≤ depth ∧ 4 ≤ (depth : ℝ) * epsilon δ ∧ | |
| 1 ≤ r ∧ ∃ α : ℝ, 0 < α ∧ α < 1 ∧ | |
| MatrixLevelBridge.levelCutoffConstant r α + RankLevelFilter.node (r + 1) < | |
| inverse δ / 2 := by | |
| have hε := epsilon_pos hδ | |
| have hε' := epsilon_lt_one hδ' | |
| obtain ⟨depth, hdepth⟩ := exists_nat_gt (4 / epsilon δ + 2) | |
| have hd2 : (2 : ℝ) < depth := by | |
| have := div_pos (by norm_num : (0 : ℝ) < 4) hε | |
| linarith | |
| have hd : 2 ≤ depth := by exact_mod_cast hd2.le | |
| have hmul : 4 ≤ (depth : ℝ) * epsilon δ := by | |
| have hdiv : 4 / epsilon δ < (depth : ℝ) := by linarith | |
| exact ((div_lt_iff₀ hε).mp hdiv).le | |
| obtain ⟨r, hr, α, hα, hα', hcut⟩ := | |
| MatrixInverseConstants.exists_cutoff_density | |
| (show 0 < inverse δ / 2 by have := inverse_pos hδ; positivity) | |
| exact ⟨depth, r, hd, hmul, hr, α, hα, hα', hcut⟩ | |
| end | |
| end PerfectCompleteness.InitialParameters | |
| end OAI | |