openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Reduction /PreliminaryOutputLemmas.lean
| import OAI.Computability.PerfectCompleteness.Foundations.DualQuotientRowsLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.LegalRationalOutputLemmas | |
| import OAI.Computability.PerfectCompleteness.Reduction.FixedCallBudgetLemmas | |
| import OAI.Computability.PerfectCompleteness.Reduction.PreliminaryLevelPair | |
| import OAI.Computability.PerfectCompleteness.Sampling.SamplerCardinalityLemmas | |
| namespace OAI | |
| namespace PerfectCompleteness.PreliminaryOutput | |
| open HierarchicalArrays | |
| open scoped Classical | |
| noncomputable section | |
| variable {v m : Nat} [NeZero m] | |
| def value (clauses : Fin m → SourceClause.NormalizedClause v) | |
| (branch : Nat → Nat) (n t : Nat) (rows repeats : Nat → Nat) (hn : 0 < n) | |
| (hbranch : ∀ k < n, 0 < branch k) (hrows : ∀ k, 0 < rows (k + 1)) : ℝ := by | |
| let F := PreliminarySampler.family clauses branch n t rows repeats | |
| let : Fintype (HierarchicalGame.LeftVertex F) := Fintype.ofFinite _ | |
| let : Fintype (HierarchicalGame.RightVertex F) := Fintype.ofFinite _ | |
| let : ∀ x, Fintype (HierarchicalGame.LeftLabel F x) := fun _ => Fintype.ofFinite _ | |
| let : ∀ y, Fintype (HierarchicalGame.RightLabel F y) := fun _ => Fintype.ofFinite _ | |
| exact (PreliminarySampler.game clauses branch n t rows repeats hn hbranch hrows).value | |
| theorem exists_target (clauses : Fin m → SourceClause.NormalizedClause v) | |
| (branch : Nat → Nat) (n t : Nat) (rows repeats : Nat → Nat) (hn : 0 < n) | |
| (hbranch : ∀ k < n, 0 < branch k) (hrows : ∀ k, 0 < rows (k + 1)) | |
| (δ : ℚ) (hδ : 0 < δ) : | |
| let F := PreliminarySampler.family clauses branch n t rows repeats | |
| let q := CompletionAlphabet.size (Nat.card (Output branch n rows)) δ | |
| let M := ⌈(3 : ℚ) / δ⌉₊ * | |
| Nat.card (PreliminarySampler.Raw clauses branch n t rows repeats) * (2 * q) | |
| ∃ target : Instance q, | |
| 2 ≤ q ∧ | |
| target.leftVertices = Nat.card (HierarchicalGame.LeftVertex F) ∧ | |
| target.rightVertices = Nat.card (HierarchicalGame.RightVertex F) ∧ | |
| target.edges.length ≤ M ∧ | |
| (Encoding.gameBits target).length ≤ | |
| Nat.card (HierarchicalGame.LeftVertex F) + Nat.card (HierarchicalGame.RightVertex F) + | |
| q + M + 4 + M * | |
| (Nat.card (HierarchicalGame.LeftVertex F) + | |
| Nat.card (HierarchicalGame.RightVertex F) + 2 * q * q + 2 * q + 2) ∧ | |
| ((∃ assignment : Fin v → Bool, | |
| ∀ c, (clauses c).clause.eval assignment = true) → PerfectlyComplete target) ∧ | |
| (value clauses branch n t rows repeats hn hbranch hrows ≤ (δ : ℝ) / 3 → | |
| target.value ≤ (δ : ℝ)) := by | |
| let F := PreliminarySampler.family clauses branch n t rows repeats | |
| let : Nonempty (PreliminarySampler.Raw clauses branch n t rows repeats) := | |
| SamplerRationality.raw_nonempty (t := t) clauses rows repeats hn hbranch hrows | |
| let : Fintype (HierarchicalGame.LeftVertex F) := Fintype.ofFinite _ | |
| let : Fintype (HierarchicalGame.RightVertex F) := Fintype.ofFinite _ | |
| let : ∀ x, Fintype (HierarchicalGame.LeftLabel F x) := fun _ => Fintype.ofFinite _ | |
| let : ∀ y, Fintype (HierarchicalGame.RightLabel F y) := fun _ => Fintype.ofFinite _ | |
| let μ := PreliminarySampler.law (t := t) clauses rows repeats hn hbranch hrows | |
| let rational := SamplerRationality.preliminaryLaw (t := t) | |
| clauses rows repeats hn hbranch hrows | |
| have h := CanonicalRationalOutput.exists_target (HierarchicalGame.toBlockFamily F) | |
| μ rational.weights rational.positive rational.total rational.cast_weight δ hδ | |
| simpa only [← Nat.card_eq_fintype_card, value, PreliminarySampler.game, | |
| HierarchicalGame.game, F, μ] using h | |
| theorem exists_target_size_bound (clauses : Fin m → SourceClause.NormalizedClause v) | |
| (branch : Nat → Nat) (n t : Nat) (rows repeats : Nat → Nat) (hn : 0 < n) | |
| (hbranch : ∀ k < n, 0 < branch k) (hrows : ∀ k, 0 < rows (k + 1)) | |
| (δ : ℚ) (hδ : 0 < δ) : | |
| let q := CompletionAlphabet.size (Nat.card (Output branch n rows)) δ | |
| let R := SamplerCardinality.occurrenceConstant branch n t rows repeats * | |
| m ^ (t * Fintype.card (RecursiveSpaces.Slots branch n)) | |
| let M := ⌈(3 : ℚ) / δ⌉₊ * R * (2 * q) | |
| ∃ target : Instance q, | |
| 2 ≤ q ∧ target.leftVertices ≤ R ∧ target.rightVertices ≤ R ∧ | |
| target.edges.length ≤ M ∧ | |
| (Encoding.gameBits target).length ≤ | |
| 2 * R + q + M + 4 + M * (2 * R + 2 * q * q + 2 * q + 2) ∧ | |
| ((∃ assignment : Fin v → Bool, | |
| ∀ c, (clauses c).clause.eval assignment = true) → PerfectlyComplete target) ∧ | |
| (value clauses branch n t rows repeats hn hbranch hrows ≤ (δ : ℝ) / 3 → | |
| target.value ≤ (δ : ℝ)) := by | |
| let F := PreliminarySampler.family clauses branch n t rows repeats | |
| let q := CompletionAlphabet.size (Nat.card (Output branch n rows)) δ | |
| let R := SamplerCardinality.occurrenceConstant branch n t rows repeats * | |
| m ^ (t * Fintype.card (RecursiveSpaces.Slots branch n)) | |
| let M := ⌈(3 : ℚ) / δ⌉₊ * R * (2 * q) | |
| obtain ⟨target, hq, htL, htR, htE, _htBits, hc, hs⟩ := | |
| exists_target clauses branch n t rows repeats hn hbranch hrows δ hδ | |
| have hraw : Nat.card (PreliminarySampler.Raw clauses branch n t rows repeats) ≤ R := | |
| SamplerCardinality.raw_card_le clauses branch n t rows repeats | |
| have hlraw : Nat.card (HierarchicalGame.LeftVertex F) ≤ | |
| Nat.card (PreliminarySampler.Raw clauses branch n t rows repeats) := by | |
| apply Nat.card_le_card_of_surjective (HierarchicalGame.leftAt F) | |
| rintro ⟨key, e, rfl⟩ | |
| exact ⟨e, rfl⟩ | |
| have hrraw : Nat.card (HierarchicalGame.RightVertex F) ≤ | |
| Nat.card (PreliminarySampler.Raw clauses branch n t rows repeats) := by | |
| apply Nat.card_le_card_of_surjective (HierarchicalGame.rightAt F) | |
| rintro ⟨key, e, rfl⟩ | |
| exact ⟨e, rfl⟩ | |
| have hl : target.leftVertices ≤ R := htL.le.trans (hlraw.trans hraw) | |
| have hr : target.rightVertices ≤ R := htR.le.trans (hrraw.trans hraw) | |
| have he : target.edges.length ≤ M := | |
| htE.trans (Nat.mul_le_mul_right (2 * q) | |
| (Nat.mul_le_mul_left ⌈(3 : ℚ) / δ⌉₊ hraw)) | |
| refine ⟨target, hq, hl, hr, he, ?_, hc, hs⟩ | |
| apply (Encoding.gameBits_length_le_of_edge_count target M he).trans | |
| have hvertices : target.leftVertices + target.rightVertices ≤ 2 * R := by omega | |
| have hheader := Nat.add_le_add_right | |
| (Nat.add_le_add_right (Nat.add_le_add_right hvertices q) M) 4 | |
| have hbody := Nat.add_le_add_right | |
| (Nat.add_le_add_right (Nat.add_le_add_right hvertices (2 * q * q)) (2 * q)) 2 | |
| exact Nat.add_le_add hheader (Nat.mul_le_mul_left M hbody) | |
| end | |
| end PerfectCompleteness.PreliminaryOutput | |
| namespace PerfectCompleteness.FixedPreliminaryGame | |
| open FixedParameters FixedRows | |
| noncomputable section | |
| variable {δ : ℚ} {hδ : 0 < δ} (p : Parameters δ hδ) | |
| theorem depth_pos : 0 < p.plan.depth := by have := p.plan.depth_ge; omega | |
| theorem rows_pos (height : Nat) : 0 < rows p.plan height := | |
| lt_of_lt_of_le Nat.zero_lt_one (p.plan.rows_pos (p.plan.depth - height)) | |
| def game (input : List Bool) := | |
| PreliminarySampler.game (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) | |
| (branch p) p.plan.depth (sourceLength p.plan hδ) (rows p.plan) (repeats p.plan) | |
| (depth_pos p) (fun k _ => branch_pos p k) (fun k => rows_pos p (k + 1)) | |
| abbrev Strategy (input : List Bool) := | |
| PreliminaryStrategy.Strategy (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) | |
| (branch p) p.plan.depth (sourceLength p.plan hδ) (rows p.plan) (repeats p.plan) | |
| def value (input : List Bool) : ℝ := | |
| PreliminaryOutput.value (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) | |
| (branch p) p.plan.depth (sourceLength p.plan hδ) (rows p.plan) (repeats p.plan) | |
| (depth_pos p) (fun k _ => branch_pos p k) (fun k => rows_pos p (k + 1)) | |
| theorem completeness (input : List Bool) (accepted : BinaryLanguage.language input) : | |
| value p input = 1 := by | |
| obtain ⟨assignment, satisfies⟩ := | |
| (PCPSourceMachine.rawSource_satisfiable_iff input).mpr accepted | |
| let F := PreliminarySampler.family (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) | |
| (branch p) p.plan.depth (sourceLength p.plan hδ) (rows p.plan) (repeats p.plan) | |
| let : Fintype (HierarchicalGame.LeftVertex F) := Fintype.ofFinite _ | |
| let : Fintype (HierarchicalGame.RightVertex F) := Fintype.ofFinite _ | |
| let : ∀ x, Fintype (HierarchicalGame.LeftLabel F x) := fun _ => Fintype.ofFinite _ | |
| let : ∀ y, Fintype (HierarchicalGame.RightLabel F y) := fun _ => Fintype.ofFinite _ | |
| unfold value PreliminaryOutput.value | |
| apply HierarchicalGame.value_eq_one F _ assignment | |
| intro occurrence | |
| exact satisfies _ (List.getElem_mem occurrence.isLt) | |
| theorem exists_level_pair (input : List Bool) (strategy : Strategy p input) | |
| (hsuccess : InitialParameters.epsilon δ ≤ (game p input).success strategy) : | |
| ∃ i j : Fin p.plan.depth, i < j ∧ InitialParameters.simultaneous δ ≤ | |
| (CandidateCoupling.sharedLaw | |
| (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) | |
| (rows p.plan) (repeats p.plan) | |
| (fun k _ => branch_pos p k) (fun k => rows_pos p (k + 1))).probability | |
| (fun e => PreliminaryLevelPair.win | |
| (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) strategy i e && | |
| PreliminaryLevelPair.win | |
| (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) strategy j e) := | |
| PreliminaryLevelPair.exists_pair | |
| (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) | |
| (depth_pos p) (fun k _ => branch_pos p k) (fun k => rows_pos p (k + 1)) | |
| strategy (InitialParameters.epsilon_pos hδ) p.plan.depth_mass hsuccess | |
| end | |
| end PerfectCompleteness.FixedPreliminaryGame | |
| namespace PerfectCompleteness.FixedPreliminaryValue | |
| open FixedParameters FixedRows FixedPreliminaryGame | |
| noncomputable section | |
| variable {δ : ℚ} {hδ : 0 < δ} (p : Parameters δ hδ) | |
| theorem exists_optimal_strategy (input : List Bool) : | |
| ∃ strategy : Strategy p input, | |
| (game p input).success strategy = value p input := by | |
| let F := PreliminarySampler.family (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) | |
| (branch p) p.plan.depth (sourceLength p.plan hδ) (rows p.plan) (repeats p.plan) | |
| let : Fintype (HierarchicalGame.LeftVertex F) := Fintype.ofFinite _ | |
| let : Fintype (HierarchicalGame.RightVertex F) := Fintype.ofFinite _ | |
| let : ∀ x, Fintype (HierarchicalGame.LeftLabel F x) := fun _ => Fintype.ofFinite _ | |
| let : ∀ y, Fintype (HierarchicalGame.RightLabel F y) := fun _ => Fintype.ofFinite _ | |
| exact (game p input).exists_optimal_strategy | |
| theorem value_lt_of_strategy_lt (input : List Bool) (bound : ℝ) | |
| (hbound : ∀ strategy : Strategy p input, (game p input).success strategy < bound) : | |
| value p input < bound := by | |
| obtain ⟨strategy, hs⟩ := exists_optimal_strategy p input | |
| rw [← hs] | |
| exact hbound strategy | |
| theorem value_le_of_no_large_strategy (input : List Bool) (bound : ℝ) | |
| (hbound : ∀ strategy : Strategy p input, ¬bound ≤ (game p input).success strategy) : | |
| value p input ≤ bound := | |
| le_of_lt (value_lt_of_strategy_lt p input bound (fun strategy => | |
| lt_of_not_ge (hbound strategy))) | |
| end | |
| end PerfectCompleteness.FixedPreliminaryValue | |
| namespace PerfectCompleteness.PreliminaryPairReserve | |
| open FixedParameters FixedRows | |
| open scoped BigOperators | |
| noncomputable section | |
| variable {δ : ℚ} {hδ : 0 < δ} (p : Parameters δ hδ) | |
| theorem exists_pair (input : List Bool) (strategy : FixedPreliminaryGame.Strategy p input) | |
| (hsuccess : InitialParameters.epsilon δ ≤ | |
| (FixedPreliminaryGame.game p input).success strategy) : | |
| ∃ i j : Fin p.plan.depth, i < j ∧ | |
| InitialParameters.simultaneous δ + 3 * p.accuracy ≤ | |
| (CandidateCoupling.sharedLaw | |
| (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) | |
| (rows p.plan) (repeats p.plan) | |
| (fun k _ => branch_pos p k) | |
| (fun k => FixedPreliminaryGame.rows_pos p (k + 1))).probability | |
| (fun e => PreliminaryLevelPair.win | |
| (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) strategy i e && | |
| PreliminaryLevelPair.win | |
| (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) strategy j e) := by | |
| have hmean : InitialParameters.epsilon δ ≤ | |
| 𝔼 level : Fin p.plan.depth, | |
| (CandidateCoupling.sharedLaw | |
| (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) | |
| (rows p.plan) (repeats p.plan) | |
| (fun k _ => branch_pos p k) | |
| (fun k => FixedPreliminaryGame.rows_pos p (k + 1))).probability | |
| (PreliminaryLevelPair.win | |
| (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) strategy level) := by | |
| rw [← PreliminaryLevelPair.success_eq_mean | |
| (PCPSource.clauseFamily (BinaryLanguage.totalRename input)) | |
| (FixedPreliminaryGame.depth_pos p) (fun k _ => branch_pos p k) | |
| (fun k => FixedPreliminaryGame.rows_pos p (k + 1)) strategy] | |
| exact hsuccess | |
| obtain ⟨i, j, hij, hprob⟩ := LevelPairReserve.exists_pair _ _ | |
| (InitialParameters.epsilon δ) (InitialParameters.epsilon_pos hδ) | |
| hmean p.plan.depth_mass | |
| refine ⟨i, j, hij, ?_⟩ | |
| have hsmall := p.accuracy_small 0 (Nat.zero_le _) | |
| simp only [CommonAccuracy.tolerance, lt_min_iff] at hsmall | |
| have hε := InitialParameters.epsilon_pos hδ | |
| have hreserved : InitialParameters.simultaneous δ + 3 * p.accuracy ≤ | |
| 2 * InitialParameters.epsilon δ ^ 2 / 3 := by | |
| unfold InitialParameters.simultaneous | |
| nlinarith [hsmall.1, sq_pos_of_pos hε] | |
| exact hreserved.trans hprob | |
| end | |
| end PerfectCompleteness.PreliminaryPairReserve | |
| end OAI | |