openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Reduction /FixedComparisonErrorsLemmas.lean
| import Mathlib.Tactic.Ring | |
| import OAI.Computability.PerfectCompleteness.Construction.HierarchicalAdviceFromBuckets | |
| import OAI.Computability.PerfectCompleteness.Decoding.HierarchicalDecoderMeetingLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.HierarchicalProjectedSliceLemmas | |
| import OAI.Computability.PerfectCompleteness.Reduction.FixedCallBudgetLemmas | |
| namespace OAI | |
| namespace PerfectCompleteness.FixedComparisonErrors | |
| open FixedParameters ChildBlockCardinality | |
| noncomputable section | |
| variable {δ : ℚ} {hδ : 0 < δ} (p : Parameters δ hδ) | |
| theorem comparison_errors {retained : Nat} (hcalls : retained ≤ calls p.plan) | |
| (height : Nat) : | |
| let L : ℝ := bound (branch p) height (FixedRows.sourceLength p.plan hδ) | |
| retained (FixedRows.rows p.plan) | |
| let m := p.cubeSize height | |
| Real.sqrt (L ^ 2 / (m : ℝ) ^ 3) / 2 < p.accuracy ∧ | |
| Real.sqrt ((1 + L ^ 2 / (m : ℝ) ^ 4) ^ (m ^ 3) - 1) / 2 < p.accuracy ∧ | |
| 2 * ((1 / (m : ℝ) ^ 2) * L / (1 - 1 / (m : ℝ) ^ 2)) < p.accuracy := by | |
| let L : ℝ := bound (branch p) height (FixedRows.sourceLength p.plan hδ) | |
| retained (FixedRows.rows p.plan) | |
| let B : ℝ := bound (branch p) height (FixedRows.sourceLength p.plan hδ) | |
| (calls p.plan) (FixedRows.rows p.plan) | |
| let m := p.cubeSize height | |
| have hL : 0 ≤ L := Nat.cast_nonneg _ | |
| have hB : 0 ≤ B := Nat.cast_nonneg _ | |
| have hLB : L ≤ B := by | |
| dsimp only [L, B] | |
| exact_mod_cast FixedCallBudget.child_bound_mono hcalls (branch p) height | |
| (FixedRows.sourceLength p.plan hδ) (FixedRows.rows p.plan) | |
| have hsq : L ^ 2 ≤ B ^ 2 := (sq_le_sq₀ hL hB).mpr hLB | |
| have hm : (2 : ℝ) ≤ m := by exact_mod_cast (p.cube_errors height).1 | |
| have hm2 : (0 : ℝ) < (m : ℝ) ^ 2 := by positivity | |
| have hprob : (1 : ℝ) / (m : ℝ) ^ 2 < 1 := by | |
| apply (div_lt_one hm2).mpr | |
| nlinarith | |
| have hfixed := (p.cube_errors height).2 | |
| change Real.sqrt (L ^ 2 / (m : ℝ) ^ 3) / 2 < p.accuracy ∧ | |
| Real.sqrt ((1 + L ^ 2 / (m : ℝ) ^ 4) ^ (m ^ 3) - 1) / 2 < p.accuracy ∧ | |
| 2 * ((1 / (m : ℝ) ^ 2) * L / (1 - 1 / (m : ℝ) ^ 2)) < p.accuracy | |
| refine ⟨?_, ?_, ?_⟩ | |
| · apply lt_of_le_of_lt _ hfixed.1 | |
| apply div_le_div_of_nonneg_right _ (by norm_num : (0 : ℝ) ≤ 2) | |
| apply Real.sqrt_le_sqrt | |
| exact div_le_div_of_nonneg_right hsq (by positivity) | |
| · apply lt_of_le_of_lt _ hfixed.2.1 | |
| apply div_le_div_of_nonneg_right _ (by norm_num : (0 : ℝ) ≤ 2) | |
| apply Real.sqrt_le_sqrt | |
| apply sub_le_sub_right | |
| apply pow_le_pow_left₀ (by positivity) | |
| exact add_le_add_right | |
| (div_le_div_of_nonneg_right hsq | |
| (by positivity : (0 : ℝ) ≤ (m : ℝ) ^ 4)) 1 | |
| · apply lt_of_le_of_lt _ hfixed.2.2.1 | |
| apply mul_le_mul_of_nonneg_left _ (by norm_num : (0 : ℝ) ≤ 2) | |
| apply div_le_div_of_nonneg_right _ (by linarith) | |
| exact mul_le_mul_of_nonneg_left hLB (by positivity) | |
| end | |
| end PerfectCompleteness.FixedComparisonErrors | |
| namespace PerfectCompleteness.HierarchicalFixedAdvice | |
| noncomputable section | |
| open scoped Classical | |
| open TreeSourceSpaces HierarchicalArrays | |
| open InitialParameters UpperParameterScalars | |
| open UniqueGamesTheorem.Foundations.Games | |
| open UniqueGamesTheorem.Appendix.RankLevelFilter (linearMapFintype) | |
| attribute [local instance] linearMapFintype | |
| variable {δ : ℚ} {hδ : 0 < δ} (p : FixedParameters.Parameters δ hδ) | |
| {branch : Nat → Nat} {t : Nat} {Ω P : Type*} [Fintype Ω] [Fintype P] | |
| (S : HierarchicalAdviceExperiment.Experiment branch (FixedRows.rows p.plan) p.plan.depth t Ω) | |
| local instance backgroundFintype : Fintype (HierarchicalAdviceExperiment.Background S) := | |
| Fintype.ofFinite _ | |
| local instance rowSpaceFintype : Fintype (NodeEmbedding.RowSpace S.slots S.upper) := | |
| Fintype.ofFinite _ | |
| local instance inputFintype : | |
| (b : HierarchicalAdviceExperiment.Background S) → Fintype (HierarchicalAdviceExperiment.Input S b) := | |
| HierarchicalAdviceExperiment.inputFintype S | |
| local instance inputFiniteDimensional : | |
| (b : HierarchicalAdviceExperiment.Background S) → | |
| FiniteDimensional F2 (HierarchicalAdviceExperiment.Input S b) := | |
| HierarchicalAdviceExperiment.inputFiniteDimensional S | |
| theorem rows_positive : 0 < FixedRows.rows p.plan (Nodes.height S.upper) := by | |
| exact p.plan.rows_pos (p.plan.depth - Nodes.height S.upper) | |
| theorem adviceFactor_eq : | |
| HierarchicalAdviceFromBuckets.adviceFactor S p.plan.order (inverse δ) = | |
| q (inverse δ) p.plan.order (FixedRows.rows p.plan (Nodes.height S.upper)) := by | |
| simp only [HierarchicalAdviceFromBuckets.adviceFactor, q, g, h, | |
| div_eq_mul_inv, pow_two] | |
| ring | |
| theorem paired_error_small : 10 * p.accuracy ≤ simultaneous δ ^ 2 / 16 := by | |
| have hs := p.accuracy_small 0 (Nat.zero_le _) | |
| simp only [CommonAccuracy.tolerance, lt_min_iff] at hs | |
| linarith [hs.2.1] | |
| theorem coarse_error_small : | |
| 10 * p.accuracy ≤ p.plan.density * | |
| HierarchicalAdviceFromBuckets.adviceFactor S p.plan.order (inverse δ) / 16 := by | |
| rw [adviceFactor_eq p S] | |
| have hs := p.accuracy_small (Nodes.height S.upper) (Nodes.height_le S.upper) | |
| simp only [CommonAccuracy.tolerance, lt_min_iff] at hs | |
| linarith [hs.2.2.1] | |
| variable (externalLaw : FiniteDistribution P) | |
| (background : P → HierarchicalAdviceExperiment.Background S) | |
| (scalarLaw : P → FiniteDistribution (NodeEmbedding.RowSpace S.slots S.upper)) | |
| theorem prediction_difference | |
| (hmass : simultaneous δ / 2 ≤ HierarchicalAdviceFromBuckets.usefulProbability | |
| S (useful δ) externalLaw background scalarLaw (rows_positive p S)) | |
| (hpaired : (HierarchicalAdviceFromBuckets.pairedLaw S externalLaw background | |
| scalarLaw (rows_positive p S)).totalVariation | |
| (HierarchicalAgreementMean.referenceLaw S.slots S.upper | |
| (HierarchicalAdviceFromBuckets.backgroundLaw S externalLaw background) | |
| (rows_positive p S)) ≤ 10 * p.accuracy) | |
| (hcoarse : ((HierarchicalAdviceExperiment.originalLaw S p.plan.order).pushforward | |
| (HierarchicalAdviceExperiment.observe S p.plan.order)).totalVariation | |
| ((HierarchicalAdviceExperiment.referenceLaw S | |
| (HierarchicalAdviceFromBuckets.backgroundLaw S externalLaw background) p.plan.order).pushforward (HierarchicalAdviceExperiment.referenceObserve S p.plan.order)) ≤ | |
| 10 * p.accuracy) : | |
| b (useful δ) p.plan.density (inverse δ) p.plan.order | |
| (FixedRows.rows p.plan (Nodes.height S.upper)) ≤ | |
| (HierarchicalAdviceExperiment.originalLaw S p.plan.order).probability | |
| (HierarchicalAdviceExperiment.prediction S (useful δ) p.plan.order p.plan.density) - | |
| rhoPred (useful δ) p.plan.density * | |
| (HierarchicalAdviceExperiment.originalLaw S p.plan.order).probability | |
| (fun x => HierarchicalAdviceExperiment.J S (useful δ) p.plan.order p.plan.density | |
| (HierarchicalAdviceExperiment.observe S p.plan.order x)) := by | |
| have hbound := HierarchicalAdviceFromBuckets.prediction_difference S (useful δ) | |
| externalLaw background scalarLaw (rows_positive p S) (useful_pos hδ).le | |
| (simultaneous δ) (simultaneous_pos hδ).le hmass | |
| (hpaired.trans (paired_error_small p)) | |
| p.plan.order p.plan.density (inverse δ) (10 * p.accuracy) | |
| (inverse_pos hδ) (by unfold inverse; linarith) | |
| p.plan.density_pos p.plan.density_lt p.plan.spectral | |
| (by have := p.accuracy_pos; positivity) (coarse_error_small p S) hcoarse | |
| rw [adviceFactor_eq p S] at hbound | |
| have hfactor : useful δ * p.plan.density * | |
| q (inverse δ) p.plan.order (FixedRows.rows p.plan (Nodes.height S.upper)) / 4 = | |
| b (useful δ) p.plan.density (inverse δ) p.plan.order | |
| (FixedRows.rows p.plan (Nodes.height S.upper)) := by | |
| unfold b rhoPred | |
| ring | |
| rw [hfactor] at hbound | |
| exact hbound | |
| theorem good_record_mass_ge {R : Type*} [Fintype R] | |
| (hmass : simultaneous δ / 2 ≤ HierarchicalAdviceFromBuckets.usefulProbability | |
| S (useful δ) externalLaw background scalarLaw (rows_positive p S)) | |
| (hpaired : (HierarchicalAdviceFromBuckets.pairedLaw S externalLaw background | |
| scalarLaw (rows_positive p S)).totalVariation | |
| (HierarchicalAgreementMean.referenceLaw S.slots S.upper | |
| (HierarchicalAdviceFromBuckets.backgroundLaw S externalLaw background) | |
| (rows_positive p S)) ≤ 10 * p.accuracy) | |
| (hcoarse : ((HierarchicalAdviceExperiment.originalLaw S p.plan.order).pushforward | |
| (HierarchicalAdviceExperiment.observe S p.plan.order)).totalVariation | |
| ((HierarchicalAdviceExperiment.referenceLaw S | |
| (HierarchicalAdviceFromBuckets.backgroundLaw S externalLaw background) p.plan.order).pushforward (HierarchicalAdviceExperiment.referenceObserve S p.plan.order)) ≤ | |
| 10 * p.accuracy) | |
| (record : Ω × HierarchicalAdviceExperiment.Advice S p.plan.order → R) : | |
| b (useful δ) p.plan.density (inverse δ) p.plan.order | |
| (FixedRows.rows p.plan (Nodes.height S.upper)) ≤ | |
| (HierarchicalAdviceExperiment.originalLaw S p.plan.order).probability | |
| (fun x => HierarchicalAdviceExperiment.J S (useful δ) p.plan.order p.plan.density | |
| (HierarchicalAdviceExperiment.observe S p.plan.order x) && | |
| PositiveFiberMass.goodRecord (HierarchicalAdviceExperiment.originalLaw S p.plan.order) record | |
| (fun y => HierarchicalAdviceExperiment.J S (useful δ) p.plan.order p.plan.density | |
| (HierarchicalAdviceExperiment.observe S p.plan.order y)) | |
| (HierarchicalAdviceExperiment.prediction S (useful δ) p.plan.order p.plan.density) | |
| (rhoPred (useful δ) p.plan.density) (record x)) := | |
| (prediction_difference p S externalLaw background scalarLaw hmass hpaired hcoarse).trans | |
| (HierarchicalAdviceExperiment.prediction_difference_le_good_mass S (useful δ) | |
| (useful_pos hδ).le p.plan.order p.plan.density p.plan.density_pos.le record) | |
| end | |
| end PerfectCompleteness.HierarchicalFixedAdvice | |
| namespace PerfectCompleteness.HierarchicalFixedProjectedMeeting | |
| noncomputable section | |
| open scoped Classical TensorProduct | |
| open TreeSourceSpaces HierarchicalArrays HierarchicalProjectedSlice | |
| open UpperParameterScalars | |
| open UniqueGamesTheorem.Foundations.Games | |
| open UniqueGamesTheorem.Appendix.RankLevelFilter (linearMapFintype) | |
| attribute [local instance] linearMapFintype | |
| attribute [local instance] RightDecoder.characterFintype RightDecoder.scalarFintype | |
| variable {δ : ℚ} (plan : FixedRows.Plan δ) (hδ : 0 < δ) | |
| {branch : Nat → Nat} {t : Nat} | |
| (slots projected : RecursiveSpaces.Slots branch plan.depth → Fin t → MixedSupport.Slot) | |
| (projection : ∀ s j, MixedSupport.Projection (slots s j) (projected s j)) | |
| (upper : Nodes branch plan.depth) (lowerLevel : Nat) | |
| (background : HierarchicalMatrixTable.Background | |
| (rows := FixedRows.rows plan) slots upper) | |
| local instance rowSpaceFintype : Fintype (NodeEmbedding.RowSpace slots upper) := | |
| Fintype.ofFinite _ | |
| local instance valueFintype : Fintype | |
| (Block (FixedRows.rows plan) upper × | |
| HierarchicalMatrixTable.SideOutput (rows := FixedRows.rows plan) upper) := | |
| Fintype.ofFinite _ | |
| local instance upperDualFintype : Fintype (Module.Dual F2 (NodeEmbedding.RowSpace slots upper)) := | |
| LeftDecoder.dualFintype (V := NodeEmbedding.RowSpace slots upper) | |
| variable {Ω : Type*} [Fintype Ω] | |
| (original : FiniteDistribution Ω) (arrays : Ω → Arrays slots (FixedRows.rows plan)) | |
| (lowerEvent : Ω → Bool) | |
| (σ : KeyStrategy.Strategy (TreeCanonical.locationCount branch plan.depth t)) | |
| (A : ManyGoodRows.RowMap (Block (FixedRows.rows plan) upper) plan.order) | |
| (known : HiddenBucketBias.VisibleDirection (LinearMap.ker A) → NodeEmbedding.NodeH projected upper) | |
| (lower : Nodes branch plan.depth) (a : Block (FixedRows.rows plan) lower) | |
| (cut : OwnInputReference.Cut upper lower) | |
| (input : OwnInputReference.Input projected (FixedRows.rows plan) upper lower (LinearMap.ker A) a) | |
| include hδ | |
| theorem meeting_probability_lower | |
| (hgood : VisibleGood slots projected projection upper lowerLevel background | |
| original arrays lowerEvent (InitialParameters.useful δ) σ plan.density A known) | |
| (hne : ∃ T, J slots projected projection upper lowerLevel background | |
| original arrays lowerEvent (InitialParameters.useful δ) σ plan.density A known T = true) | |
| (hmatch : rhoPred (InitialParameters.useful δ) plan.density ≤ | |
| RightDecoderWitness.conditionalMatch projected (FixedRows.rows plan) upper lower | |
| (LinearMap.ker A) a (FixedRows.repeats plan) cut σ input | |
| (columnSpace slots projected projection upper lowerLevel background | |
| original arrays lowerEvent (InitialParameters.useful δ) σ plan.density A known hgood) | |
| (target slots projected projection upper lowerLevel background | |
| original arrays lowerEvent (InitialParameters.useful δ) σ plan.density A known hgood hne) | |
| (nativeCorrection slots projected projection upper lowerLevel background | |
| original arrays lowerEvent (InitialParameters.useful δ) σ plan.density A known hgood) | |
| (visibleOffset slots projected projection upper lowerLevel background | |
| original arrays lowerEvent (InitialParameters.useful δ) σ plan.density A known hgood)) : | |
| (1 / (2 : ℝ) ^ plan.order) * | |
| (tau (InitialParameters.useful δ) plan.density plan.order | |
| (FixedRows.rows plan (Nodes.height upper)) ^ 2 / | |
| (2 * (2 : ℝ) ^ FixedRows.rows plan (Nodes.height upper))) ≤ | |
| ((HierarchicalProjectedMeeting.leftLaw slots projected projection upper lowerLevel | |
| background original arrays lowerEvent (InitialParameters.useful δ) σ plan.density A known).product | |
| (RightDecoder.law projected (FixedRows.rows plan) upper lower (LinearMap.ker A) a | |
| (FixedRows.repeats plan) cut σ input | |
| (tau (InitialParameters.useful δ) plan.density plan.order | |
| (FixedRows.rows plan (Nodes.height upper))))).probability | |
| (fun pair => decide ((ProjectedNodeEmbedding.intoOriginal projection upper).dualMap | |
| pair.1 = pair.2)) := by | |
| simpa only [UpperParameterScalars.tau] using | |
| (HierarchicalProjectedMeeting.meeting_probability_lower slots projected projection upper lowerLevel | |
| background original arrays lowerEvent (InitialParameters.useful δ) σ plan.density A known | |
| lower a (FixedRows.repeats plan) cut input hgood hne | |
| (rhoPred (InitialParameters.useful δ) plan.density) | |
| (h plan.order (FixedRows.rows plan (Nodes.height upper))) | |
| (rhoPred_pos (InitialParameters.useful_pos hδ) plan.density_pos) | |
| (h_pos plan.order (FixedRows.rows plan (Nodes.height upper))) | |
| (HierarchicalFixedDecoderMeeting.repetitionsBalanced plan) | |
| (HierarchicalFixedDecoderMeeting.slice_error plan (Nodes.height upper)) | |
| (HierarchicalFixedDecoderMeeting.list_error plan (Nodes.height upper)) | |
| (HierarchicalFixedDecoderMeeting.kernel_excluded plan (Nodes.height upper) A) | |
| le_rfl hmatch) | |
| end | |
| end PerfectCompleteness.HierarchicalFixedProjectedMeeting | |
| end OAI | |