openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Sampling /OriginalUniformCut.lean
| import OAI.Computability.PerfectCompleteness.Sampling.OriginalUniformCutBase | |
| namespace OAI | |
| section | |
| namespace PerfectCompleteness.OriginalUniformCut | |
| open RecursiveSpaces DescendantSpaces TreeSourceSpaces HierarchicalArrays | |
| open OriginalWholeCut OriginalWholeCutTape | |
| open UniqueGamesTheorem.Foundations.Games | |
| open scoped Classical | |
| noncomputable section | |
| attribute [local instance 2000] OriginalUniformCutBase.valuesChildrenFintype | |
| private theorem uniform_equiv {A B : Type*} [Fintype A] [Fintype B] | |
| [Nonempty A] [Nonempty B] (e : A ≃ B) : | |
| (FiniteDistribution.uniform A).pushforward e = FiniteDistribution.uniform B := by | |
| rw [← FiniteDistribution.transport_eq_pushforward] | |
| exact UniformConditioning.uniform_transport e | |
| private theorem uniform_map_product {A B C D : Type*} | |
| [Fintype A] [Fintype B] [Fintype C] [Fintype D] | |
| [Nonempty A] [Nonempty B] [Nonempty C] [Nonempty D] | |
| (f : A → C) (g : B → D) | |
| (hf : (FiniteDistribution.uniform A).pushforward f = FiniteDistribution.uniform C) | |
| (hg : (FiniteDistribution.uniform B).pushforward g = FiniteDistribution.uniform D) : | |
| (FiniteDistribution.uniform (A × B)).pushforward | |
| (fun x => (f x.1, g x.2)) = FiniteDistribution.uniform (C × D) := by | |
| rw [← WholeCutSampler.uniform_product, FiniteDistribution.product_pushforward, | |
| hf, hg, WholeCutSampler.uniform_product] | |
| variable {branch : Nat → Nat} {n m t : Nat} | |
| def recordStepEquiv (rows repeats : Nat → Nat) (i : Fin (branch n)) | |
| (p : Path branch n (m + 1)) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) : | |
| Record rows repeats (.step i p) slots ≃ | |
| WholeArraySampler.RootTape rows repeats (.step i p) slots × | |
| (Record rows repeats p (childSlots slots i) × | |
| ((j : RecursiveSampler.OffPath i) → Arrays (childSlots slots j.val) rows)) := | |
| (OriginalWholeCutTape.regroupStep | |
| (D := BucketSampler.Direction (rows (n + 1))) | |
| (T := TerminalCalls.TerminalIndex repeats (.step i p)) | |
| (C := OriginalCutCalls.Index rows repeats p) | |
| (S := H (cutSlots (.step i p) slots)) | |
| (E := OriginalTerminalSplit.ExteriorTape F2 repeats (.step i p) (LeafDomain slots)) | |
| (L := Exterior rows repeats p (childSlots slots i)) | |
| (O := (j : RecursiveSampler.OffPath i) → Arrays (childSlots slots j.val) rows) | |
| (B := BelowArrays rows p (childSlots slots i))).symm.trans | |
| (Equiv.prodCongr | |
| (Equiv.piCongrRight (fun _ : BucketSampler.Direction (rows (n + 1)) => | |
| (OriginalScalarReconstruction.prefixSplit F2 repeats (.step i p) | |
| (LeafDomain slots)).symm)) | |
| (Equiv.refl _)) | |
| def toStoppedTape (rows repeats : Nat → Nat) : | |
| {n m : Nat} → (p : Path branch n (m + 1)) → | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) → | |
| Record rows repeats p slots → WholeArraySampler.Tape rows repeats p slots | |
| | _, _, .refl _, slots, record => | |
| reconstructRecord rows repeats (.refl _) slots record | |
| | _, _, .step i p, slots, record => | |
| let split := recordStepEquiv rows repeats i p slots record | |
| WholeCutSampler.stepEquiv i | |
| (WholeArraySampler.RootTape rows repeats (.step i p) slots) | |
| (WholeArraySampler.Tape rows repeats p (childSlots slots i)) | |
| (fun j => Arrays (childSlots slots j.val) rows) | |
| (split.1, (toStoppedTape rows repeats p (childSlots slots i) split.2.1, | |
| split.2.2)) | |
| theorem evaluate_toStoppedTape (rows repeats : Nat → Nat) : | |
| ∀ {n m : Nat} (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (record : Record rows repeats p slots), | |
| WholeArraySampler.evaluate rows repeats p slots | |
| (toStoppedTape rows repeats p slots record) = | |
| reconstructRecord rows repeats p slots record := by | |
| intro n | |
| induction n with | |
| | zero => intro m p; cases p | |
| | succ n ih => | |
| intro m p slots record | |
| cases p with | |
| | refl => rfl | |
| | step i p => | |
| exact congrArg₂ (WholeArraySampler.assemble slots rows) rfl | |
| (congrArg (fun selected : Arrays (childSlots slots i) rows => | |
| WholeArraySampler.childrenAt slots rows i selected record.1.2.2) | |
| (ih p (childSlots slots i) | |
| (record.1.2.1, ((fun call => record.2.1 (.inr call)), record.2.2)))) | |
| theorem uniform_toStoppedTape (rows repeats : Nat → Nat) : | |
| ∀ {n m : Nat} (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot), | |
| (FiniteDistribution.uniform (Record rows repeats p slots)).pushforward | |
| (toStoppedTape rows repeats p slots) = | |
| FiniteDistribution.uniform (WholeArraySampler.Tape rows repeats p slots) := by | |
| intro n | |
| induction n with | |
| | zero => intro m p; cases p | |
| | succ n ih => | |
| intro m p slots | |
| cases p with | |
| | refl => | |
| exact OriginalUniformCutBase.uniform_reconstructRecord_refl rows repeats slots | |
| | step i p => | |
| let R := WholeArraySampler.RootTape rows repeats (.step i p) slots | |
| let L := Record rows repeats p (childSlots slots i) | |
| let S := WholeArraySampler.Tape rows repeats p (childSlots slots i) | |
| let O := (j : RecursiveSampler.OffPath i) → Arrays (childSlots slots j.val) rows | |
| let e := recordStepEquiv rows repeats i p slots | |
| let finish := WholeCutSampler.stepEquiv i R S | |
| (fun j => Arrays (childSlots slots j.val) rows) | |
| let : Fintype (WholeArraySampler.StepTape (i := i) R S | |
| (fun j => Arrays (childSlots slots j.val) rows)) := | |
| WholeArraySampler.tapeFintype rows repeats (.step i p) slots | |
| let : Nonempty (WholeArraySampler.StepTape (i := i) R S | |
| (fun j => Arrays (childSlots slots j.val) rows)) := | |
| ⟨WholeArraySampler.zeroTape rows repeats (.step i p) slots⟩ | |
| let middle : R × (L × O) → R × (S × O) := | |
| fun z => (z.1, | |
| (toStoppedTape rows repeats p (childSlots slots i) z.2.1, z.2.2)) | |
| have hinner : (FiniteDistribution.uniform (L × O)).pushforward | |
| (fun z => (toStoppedTape rows repeats p (childSlots slots i) z.1, z.2)) = | |
| FiniteDistribution.uniform (S × O) := | |
| uniform_map_product (toStoppedTape rows repeats p (childSlots slots i)) | |
| (id : O → O) (ih p (childSlots slots i)) | |
| (FiniteDistribution.pushforward_id _) | |
| have hmiddle : (FiniteDistribution.uniform (R × (L × O))).pushforward middle = | |
| FiniteDistribution.uniform (R × (S × O)) := | |
| uniform_map_product (id : R → R) | |
| (fun z : L × O => | |
| (toStoppedTape rows repeats p (childSlots slots i) z.1, z.2)) | |
| (FiniteDistribution.pushforward_id _) hinner | |
| calc | |
| _ = (((FiniteDistribution.uniform (Record rows repeats (.step i p) slots)).pushforward | |
| e).pushforward middle).pushforward finish := by | |
| rw [FiniteDistribution.pushforward_comp, FiniteDistribution.pushforward_comp] | |
| rfl | |
| _ = (FiniteDistribution.uniform (R × (S × O))).pushforward finish := by | |
| rw [uniform_equiv e, hmiddle] | |
| _ = _ := uniform_equiv finish | |
| def referenceLaw (rows repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) : | |
| FiniteDistribution (Record rows repeats p slots) := | |
| (exteriorLaw rows repeats p slots).product | |
| ((FiniteProduct.law (fun _ : OriginalCutCalls.Index rows repeats p => | |
| FiniteDistribution.uniform (H (cutSlots p slots)))).product | |
| (FiniteProduct.law (fun child : Fin (branch m) => | |
| FiniteDistribution.uniform (Arrays (childSlots (cutSlots p slots) child) rows)))) | |
| theorem referenceLaw_uniform (rows repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) : | |
| referenceLaw rows repeats p slots = FiniteDistribution.uniform (Record rows repeats p slots) := by | |
| unfold referenceLaw exteriorLaw | |
| rw [UniformLinearImage.law_uniform, UniformLinearImage.law_uniform, | |
| WholeCutSampler.uniform_product, WholeCutSampler.uniform_product] | |
| theorem reconstruct_referenceLaw (rows repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) : | |
| (referenceLaw rows repeats p slots).pushforward (reconstructRecord rows repeats p slots) = | |
| WholeArraySampler.law rows repeats p slots := by | |
| rw [referenceLaw_uniform] | |
| calc | |
| _ = ((FiniteDistribution.uniform (Record rows repeats p slots)).pushforward | |
| (toStoppedTape rows repeats p slots)).pushforward | |
| (WholeArraySampler.evaluate rows repeats p slots) := by | |
| rw [FiniteDistribution.pushforward_comp] | |
| congr 1 | |
| funext record | |
| exact (evaluate_toStoppedTape rows repeats p slots record).symm | |
| _ = (FiniteDistribution.uniform (WholeArraySampler.Tape rows repeats p slots)).pushforward | |
| (WholeArraySampler.evaluate rows repeats p slots) := by rw [uniform_toStoppedTape] | |
| _ = _ := by rw [← WholeArraySubtreeSplit.tapeLaw_eq_uniform]; rfl | |
| end | |
| end PerfectCompleteness.OriginalUniformCut | |
| end | |
| end OAI | |