openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Sampling /OriginalUsefulPairLaw.lean
| import OAI.Computability.PerfectCompleteness.Construction.CutBucketTransportLemmas | |
| import OAI.Computability.PerfectCompleteness.Sampling.OriginalCutPairLaw | |
| namespace OAI | |
| section | |
| namespace PerfectCompleteness.OriginalUsefulPairLaw | |
| open RecursiveSpaces DescendantSpaces TreeSourceSpaces HierarchicalArrays | |
| open OriginalWholeCutTape WholeArrayInteriorExterior | |
| open UniqueGamesTheorem.Foundations.Games | |
| open UniqueGamesTheorem.Appendix.RankLevelFilter (linearMapFintype) | |
| open scoped BigOperators Classical | |
| noncomputable section | |
| attribute [local instance] linearMapFintype | |
| private theorem product_mixture_pushforward {E A B Γ : Type*} | |
| [Fintype E] [Fintype A] [Fintype B] [Fintype Γ] | |
| (μ : FiniteDistribution A) (κ : FiniteDistribution E) | |
| (ν : E → FiniteDistribution B) (f : A × B → Γ) : | |
| (μ.product (κ.mixture ν)).pushforward f = | |
| κ.mixture (fun e => (μ.product (ν e)).pushforward f) := by | |
| have hp : μ.product (κ.mixture ν) = κ.mixture (fun e => μ.product (ν e)) := by | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro x | |
| simp only [FiniteDistribution.product, FiniteDistribution.mixture, Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro e _ | |
| exact mul_left_comm _ _ _ | |
| rw [hp, FiniteDistribution.pushforward_mixture] | |
| private theorem nested_sigma_product_pushforward {Tag Bg Buck Γ : Type*} | |
| [Fintype Tag] [Fintype Bg] [Fintype Buck] [Fintype Γ] | |
| (μ : FiniteDistribution Tag) (β : Tag → FiniteDistribution Bg) | |
| (γ : Tag → FiniteDistribution Buck) (f : Bg × Buck → Γ) : | |
| (CompletionSoundness.sigmaLaw (CompletionSoundness.sigmaLaw μ β) | |
| (fun d : Σ _ : Tag, Bg => γ d.1)).pushforward | |
| (fun z => f (z.1.2, z.2)) = | |
| μ.mixture (fun tag => ((β tag).product (γ tag)).pushforward f) := by | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro x | |
| simp only [FiniteDistribution.pushforward, CompletionSoundness.sigmaLaw, | |
| FiniteDistribution.mixture, FiniteDistribution.product, Fintype.sum_sigma, | |
| Fintype.sum_prod_type, Finset.mul_sum, mul_ite, mul_zero, mul_assoc] | |
| variable {branch : Nat → Nat} {n m k t : Nat} | |
| local instance backgroundFintype (rows : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) : | |
| Fintype (HierarchicalMatrixTable.Background (rows := rows) slots (upperNode p)) := | |
| Fintype.ofFinite _ | |
| local instance rowSpaceFintype (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) : | |
| Fintype (NodeEmbedding.RowSpace slots (upperNode p)) := Fintype.ofFinite _ | |
| attribute [local instance 2000] OriginalWholeCutLaw.valuesBelowFintype | |
| private theorem transportPair_law (rows : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (μ : FiniteDistribution (HierarchicalMatrixTable.Background (rows := rows) slots (upperNode p))) | |
| (ν : FiniteDistribution (BucketSampler.Direction (rows (m + 1)) × | |
| (BucketSampler.Tape (rows (m + 1)) (H (cutSlots p slots)) × H (cutSlots p slots)))) : | |
| (μ.product ν).pushforward (OriginalCutPairLaw.transportPair rows p slots) = | |
| ((μ.product ν).pushforward | |
| (fun z : OriginalCutBucketLaw.NativeSample rows p slots => | |
| (z.1, CutNodeRows.bucketSampleEquiv rows p slots z.2))).pushforward | |
| (HierarchicalAgreementMean.pairRecord slots (upperNode p)) := by | |
| exact (FiniteDistribution.pushforward_comp (μ.product ν) | |
| (fun z : OriginalCutBucketLaw.NativeSample rows p slots => | |
| (z.1, CutNodeRows.bucketSampleEquiv rows p slots z.2)) | |
| (HierarchicalAgreementMean.pairRecord slots (upperNode p))).symm | |
| theorem record_fresh_pair_law (rows repeats : Nat → Nat) | |
| (p : Path branch n (m + 1)) (chosen : Fin (branch m)) (q : Path branch m k) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) (hrows : 0 < rows (m + 1)) : | |
| ((OriginalCutPairLaw.directionsLaw rows m hrows).product | |
| (((OriginalWholeCutLaw.recordLaw rows repeats p chosen q slots).pushforward | |
| (OriginalWholeCutBridge.numberRecord rows repeats p slots)).product | |
| (RecursiveSampler.law F2 repeats (.step chosen q) (LeafDomain (cutSlots p slots))))).pushforward | |
| (OriginalCutCollision.pairRecord rows repeats p slots) = | |
| ((OriginalOwnBucketSplit.actualBackgroundLaw rows repeats p chosen q slots).product | |
| (HierarchicalUsefulCollision.bucketLaw slots (upperNode p) | |
| ((RecursiveSampler.law F2 repeats (.step chosen q) (LeafDomain (cutSlots p slots))).pushforward | |
| (CutNodeRows.cutRowEquiv p slots)) | |
| (by simpa only [upperNode_height] using hrows))).pushforward | |
| (HierarchicalAgreementMean.pairRecord slots (upperNode p)) := by | |
| let μ := OriginalOwnBucketSplit.actualBackgroundLaw rows repeats p chosen q slots | |
| let scalar := RecursiveSampler.law F2 repeats (.step chosen q) (LeafDomain (cutSlots p slots)) | |
| let records := ((OriginalWholeCutLaw.recordLaw rows repeats p chosen q slots).pushforward | |
| (OriginalWholeCutBridge.numberRecord rows repeats p slots)).product scalar | |
| let directions := OriginalCutPairLaw.directionsLaw rows m hrows | |
| have hread := OriginalCutBucketLaw.record_fresh_read_law rows repeats p chosen q slots directions | |
| have hnative : | |
| (directions.product records).pushforward (OriginalCutBucketLaw.read rows repeats p slots) = | |
| μ.product (CutBucketTransportActual.nativeLaw rows p slots scalar hrows) := by | |
| simpa only [μ, scalar, records, directions, CutBucketTransportActual.nativeLaw, | |
| OriginalCutPairLaw.directionsLaw] using hread | |
| have htransport := FiniteDistribution.product_pushforward μ | |
| (CutBucketTransportActual.nativeLaw rows p slots scalar hrows) id | |
| (CutNodeRows.bucketSampleEquiv rows p slots) | |
| simp only [id_eq, FiniteDistribution.pushforward_id] at htransport | |
| calc | |
| _ = ((directions.product records).pushforward | |
| (OriginalCutBucketLaw.read rows repeats p slots)).pushforward | |
| (OriginalCutPairLaw.transportPair rows p slots) := by | |
| rw [FiniteDistribution.pushforward_comp] | |
| congr 1 | |
| funext sample | |
| exact OriginalCutPairLaw.pairRecord_eq rows repeats p slots sample | |
| _ = (μ.product (CutBucketTransportActual.nativeLaw rows p slots scalar hrows)).pushforward | |
| (OriginalCutPairLaw.transportPair rows p slots) := by rw [hnative] | |
| _ = ((μ.product (CutBucketTransportActual.nativeLaw rows p slots scalar hrows)).pushforward | |
| (fun z => (z.1, CutNodeRows.bucketSampleEquiv rows p slots z.2))).pushforward | |
| (HierarchicalAgreementMean.pairRecord slots (upperNode p)) := | |
| transportPair_law rows p slots μ (CutBucketTransportActual.nativeLaw rows p slots scalar hrows) | |
| _ = _ := by | |
| rw [htransport, CutBucketTransportActual.nativeLaw_pushforward] | |
| abbrev Descriptor (rows : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) (K : Type*) := | |
| Σ _ : Fin (branch m) × K, | |
| HierarchicalMatrixTable.Background (rows := rows) slots (upperNode p) | |
| variable {K : Type*} [Fintype K] | |
| def externalLaw (rows repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (ν : FiniteDistribution K) (q : K → Path branch m k) (hbranch : 0 < branch m) : | |
| FiniteDistribution (Descriptor rows p slots K) := | |
| CompletionSoundness.sigmaLaw (OriginalPrefixContinuation.tagLaw ν hbranch) | |
| (fun tag => OriginalOwnBucketSplit.actualBackgroundLaw rows repeats p tag.1 (q tag.2) slots) | |
| def background (rows : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (descriptor : Descriptor rows p slots K) : | |
| HierarchicalMatrixTable.Background (rows := rows) slots (upperNode p) := descriptor.2 | |
| def scalarLaw (rows repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) (q : K → Path branch m k) | |
| (descriptor : Descriptor rows p slots K) : | |
| FiniteDistribution (NodeEmbedding.RowSpace slots (upperNode p)) := | |
| (RecursiveSampler.law F2 repeats (.step descriptor.1.1 (q descriptor.1.2)) | |
| (LeafDomain (cutSlots p slots))).pushforward (CutNodeRows.cutRowEquiv p slots) | |
| theorem useful_pairLaw_eq_mixture (rows repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (ν : FiniteDistribution K) (q : K → Path branch m k) (hbranch : 0 < branch m) | |
| (hrows : 0 < rows (m + 1)) : | |
| HierarchicalUsefulCollision.pairLaw slots (upperNode p) | |
| (externalLaw rows repeats p slots ν q hbranch) (background rows p slots) | |
| (scalarLaw rows repeats p slots q) | |
| (by simpa only [upperNode_height] using hrows) = | |
| (OriginalPrefixContinuation.tagLaw ν hbranch).mixture (fun tag => | |
| ((OriginalOwnBucketSplit.actualBackgroundLaw rows repeats p tag.1 (q tag.2) slots).product | |
| (HierarchicalUsefulCollision.bucketLaw slots (upperNode p) | |
| ((RecursiveSampler.law F2 repeats (.step tag.1 (q tag.2)) | |
| (LeafDomain (cutSlots p slots))).pushforward (CutNodeRows.cutRowEquiv p slots)) | |
| (by simpa only [upperNode_height] using hrows))).pushforward | |
| (HierarchicalAgreementMean.pairRecord slots (upperNode p))) := by | |
| exact nested_sigma_product_pushforward | |
| (OriginalPrefixContinuation.tagLaw ν hbranch) | |
| (fun tag => OriginalOwnBucketSplit.actualBackgroundLaw rows repeats p tag.1 (q tag.2) slots) | |
| (fun tag => HierarchicalUsefulCollision.bucketLaw slots (upperNode p) | |
| ((RecursiveSampler.law F2 repeats (.step tag.1 (q tag.2)) | |
| (LeafDomain (cutSlots p slots))).pushforward (CutNodeRows.cutRowEquiv p slots)) | |
| (by simpa only [upperNode_height] using hrows)) | |
| (HierarchicalAgreementMean.pairRecord slots (upperNode p)) | |
| theorem actual_pair_law (rows repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (ν : FiniteDistribution K) (q : K → Path branch m k) (hbranch : 0 < branch m) | |
| (hrows : 0 < rows (m + 1)) : | |
| ((OriginalCutPairLaw.directionsLaw rows m hrows).product | |
| (OriginalExtraCutComparison.actualLaw rows repeats p slots ν q hbranch)).pushforward | |
| (OriginalCutCollision.pairRecord rows repeats p slots) = | |
| HierarchicalUsefulCollision.pairLaw slots (upperNode p) | |
| (externalLaw rows repeats p slots ν q hbranch) (background rows p slots) | |
| (scalarLaw rows repeats p slots q) | |
| (by simpa only [upperNode_height] using hrows) := by | |
| rw [OriginalExtraCutComparison.actualLaw_eq_mixture, product_mixture_pushforward, | |
| useful_pairLaw_eq_mixture rows repeats p slots ν q hbranch hrows] | |
| apply congrArg ((OriginalPrefixContinuation.tagLaw ν hbranch).mixture) | |
| funext tag | |
| exact record_fresh_pair_law rows repeats p tag.1 (q tag.2) slots hrows | |
| end | |
| end PerfectCompleteness.OriginalUsefulPairLaw | |
| end | |
| end OAI | |