openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Reduction /CompletionAlphabetLemmas.lean
| import OAI.Computability.PerfectCompleteness.Algebra.HierarchicalMatrixTable | |
| import OAI.Computability.PerfectCompleteness.Decoding.Projection | |
| import OAI.Computability.PerfectCompleteness.Foundations.HierarchicalArrays | |
| import OAI.Computability.PerfectCompleteness.Machines.EncodingLemmas | |
| import OAI.Computability.PerfectCompleteness.Reduction.CanonicalGameLemmas | |
| import OAI.Computability.PerfectCompleteness.Reduction.CompletionOutputLemmas | |
| import OAI.Computability.PerfectCompleteness.Sampling.CompletionProbability | |
| namespace OAI | |
| namespace PerfectCompleteness.CompletionAlphabet | |
| open scoped Classical | |
| open UniqueGamesTheorem.Foundations.Games | |
| open WeightRounding CompletionSoundness CompletionParameters | |
| def size (cap : Nat) (δ : ℚ) : Nat := max (cap + 1) ⌈(6 : ℚ) / δ⌉₊ | |
| theorem size_positive (cap : Nat) (δ : ℚ) : 0 < size cap δ := by | |
| have h : cap + 1 ≤ size cap δ := le_max_left _ _ | |
| omega | |
| theorem cap_le_size (cap : Nat) (δ : ℚ) : cap ≤ size cap δ := | |
| (Nat.le_succ cap).trans (le_max_left _ _) | |
| theorem size_budget (cap : Nat) (δ : ℚ) (hδ : 0 < δ) : | |
| (6 : ℝ) ≤ (δ : ℝ) * size cap δ := by | |
| have hceil : (6 : ℚ) / δ ≤ (⌈(6 : ℚ) / δ⌉₊ : ℚ) := Nat.le_ceil _ | |
| have hsize : (⌈(6 : ℚ) / δ⌉₊ : ℚ) ≤ (size cap δ : ℚ) := by | |
| exact_mod_cast (le_max_right (cap + 1) ⌈(6 : ℚ) / δ⌉₊) | |
| have hprod : (6 : ℚ) ≤ δ * size cap δ := by | |
| have h := (div_le_iff₀ hδ).1 (hceil.trans hsize) | |
| simpa only [mul_comm] using h | |
| exact_mod_cast hprod | |
| theorem exists_target {m l r : Nat} {L : Fin l → Type*} {R : Fin r → Type*} | |
| [∀ x, Fintype (L x)] [∀ y, Fintype (R y)] | |
| [∀ x, Nonempty (L x)] [∀ y, Nonempty (R y)] | |
| (G : LegalProjectionGame (Fin m) (Fin l) (Fin r) L R) | |
| (w : PositiveWeights m) | |
| (hweights : ∀ e, G.occurrences.weight e = (w.weight e : ℝ)) | |
| (hsmall : ∀ e b, Fintype.card {a : L (G.left e) // G.projection e a = b} ≤ 2) | |
| (cap : Nat) (hleft : ∀ x, Fintype.card (L x) ≤ cap) | |
| (hright : ∀ y, Fintype.card (R y) ≤ cap) | |
| (δ : ℚ) (hδ : 0 < δ) : | |
| let q := size cap δ | |
| let M := ⌈(3 : ℚ) / δ⌉₊ * m * (2 * q) | |
| ∃ target : Instance q, | |
| target.leftVertices = l ∧ target.rightVertices = r ∧ | |
| target.edges.length ≤ M ∧ | |
| (Encoding.gameBits target).length ≤ | |
| l + r + q + M + 4 + M * (l + r + 2 * q * q + 2 * q + 2) ∧ | |
| (G.value = 1 → PerfectlyComplete target) ∧ | |
| (G.value ≤ (δ : ℝ) / 3 → target.value ≤ (δ : ℝ)) := by | |
| let q := size cap δ | |
| let M := ⌈(3 : ℚ) / δ⌉₊ * m * (2 * q) | |
| have hleftq : ∀ x, Fintype.card (L x) ≤ q := | |
| fun x => (hleft x).trans (cap_le_size cap δ) | |
| have hrightq : ∀ y, Fintype.card (R y) ≤ q := | |
| fun y => (hright y).trans (cap_le_size cap δ) | |
| obtain ⟨target, hl, hr, he, hc, hs⟩ := CompletionParameters.exists_target | |
| G w hweights hsmall hleftq hrightq δ hδ (size_positive cap δ) (size_budget cap δ hδ) | |
| refine ⟨target, hl, hr, he, ?_, hc, hs⟩ | |
| have hb := Encoding.gameBits_length_le_of_edge_count target M he | |
| simpa only [hl, hr] using hb | |
| end PerfectCompleteness.CompletionAlphabet | |
| namespace PerfectCompleteness | |
| open CompletionProbability | |
| theorem exists_completion_tables {l q : Nat} | |
| (legal : Fin l ↪ Fin (2 * q)) (p : Fin l → Fin q) | |
| (hsmall : ∀ b, Fintype.card {a : Fin l // p a = b} ≤ 2) : | |
| ∃ n : Nat, 0 < n ∧ ∃ tables : Fin n → ProjectionTable q, | |
| (∀ seed a, (tables seed).images[legal a] = p a) ∧ | |
| ∀ (a : Illegal legal) (b : Fin q), | |
| uniformProbability (fun seed => (tables seed).images[a.val] = b) ≤ | |
| 2 / (2 * q - l : Nat) := by | |
| classical | |
| obtain ⟨n, hn, sampler, hext, hexact, hprob⟩ := | |
| exists_completion_sampler legal p | |
| (by intro b; simpa only [← Nat.card_eq_fintype_card] using hsmall b) (by simp) | |
| let tables : Fin n → ProjectionTable q := fun seed => | |
| ProjectionTable.ofMap (sampler seed) (by | |
| simpa only [← Nat.card_eq_fintype_card] using hexact seed) | |
| refine ⟨n, hn, tables, ?_, ?_⟩ | |
| · intro seed a | |
| simpa [tables, ProjectionTable.ofMap] using hext seed a | |
| · intro a b | |
| simpa [tables, ProjectionTable.ofMap] using (hprob a b).2 | |
| end PerfectCompleteness | |
| namespace PerfectCompleteness.HierarchicalGame | |
| open HierarchicalArrays | |
| open UniqueGamesTheorem.Foundations.Games | |
| structure Family {v m : Nat} (clauses : Fin m → SourceClause.NormalizedClause v) | |
| (branch : Nat → Nat) (n t : Nat) (rows : Nat → Nat) (E : Type*) where | |
| endpoints : E → RecursiveSpaces.Slots branch n → Fin t → SourceKeys.Endpoint v m | |
| arrays : ∀ e, Arrays (sourceSlots clauses (endpoints e)) rows | |
| selected : E → Nodes branch n | |
| direction : ∀ e, Block rows (selected e) | |
| nonzero : ∀ e, direction e ≠ 0 | |
| noncomputable section | |
| variable {v m n t : Nat} {clauses : Fin m → SourceClause.NormalizedClause v} | |
| {branch rows : Nat → Nat} {E : Type*} | |
| (F : Family clauses branch n t rows E) | |
| def toBlockFamily : CanonicalGame.BlockFamily clauses | |
| (TreeCanonical.locationCount branch n t) E (Nodes branch n) | |
| (fun node : Nodes branch n => Block rows node) PUnit.{1} where | |
| presentation e := HierarchicalArrays.presentation clauses (F.endpoints e) rows (F.arrays e) | |
| selected := F.selected | |
| direction := F.direction | |
| nonzero := F.nonzero | |
| abbrev LeftVertex := CanonicalGame.LeftVertex (toBlockFamily F) | |
| abbrev RightVertex := CanonicalGame.RightVertex (toBlockFamily F) | |
| abbrev LeftLabel (q : LeftVertex F) := CanonicalGame.LeftLabel (toBlockFamily F) q | |
| abbrev RightLabel (q : RightVertex F) := CanonicalGame.RightLabel (toBlockFamily F) q | |
| abbrev leftAt (e : E) : LeftVertex F := CanonicalGame.leftAt (toBlockFamily F) e | |
| abbrev rightAt (e : E) : RightVertex F := CanonicalGame.rightAt (toBlockFamily F) e | |
| theorem leftVertex_finite [Finite E] : Finite (LeftVertex F) := by infer_instance | |
| theorem rightVertex_finite [Finite E] : Finite (RightVertex F) := by infer_instance | |
| theorem leftLabel_finite (q : LeftVertex F) : Finite (LeftLabel F q) := by infer_instance | |
| theorem rightLabel_finite (q : RightVertex F) : Finite (RightLabel F q) := by infer_instance | |
| theorem leftKey_eq (e : E) : | |
| CanonicalGame.leftKey (toBlockFamily F) e = | |
| TreeCanonical.key .left (sourceSlots clauses (F.endpoints e)) (fullJoint (F.arrays e)) := rfl | |
| theorem rightKey_eq (e : E) : | |
| CanonicalGame.rightKey (toBlockFamily F) e = | |
| TreeCanonical.key .right (sourceSlots clauses (F.endpoints e)) | |
| (BlockQuotient.projectBlock (F.selected e) (F.direction e) ∘ fullJoint (F.arrays e)) := rfl | |
| abbrev edge (e : E) (P : LeftLabel F (leftAt F e)) : RightLabel F (rightAt F e) := | |
| CanonicalGame.edge (toBlockFamily F) e P | |
| theorem edge_eq_iff (e : E) (P : LeftLabel F (leftAt F e)) | |
| (Q : RightLabel F (rightAt F e)) : | |
| edge F e P = Q ↔ | |
| BlockQuotient.projectBlock (F.selected e) (F.direction e) | |
| (TreeCanonical.restore (sourceSlots clauses (F.endpoints e)) (fullJoint (F.arrays e)) P) = | |
| TreeCanonical.restore (sourceSlots clauses (F.endpoints e)) | |
| (BlockQuotient.projectBlock (F.selected e) (F.direction e) ∘ fullJoint (F.arrays e)) Q := by | |
| change CanonicalKeys.Label | |
| (TreeCanonical.numberedSlots (sourceSlots clauses (F.endpoints e))) | |
| (BlockQuotient.projectBlock (F.selected e) (F.direction e) ∘ | |
| TreeCanonical.numberedFunction (sourceSlots clauses (F.endpoints e)) | |
| (fullJoint (F.arrays e))) at Q | |
| exact CanonicalEdges.coarsen_eq_iff | |
| (TreeCanonical.numberedSlots (sourceSlots clauses (F.endpoints e))) | |
| (TreeCanonical.numberedFunction (sourceSlots clauses (F.endpoints e)) (fullJoint (F.arrays e))) | |
| (BlockQuotient.projectBlock (F.selected e) (F.direction e)) P Q | |
| theorem edge_at_most_two (e : E) (Q : RightLabel F (rightAt F e)) : | |
| Nat.card {P : LeftLabel F (leftAt F e) // edge F e P = Q} ≤ 2 := | |
| CanonicalGame.edge_at_most_two (toBlockFamily F) e Q | |
| def game [Fintype E] (μ : FiniteDistribution E) : | |
| CompletionSoundness.LegalProjectionGame E (LeftVertex F) (RightVertex F) | |
| (LeftLabel F) (RightLabel F) := | |
| CanonicalGame.game (toBlockFamily F) μ | |
| def satisfyingStrategy (assignment : Fin v → Bool) | |
| (hsat : ∀ c, (clauses c).clause.eval assignment = true) : | |
| CompletionSoundness.LegalStrategy (LeftLabel F) (RightLabel F) := | |
| CanonicalGame.satisfyingStrategy (toBlockFamily F) assignment hsat | |
| theorem edge_satisfyingStrategy (assignment : Fin v → Bool) | |
| (hsat : ∀ c, (clauses c).clause.eval assignment = true) (e : E) : | |
| edge F e ((satisfyingStrategy F assignment hsat).1 (leftAt F e)) = | |
| (satisfyingStrategy F assignment hsat).2 (rightAt F e) := | |
| CanonicalGame.edge_strategy (toBlockFamily F) assignment hsat e | |
| theorem success_satisfyingStrategy [Fintype E] (μ : FiniteDistribution E) | |
| (assignment : Fin v → Bool) (hsat : ∀ c, (clauses c).clause.eval assignment = true) : | |
| (game F μ).success (satisfyingStrategy F assignment hsat) = 1 := | |
| CanonicalGame.success_satisfyingStrategy (toBlockFamily F) μ assignment hsat | |
| theorem value_eq_one [Fintype E] | |
| [Fintype (LeftVertex F)] [Fintype (RightVertex F)] | |
| [∀ q, Fintype (LeftLabel F q)] [∀ q, Fintype (RightLabel F q)] | |
| (μ : FiniteDistribution E) (assignment : Fin v → Bool) | |
| (hsat : ∀ c, (clauses c).clause.eval assignment = true) : (game F μ).value = 1 := by | |
| apply le_antisymm | |
| · obtain ⟨strategy, hs⟩ := (game F μ).exists_optimal_strategy | |
| rw [← hs] | |
| exact (game F μ).occurrences.probability_le_one _ | |
| · have h := (game F μ).success_le_value (satisfyingStrategy F assignment hsat) | |
| simpa only [success_satisfyingStrategy F μ assignment hsat] using h | |
| end | |
| end PerfectCompleteness.HierarchicalGame | |
| namespace PerfectCompleteness.HierarchicalGameTable | |
| noncomputable section | |
| open HierarchicalArrays | |
| variable {v m n t : Nat} {clauses : Fin m → SourceClause.NormalizedClause v} | |
| {branch rows : Nat → Nat} {E : Type*} | |
| (F : HierarchicalGame.Family clauses branch n t rows E) | |
| (s : CompletionSoundness.LegalStrategy (HierarchicalGame.LeftLabel F) | |
| (HierarchicalGame.RightLabel F)) | |
| def strategy : KeyStrategy.Strategy (TreeCanonical.locationCount branch n t) := | |
| CanonicalGameStrategy.extend (HierarchicalGame.toBlockFamily F) s | |
| def background (e : E) : | |
| HierarchicalMatrixTable.Background (rows := rows) | |
| (sourceSlots clauses (F.endpoints e)) (F.selected e) := | |
| HierarchicalMatrixTable.backgroundOf (sourceSlots clauses (F.endpoints e)) | |
| (F.selected e) (F.arrays e) | |
| def matrix (e : E) : | |
| HierarchicalMatrixTable.Matrix (rows := rows) | |
| (sourceSlots clauses (F.endpoints e)) (F.selected e) := | |
| NodeEmbedding.matrix (F.arrays e) (F.selected e) | |
| theorem accepts_iff (e : E) : | |
| CanonicalMatrixTable.Accepts | |
| (TreeCanonical.numberedSlots (sourceSlots clauses (F.endpoints e))) | |
| (NodeEmbedding.RowSpace (sourceSlots clauses (F.endpoints e)) (F.selected e)) | |
| (HierarchicalMatrixTable.other (sourceSlots clauses (F.endpoints e)) | |
| (F.selected e) (background F e)) | |
| (strategy F s) (F.direction e) (matrix F e) ↔ | |
| HierarchicalGame.edge F e (s.1 (HierarchicalGame.leftAt F e)) = | |
| s.2 (HierarchicalGame.rightAt F e) := by | |
| unfold background matrix | |
| rw [HierarchicalMatrixTable.accepts_iff_canonical, | |
| HierarchicalMatrixTable.displayed_original] | |
| exact CanonicalGameStrategy.accepts_extend_iff (HierarchicalGame.toBlockFamily F) s e | |
| end | |
| end PerfectCompleteness.HierarchicalGameTable | |
| end OAI | |