openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Construction /OriginalHiddenChild.lean
| import OAI.Computability.PerfectCompleteness.Construction.OriginalChildBlocks | |
| import OAI.Computability.PerfectCompleteness.Construction.SourceQuestionOrderLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.GeometricPathLemmas | |
| import OAI.Computability.PerfectCompleteness.Reduction.CompletionSoundness | |
| namespace OAI | |
| section | |
| namespace PerfectCompleteness.OriginalHiddenChild | |
| open RecursiveSpaces DescendantSpaces TreeSourceSpaces HierarchicalArrays | |
| open UniqueGamesTheorem.Foundations.Games | |
| open scoped BigOperators Classical | |
| noncomputable section | |
| private theorem sigmaLaw_pushforward {E Γ : Type*} {F : E → Type*} | |
| [Fintype E] [∀ e, Fintype (F e)] [Fintype Γ] | |
| (μ : FiniteDistribution E) (ν : ∀ e, FiniteDistribution (F e)) | |
| (f : ∀ e, F e → Γ) : | |
| (CompletionSoundness.sigmaLaw μ ν).pushforward (fun x => f x.1 x.2) = | |
| μ.mixture (fun e => (ν e).pushforward (f e)) := by | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro z | |
| simp only [FiniteDistribution.pushforward, CompletionSoundness.sigmaLaw, | |
| FiniteDistribution.mixture, Fintype.sum_sigma, Finset.mul_sum, mul_ite, mul_zero] | |
| private theorem product_mixture {E F Γ : Type*} | |
| [Fintype E] [Fintype F] [Fintype Γ] | |
| (μ : FiniteDistribution E) (ν : FiniteDistribution F) | |
| (R : E × F → FiniteDistribution Γ) : | |
| (μ.product ν).mixture R = μ.mixture (fun e => ν.mixture (fun f => R (e, f))) := by | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro z | |
| simp only [FiniteDistribution.mixture, FiniteDistribution.product, | |
| Fintype.sum_prod_type, Finset.mul_sum, mul_assoc] | |
| variable {branch : Nat → Nat} {n t : Nat} | |
| abbrev Blocks (calls : Nat) (rows : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) := | |
| (child : Fin (branch n)) → ChildBlockCardinality.Raw calls rows (childSlots slots child) | |
| abbrev Tape (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) := | |
| Σ leaf : Slots branch (n + 1), OriginalChildBlocks.SourceTape calls rows repeats | |
| leaf.1 (GeometricPath.leafPath leaf.2) slots | |
| def sourceLaw (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (hbranch : ∀ k < n + 1, 0 < branch k) : | |
| FiniteDistribution (Tape calls rows repeats slots) := | |
| CompletionSoundness.sigmaLaw (GeometricPath.law (n + 1) hbranch) | |
| (fun leaf => OriginalChildBlocks.sourceLaw calls rows repeats leaf.1 | |
| (GeometricPath.leafPath leaf.2) slots) | |
| def rawMap (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (ω : Tape calls rows repeats slots) : Blocks calls rows slots := | |
| OriginalChildBlocks.rawMap calls rows repeats ω.1.1 | |
| (GeometricPath.leafPath ω.1.2) slots ω.2 | |
| def continuationLaw (hbranch : ∀ k < n + 1, 0 < branch k) : | |
| FiniteDistribution (Slots branch n) := | |
| GeometricPath.law n (fun k hk => hbranch k (Nat.lt_trans hk (Nat.lt_succ_self n))) | |
| def averagedSpecial (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (hbranch : ∀ k < n + 1, 0 < branch k) (child : Fin (branch n)) : | |
| FiniteDistribution (ChildBlockCardinality.Raw calls rows (childSlots slots child)) := | |
| (continuationLaw hbranch).mixture (fun leaf => | |
| OriginalChildBlocks.specialLaw calls rows repeats (GeometricPath.leafPath leaf) slots child) | |
| def blockMixture (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (hbranch : ∀ k < n + 1, 0 < branch k) : FiniteDistribution (Blocks calls rows slots) := by | |
| letI : Nonempty (Fin (branch n)) := ⟨⟨0, hbranch n (Nat.lt_succ_self n)⟩⟩ | |
| exact ChildBlockMixture.mixture (averagedSpecial calls rows repeats slots hbranch) | |
| private theorem special_as_continued (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (chosen : Fin (branch n)) (leaf : Slots branch n) : | |
| ChildBlockMixture.special | |
| (OriginalChildBlocks.specialLaw calls rows repeats (GeometricPath.leafPath leaf) slots) | |
| chosen = | |
| ChildBlockContinuation.continuedSpecial | |
| (fun child leaf => OriginalChildBlocks.specialLaw calls rows repeats | |
| (GeometricPath.leafPath leaf) slots child) chosen leaf := by | |
| let : Nonempty (Fin (branch n)) := ⟨chosen⟩ | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro x | |
| rw [ChildBlockMixture.special_weight, ChildBlockContinuation.continuedSpecial_weight] | |
| theorem rawMap_law (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (hbranch : ∀ k < n + 1, 0 < branch k) : | |
| (sourceLaw calls rows repeats slots hbranch).pushforward (rawMap calls rows repeats slots) = | |
| blockMixture calls rows repeats slots hbranch := by | |
| let : Nonempty (Fin (branch n)) := ⟨⟨0, hbranch n (Nat.lt_succ_self n)⟩⟩ | |
| refine (sigmaLaw_pushforward | |
| (E := Fin (branch n) × Slots branch n) (Γ := Blocks calls rows slots) | |
| (GeometricPath.law (n + 1) hbranch) | |
| (fun leaf => OriginalChildBlocks.sourceLaw calls rows repeats leaf.1 | |
| (GeometricPath.leafPath leaf.2) slots) | |
| (fun leaf tape => OriginalChildBlocks.rawMap calls rows repeats leaf.1 | |
| (GeometricPath.leafPath leaf.2) slots tape)).trans ?_ | |
| simp_rw [OriginalChildBlocks.rawMap_law] | |
| rw [GeometricPath.law_step] | |
| refine (product_mixture (FiniteDistribution.uniform (Fin (branch n))) | |
| (continuationLaw hbranch) | |
| (fun tag : Fin (branch n) × Slots branch n => | |
| ChildBlockMixture.special | |
| (OriginalChildBlocks.specialLaw calls rows repeats (GeometricPath.leafPath tag.2) slots) | |
| tag.1)).trans ?_ | |
| simp_rw [special_as_continued] | |
| exact ChildBlockContinuation.uniform_average | |
| (fun _ : Fin (branch n) => continuationLaw hbranch) | |
| (fun child leaf => OriginalChildBlocks.specialLaw calls rows repeats | |
| (GeometricPath.leafPath leaf) slots child) | |
| theorem rawMap_eq_mixture [Nonempty (Fin (branch n))] | |
| (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (hbranch : ∀ k < n + 1, 0 < branch k) : | |
| (sourceLaw calls rows repeats slots hbranch).pushforward (rawMap calls rows repeats slots) = | |
| ChildBlockMixture.mixture (averagedSpecial calls rows repeats slots hbranch) := | |
| rawMap_law calls rows repeats slots hbranch | |
| def observed (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (ω : Tape calls rows repeats slots) : CutChildGrouping.Assembled (C := Fin calls) slots rows := | |
| OriginalChildBlocks.observed calls rows repeats ω.1.1 | |
| (GeometricPath.leafPath ω.1.2) slots ω.2 | |
| theorem assemble_rawMap (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (ω : Tape calls rows repeats slots) : | |
| CutChildGrouping.assemble slots rows (rawMap calls rows repeats slots ω) = | |
| observed calls rows repeats slots ω := | |
| OriginalChildBlocks.assemble_rawMap calls rows repeats ω.1.1 | |
| (GeometricPath.leafPath ω.1.2) slots ω.2 | |
| theorem observed_law (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (hbranch : ∀ k < n + 1, 0 < branch k) : | |
| (sourceLaw calls rows repeats slots hbranch).pushforward (observed calls rows repeats slots) = | |
| (blockMixture calls rows repeats slots hbranch).pushforward | |
| (CutChildGrouping.assemble slots rows) := by | |
| rw [← rawMap_law calls rows repeats slots hbranch, FiniteDistribution.pushforward_comp] | |
| congr 1 | |
| funext ω | |
| exact (assemble_rawMap calls rows repeats slots ω).symm | |
| theorem raw_observed_variation {Γ : Type*} [Fintype Γ] | |
| (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (hbranch : ∀ k < n + 1, 0 < branch k) (observe : Blocks calls rows slots → Γ) : | |
| ((sourceLaw calls rows repeats slots hbranch).pushforward | |
| (fun ω => observe (rawMap calls rows repeats slots ω))).totalVariation | |
| ((ChildBlockMixture.reference (Ω := fun child : Fin (branch n) => | |
| ChildBlockCardinality.Raw calls rows (childSlots slots child))).pushforward observe) ≤ | |
| Real.sqrt ((ChildBlockCardinality.bound branch n t calls rows : ℝ) ^ 2 / | |
| branch n) / 2 := by | |
| let : Nonempty (Fin (branch n)) := ⟨⟨0, hbranch n (Nat.lt_succ_self n)⟩⟩ | |
| have hpush : (sourceLaw calls rows repeats slots hbranch).pushforward | |
| (fun ω => observe (rawMap calls rows repeats slots ω)) = | |
| (blockMixture calls rows repeats slots hbranch).pushforward observe := by | |
| rw [← rawMap_law calls rows repeats slots hbranch] | |
| exact (FiniteDistribution.pushforward_comp _ _ _).symm | |
| rw [hpush] | |
| simpa only [blockMixture, Fintype.card_fin] using | |
| (ChildBlockMixture.actual_observed_variation calls rows (fun child => childSlots slots child) | |
| (averagedSpecial calls rows repeats slots hbranch) observe) | |
| theorem observed_variation {Γ : Type*} [Fintype Γ] | |
| (calls : Nat) (rows repeats : Nat → Nat) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (hbranch : ∀ k < n + 1, 0 < branch k) | |
| (observe : CutChildGrouping.Assembled (C := Fin calls) slots rows → Γ) : | |
| ((sourceLaw calls rows repeats slots hbranch).pushforward | |
| (fun ω => observe (observed calls rows repeats slots ω))).totalVariation | |
| ((FiniteDistribution.uniform (CutChildGrouping.Assembled (C := Fin calls) slots rows)).pushforward | |
| observe) ≤ | |
| Real.sqrt ((ChildBlockCardinality.bound branch n t calls rows : ℝ) ^ 2 / | |
| branch n) / 2 := by | |
| have hclean : (ChildBlockMixture.reference (Ω := fun child : Fin (branch n) => | |
| ChildBlockCardinality.Raw calls rows (childSlots slots child))).pushforward | |
| (fun x => observe (CutChildGrouping.assemble slots rows x)) = | |
| (FiniteDistribution.uniform (CutChildGrouping.Assembled (C := Fin calls) slots rows)).pushforward | |
| observe := by | |
| rw [← FiniteDistribution.pushforward_comp] | |
| have h := CutChildGrouping.assemble_law (C := Fin calls) slots rows | |
| change (ChildBlockMixture.reference (Ω := fun child : Fin (branch n) => | |
| ChildBlockCardinality.Raw calls rows (childSlots slots child))).pushforward | |
| (CutChildGrouping.assemble slots rows) = _ at h | |
| rw [h] | |
| have h := raw_observed_variation calls rows repeats slots hbranch | |
| (fun x => observe (CutChildGrouping.assemble slots rows x)) | |
| simpa only [assemble_rawMap, hclean] using h | |
| end | |
| end PerfectCompleteness.OriginalHiddenChild | |
| end | |
| end OAI | |