openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Construction /CanonicalLocalCompletion.lean
| import OAI.Computability.PerfectCompleteness.Construction.FlexibleLocalCompletionLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.LegalOutputLemmas | |
| import OAI.Computability.PerfectCompleteness.Machines.CanonicalLabelEncoding | |
| import OAI.Computability.PerfectCompleteness.Machines.LocalCompletionMachineLemmas | |
| namespace OAI | |
| section | |
| namespace PerfectCompleteness.CanonicalLocalCompletion | |
| open scoped Classical | |
| open Turing UniqueGamesTheorem.Foundations.Complexity UniqueGamesTheorem.Foundations.Games | |
| open SourceClause CanonicalKeys CanonicalGame CanonicalKeyEncoding CanonicalLabelEncoding | |
| open CompletionSoundness CompletionSoundness.LegalProjectionGame | |
| noncomputable section | |
| def alphabet (n : Nat) (δ : ℚ) : Nat := CompletionAlphabet.size (partitionWidth n) δ | |
| theorem alphabet_positive (n : Nat) (δ : ℚ) : 0 < alphabet n δ := | |
| CompletionAlphabet.size_positive (partitionWidth n) δ | |
| theorem partitionWidth_le_alphabet (n : Nat) (δ : ℚ) : partitionWidth n ≤ alphabet n δ := | |
| CompletionAlphabet.cap_le_size (partitionWidth n) δ | |
| theorem partitionWidth_le_leftAlphabet (n : Nat) (δ : ℚ) : | |
| partitionWidth n ≤ 2 * alphabet n δ := by | |
| have h := partitionWidth_le_alphabet n δ | |
| omega | |
| theorem alphabet_ge_two (n : Nat) (δ : ℚ) : 2 ≤ alphabet n δ := by | |
| have hpos : 0 < partitionWidth n := by | |
| rw [partitionWidth_eq] | |
| exact pow_pos (by decide) _ | |
| have hcap : partitionWidth n + 1 ≤ alphabet n δ := le_max_left _ _ | |
| omega | |
| local instance rightAlphabet_nonempty (n : Nat) (δ : ℚ) : Nonempty (Fin (alphabet n δ)) := | |
| ⟨⟨0, alphabet_positive n δ⟩⟩ | |
| local instance leftAlphabet_nonempty (n : Nat) (δ : ℚ) : Nonempty (Fin (2 * alphabet n δ)) := | |
| ⟨⟨0, Nat.mul_pos (by decide) (alphabet_positive n δ)⟩⟩ | |
| variable {v m n : Nat} {E I B : Type*} {V : I → Type*} | |
| [DecidableEq I] [∀ i, AddCommGroup (V i)] | |
| [∀ i, Module DirectionQuotient.F2 (V i)] | |
| [Finite I] [∀ i, Finite (V i)] [Finite B] | |
| {clauses : Fin m → NormalizedClause v} | |
| (F : BlockFamily clauses n E I V B) | |
| def legalL (δ : ℚ) (x : LeftVertex F) : LeftLabel F x ↪ Fin (2 * alphabet n δ) := | |
| labelEmbedding x.val (partitionWidth_le_leftAlphabet n δ) | |
| def legalR (δ : ℚ) (y : RightVertex F) : RightLabel F y ↪ Fin (alphabet n δ) := | |
| labelEmbedding y.val (partitionWidth_le_alphabet n δ) | |
| omit [DecidableEq I] [Finite I] [∀ index, Finite (V index)] [Finite B] in | |
| @[simp] theorem legalL_val (δ : ℚ) (x : LeftVertex F) (label : LeftLabel F x) : | |
| (legalL F δ x label).val = (partEnum n label.val).val := rfl | |
| omit [Finite I] [∀ index, Finite (V index)] [Finite B] in | |
| @[simp] theorem legalR_val (δ : ℚ) (y : RightVertex F) (label : RightLabel F y) : | |
| (legalR F δ y label).val = (partEnum n label.val).val := rfl | |
| def defaultL (x : LeftVertex F) : LeftLabel F x := Classical.choice inferInstance | |
| variable [Fintype E] [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ x, Fintype (LeftLabel F x)] [∀ y, Fintype (RightLabel F y)] | |
| omit [DecidableEq I] [Finite I] [∀ index, Finite (V index)] [Finite B] [Fintype E] | |
| [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| theorem leftLabel_card_le (δ : ℚ) (x : LeftVertex F) : | |
| Fintype.card (LeftLabel F x) ≤ alphabet n δ := by | |
| let : Fintype (KeyLabel x.val) := inferInstanceAs (Fintype (LeftLabel F x)) | |
| exact (label_card_le x.val).trans (partitionWidth_le_alphabet n δ) | |
| omit [Finite I] [∀ index, Finite (V index)] [Finite B] [Fintype E] | |
| [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (LeftLabel F vertex)] in | |
| theorem rightLabel_card_le (δ : ℚ) (y : RightVertex F) : | |
| Fintype.card (RightLabel F y) ≤ alphabet n δ := by | |
| let : Fintype (KeyLabel y.val) := inferInstanceAs (Fintype (RightLabel F y)) | |
| exact (label_card_le y.val).trans (partitionWidth_le_alphabet n δ) | |
| omit [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| theorem small (μ : FiniteDistribution E) : | |
| ∀ e b, Fintype.card | |
| {a : LeftLabel F ((game F μ).left e) // (game F μ).projection e a = b} ≤ 2 := by | |
| intro e b | |
| rw [Fintype.card_eq_nat_card] | |
| change Nat.card {a : LeftLabel F (leftAt F e) // edge F e a = b} ≤ 2 | |
| exact edge_at_most_two F e b | |
| def input (μ : FiniteDistribution E) (δ : ℚ) (e : E) : | |
| LocalCompletionFamily.Input (alphabet n δ) := | |
| LocalCompletionGame.input (game F μ) (legalL F δ) (legalR F δ) (defaultL F) e | |
| omit [Finite I] [∀ index, Finite (V index)] [Finite B] | |
| [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| theorem input_mask (μ : FiniteDistribution E) (δ : ℚ) (e : E) : | |
| (input F μ δ e).1 = paddedMask (leftKey F e) := by | |
| funext a | |
| apply Bool.eq_iff_iff.mpr | |
| exact (LocalCompletionGame.input_mask_true | |
| (game F μ) (legalL F δ) (legalR F δ) (defaultL F) e a).trans | |
| (paddedMask_eq_true_iff (leftKey F e) (partitionWidth_le_leftAlphabet n δ) a).symm | |
| omit [Finite I] [∀ index, Finite (V index)] [Finite B] | |
| [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| theorem input_image_legal (μ : FiniteDistribution E) (δ : ℚ) (e : E) | |
| (label : LeftLabel F (leftAt F e)) : | |
| (input F μ δ e).2 (legalL F δ (leftAt F e) label) = | |
| legalR F δ (rightAt F e) (edge F e label) := | |
| LocalCompletionGame.input_image_legal | |
| (game F μ) (legalL F δ) (legalR F δ) (defaultL F) e label | |
| omit [Finite I] [∀ index, Finite (V index)] [Finite B] | |
| [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| theorem input_independent_of_law (μ ν : FiniteDistribution E) (δ : ℚ) (e : E) : | |
| input F μ δ e = input F ν δ e := rfl | |
| omit [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| theorem input_admissible (μ : FiniteDistribution E) (δ : ℚ) (e : E) : | |
| LocalCompletionFamily.Admissible (input F μ δ e) := | |
| LocalCompletionGame.input_admissible | |
| (game F μ) (legalL F δ) (legalR F δ) (defaultL F) (by | |
| intro occurrence label | |
| rw [Fintype.card_eq_nat_card] | |
| have h := small F μ occurrence label | |
| rw [Fintype.card_eq_nat_card] at h | |
| exact h) e | |
| def result (μ : FiniteDistribution E) (δ : ℚ) (e : E) : | |
| LocalCompletionFamily.Result (alphabet n δ) := | |
| LocalCompletionFamily.lookup (alphabet_positive n δ) (input F μ δ e) | |
| omit [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| theorem result_correct (μ : FiniteDistribution E) (δ : ℚ) (e : E) : | |
| LocalCompletionFamily.Correct (input F μ δ e) (result F μ δ e) := | |
| LocalCompletionFamily.lookup_correct (alphabet_positive n δ) _ (input_admissible F μ δ e) | |
| def family (μ : FiniteDistribution E) (δ : ℚ) : | |
| (game F μ).CompletionFamily (legalL F δ) (legalR F δ) := | |
| LocalCompletionGame.family (game F μ) (legalL F δ) (legalR F δ) (defaultL F) | |
| (alphabet_positive n δ) (by | |
| intro occurrence label | |
| rw [Fintype.card_eq_nat_card] | |
| have h := small F μ occurrence label | |
| rw [Fintype.card_eq_nat_card] at h | |
| exact h) | |
| omit [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| @[simp] theorem family_size (μ : FiniteDistribution E) (δ : ℚ) (e : E) : | |
| (family F μ δ).size e = LocalCompletionFamily.activeCount (result F μ δ e) := rfl | |
| omit [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| @[simp] theorem family_map (μ : FiniteDistribution E) (δ : ℚ) (e : E) : | |
| (family F μ δ).map e = LocalCompletionFamily.table (result F μ δ e) := rfl | |
| omit [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| theorem family_size_le (μ : FiniteDistribution E) (δ : ℚ) (e : E) : | |
| (family F μ δ).size e ≤ 2 * alphabet n δ := | |
| LocalCompletionFamily.activeCount_le (result F μ δ e) | |
| def machine_output (μ : FiniteDistribution E) (δ : ℚ) (e : E) : | |
| TM2OutputsInTime | |
| (LocalCompletionSerialization.computation (alphabet_positive n δ)).tm | |
| (LocalCompletionMachine.inputBits (input F μ δ e)) | |
| (some (LocalCompletionSerialization.payloadBits (result F μ δ e))) 1 := | |
| LocalCompletionSerialization.machine_output (alphabet_positive n δ) (input F μ δ e) | |
| omit [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| theorem payload_parses (μ : FiniteDistribution E) (δ : ℚ) (e : E) : | |
| decodeWords (LocalCompletionSerialization.payloadBits (result F μ δ e)) >>= | |
| LocalCompletionSerialization.parsePayload (alphabet n δ) = | |
| some ((List.finRange (LocalCompletionFamily.activeCount (result F μ δ e))).map | |
| (LocalCompletionSerialization.projection (result_correct F μ δ e))) := by | |
| rw [LocalCompletionSerialization.decode_payloadBits] | |
| exact LocalCompletionSerialization.parse_payload (result_correct F μ δ e) | |
| omit [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| theorem parsed_projection_eq_family_map (μ : FiniteDistribution E) (δ : ℚ) (e : E) | |
| (seed : Fin ((family F μ δ).size e)) (a : Fin (2 * alphabet n δ)) : | |
| (LocalCompletionSerialization.projection (result_correct F μ δ e) seed).images[a] = | |
| (family F μ δ).map e seed a := | |
| LocalCompletionSerialization.projection_apply (result_correct F μ δ e) seed a | |
| omit [Finite I] [∀ index, Finite (V index)] [Finite B] | |
| [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ vertex, Fintype (RightLabel F vertex)] in | |
| theorem payload_length_le (μ : FiniteDistribution E) (δ : ℚ) (e : E) : | |
| (LocalCompletionSerialization.payloadBits (result F μ δ e)).length ≤ | |
| (1 + (2 * alphabet n δ) * (2 * alphabet n δ)) * (2 * alphabet n δ + 1) := | |
| LocalCompletionSerialization.payloadBits_length_le _ | |
| theorem family_value_le (μ : FiniteDistribution E) (δ : ℚ) (hδ : 0 < δ) : | |
| (family F μ δ).game.value ≤ (game F μ).value + (δ : ℝ) / 3 := by | |
| apply (family F μ δ).value_le_of_bound ((δ : ℝ) / 3) | |
| intro e | |
| have hδreal : (0 : ℝ) < (δ : ℝ) := by exact_mod_cast hδ | |
| have h := CompletionParameters.residual_le_third (alphabet_positive n δ) | |
| (leftLabel_card_le F δ (leftAt F e)) hδreal | |
| (CompletionAlphabet.size_budget (partitionWidth n) δ hδ) | |
| simp only [Fintype.card_fin] | |
| rw [Fintype.card_eq_nat_card] | |
| rw [Fintype.card_eq_nat_card] at h | |
| simpa only [CanonicalGame.game] using h | |
| theorem family_value_of_satisfying (μ : FiniteDistribution E) (δ : ℚ) | |
| (assignment : Fin v → Bool) (hsat : ∀ c, (clauses c).clause.eval assignment = true) : | |
| (family F μ δ).game.value = 1 := by | |
| let : Nonempty E := by | |
| by_contra hempty | |
| have : IsEmpty E := ⟨fun e => hempty ⟨e⟩⟩ | |
| have hnormalized := μ.normalized | |
| simp at hnormalized | |
| apply (family F μ δ).value_eq_one | |
| exact CanonicalOutput.game_value_of_satisfying F μ assignment hsat | |
| end | |
| end PerfectCompleteness.CanonicalLocalCompletion | |
| end | |
| end OAI | |