openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Sampling /BucketDescriptorLaw.lean
| import OAI.Computability.PerfectCompleteness.Foundations.DependentPredictionDifferenceLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.FiniteProduct | |
| import OAI.Computability.PerfectCompleteness.Sampling.RationalFiniteLawLemmas | |
| namespace OAI | |
| section | |
| namespace PerfectCompleteness.BucketDescriptorLaw | |
| open UniqueGamesTheorem.Foundations.Games | |
| open scoped BigOperators Classical | |
| noncomputable section | |
| abbrev Buckets (D V : Type*) := D → V | |
| abbrev Record (E D V : Type*) := Σ _ : E, D × (Buckets D V × V) | |
| variable {D E T V : Type*} [Fintype D] [Fintype E] [Fintype T] [Fintype V] | |
| def bucketLaw (D : Type*) [Fintype D] (ρ : FiniteDistribution V) : | |
| FiniteDistribution (Buckets D V) := | |
| FiniteProduct.law (fun _ : D => ρ) | |
| def sampleLaw (δ : FiniteDistribution D) (ρ : FiniteDistribution V) : | |
| FiniteDistribution (D × (Buckets D V × V)) := | |
| δ.product ((bucketLaw D ρ).product ρ) | |
| def observe (read : T → E × Buckets D V) (z : D × (T × V)) : Record E D V := | |
| ⟨(read z.2.1).1, (z.1, ((read z.2.1).2, z.2.2))⟩ | |
| private def reorder (D E B V : Type*) : | |
| D × ((E × B) × V) ≃ Σ _ : E, D × (B × V) where | |
| toFun z := ⟨z.2.1.1, (z.1, (z.2.1.2, z.2.2))⟩ | |
| invFun z := (z.2.1, ((z.1, z.2.2.1), z.2.2.2)) | |
| left_inv _ := rfl | |
| right_inv _ := rfl | |
| theorem reorder_law {B : Type*} [Fintype B] | |
| (δ : FiniteDistribution D) (ν : FiniteDistribution E) | |
| (κ : FiniteDistribution B) (ρ : FiniteDistribution V) : | |
| (δ.product ((ν.product κ).product ρ)).pushforward | |
| (fun z => (⟨z.2.1.1, (z.1, (z.2.1.2, z.2.2))⟩ : Σ _ : E, D × (B × V))) = | |
| CompletionSoundness.sigmaLaw ν (fun _ => δ.product (κ.product ρ)) := by | |
| change (δ.product ((ν.product κ).product ρ)).pushforward (reorder D E B V) = _ | |
| rw [← FiniteDistribution.transport_eq_pushforward] | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro z | |
| change δ.weight z.2.1 * ((ν.weight z.1 * κ.weight z.2.2.1) * ρ.weight z.2.2.2) = | |
| ν.weight z.1 * (δ.weight z.2.1 * (κ.weight z.2.2.1 * ρ.weight z.2.2.2)) | |
| rw [mul_assoc] | |
| exact mul_left_comm _ _ _ | |
| theorem observe_law (μ : FiniteDistribution T) (ν : FiniteDistribution E) | |
| (ρ : FiniteDistribution V) (δ : FiniteDistribution D) | |
| (read : T → E × Buckets D V) | |
| (hread : μ.pushforward read = ν.product (bucketLaw D ρ)) : | |
| (δ.product (μ.product ρ)).pushforward (observe read) = | |
| CompletionSoundness.sigmaLaw ν (fun _ => sampleLaw δ ρ) := by | |
| have hinner : (μ.product ρ).pushforward (fun z => (read z.1, z.2)) = | |
| (ν.product (bucketLaw D ρ)).product ρ := by | |
| simpa only [id_eq, FiniteDistribution.pushforward_id, hread] using | |
| FiniteDistribution.product_pushforward μ ρ read (id : V → V) | |
| have houter : (δ.product (μ.product ρ)).pushforward | |
| (fun z => (z.1, (read z.2.1, z.2.2))) = | |
| δ.product ((ν.product (bucketLaw D ρ)).product ρ) := by | |
| simpa only [id_eq, FiniteDistribution.pushforward_id, hinner] using | |
| FiniteDistribution.product_pushforward δ (μ.product ρ) (id : D → D) | |
| (fun z : T × V => (read z.1, z.2)) | |
| calc | |
| _ = ((δ.product (μ.product ρ)).pushforward | |
| (fun z => (z.1, (read z.2.1, z.2.2)))).pushforward | |
| (reorder D E (Buckets D V) V) := | |
| (FiniteDistribution.pushforward_comp _ _ _).symm | |
| _ = (δ.product ((ν.product (bucketLaw D ρ)).product ρ)).pushforward | |
| (reorder D E (Buckets D V) V) := | |
| congrArg (fun η : FiniteDistribution (D × ((E × Buckets D V) × V)) => | |
| η.pushforward (reorder D E (Buckets D V) V)) houter | |
| _ = _ := reorder_law δ ν (bucketLaw D ρ) ρ | |
| variable {D' V' : Type*} [Fintype D'] [Fintype V'] | |
| def sampleEquiv (eD : D ≃ D') (eV : V ≃ V') : | |
| (D × (Buckets D V × V)) ≃ (D' × (Buckets D' V' × V')) := | |
| Equiv.prodCongr eD (Equiv.prodCongr (Equiv.arrowCongr eD eV) eV) | |
| def recordEquiv (eD : D ≃ D') (eV : V ≃ V') : Record E D V ≃ Record E D' V' := | |
| Equiv.sigmaCongrRight (fun _ => sampleEquiv eD eV) | |
| theorem bucketLaw_equiv (ρ : FiniteDistribution V) (eD : D ≃ D') (eV : V ≃ V') : | |
| (bucketLaw D ρ).pushforward (Equiv.arrowCongr eD eV) = | |
| bucketLaw D' (ρ.pushforward eV) := by | |
| rw [← FiniteDistribution.transport_eq_pushforward (bucketLaw D ρ) (Equiv.arrowCongr eD eV), | |
| ← FiniteDistribution.transport_eq_pushforward ρ eV] | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro buckets | |
| change (∏ d : D, ρ.weight (eV.symm (buckets (eD d)))) = | |
| ∏ d : D', ρ.weight (eV.symm (buckets d)) | |
| exact eD.prod_comp (fun d => ρ.weight (eV.symm (buckets d))) | |
| theorem sampleLaw_equiv (δ : FiniteDistribution D) (ρ : FiniteDistribution V) | |
| (eD : D ≃ D') (eV : V ≃ V') : | |
| (sampleLaw δ ρ).pushforward (sampleEquiv eD eV) = | |
| sampleLaw (δ.pushforward eD) (ρ.pushforward eV) := by | |
| have hinner : ((bucketLaw D ρ).product ρ).pushforward | |
| (Equiv.prodCongr (Equiv.arrowCongr eD eV) eV) = | |
| (bucketLaw D' (ρ.pushforward eV)).product (ρ.pushforward eV) := by | |
| exact (FiniteDistribution.product_pushforward (bucketLaw D ρ) ρ | |
| (Equiv.arrowCongr eD eV) eV).trans | |
| (congrArg (fun η : FiniteDistribution (Buckets D' V') => η.product (ρ.pushforward eV)) | |
| (bucketLaw_equiv ρ eD eV)) | |
| exact (FiniteDistribution.product_pushforward δ ((bucketLaw D ρ).product ρ) | |
| eD (Equiv.prodCongr (Equiv.arrowCongr eD eV) eV)).trans | |
| (congrArg (fun η : FiniteDistribution (Buckets D' V' × V') => | |
| (δ.pushforward eD).product η) hinner) | |
| theorem reference_equiv (ν : FiniteDistribution E) (δ : FiniteDistribution D) | |
| (ρ : FiniteDistribution V) (eD : D ≃ D') (eV : V ≃ V') : | |
| (CompletionSoundness.sigmaLaw ν (fun _ => sampleLaw δ ρ)).pushforward | |
| (recordEquiv (E := E) eD eV) = | |
| CompletionSoundness.sigmaLaw ν | |
| (fun _ => sampleLaw (δ.pushforward eD) (ρ.pushforward eV)) := by | |
| have hmap : (⇑(recordEquiv (E := E) eD eV) : Record E D V → Record E D' V') = | |
| (fun z => ⟨z.1, sampleEquiv eD eV z.2⟩) := by | |
| funext z | |
| cases z | |
| rfl | |
| rw [hmap] | |
| have h := SigmaObservation.pushforward_fiber ν (fun _ => sampleLaw δ ρ) | |
| (fun _ => ⇑(sampleEquiv eD eV)) | |
| simpa only [sampleLaw_equiv] using h | |
| theorem observe_equiv_law (μ : FiniteDistribution T) (ν : FiniteDistribution E) | |
| (ρ : FiniteDistribution V) (δ : FiniteDistribution D) | |
| (read : T → E × Buckets D V) | |
| (hread : μ.pushforward read = ν.product (bucketLaw D ρ)) | |
| (eD : D ≃ D') (eV : V ≃ V') : | |
| (δ.product (μ.product ρ)).pushforward | |
| (fun z => recordEquiv (E := E) eD eV (observe read z)) = | |
| CompletionSoundness.sigmaLaw ν | |
| (fun _ => sampleLaw (δ.pushforward eD) (ρ.pushforward eV)) := by | |
| calc | |
| _ = ((δ.product (μ.product ρ)).pushforward (observe read)).pushforward | |
| (recordEquiv (E := E) eD eV) := | |
| (FiniteDistribution.pushforward_comp _ _ _).symm | |
| _ = (CompletionSoundness.sigmaLaw ν (fun _ => sampleLaw δ ρ)).pushforward | |
| (recordEquiv (E := E) eD eV) := | |
| congrArg (fun η : FiniteDistribution (Record E D V) => | |
| η.pushforward (recordEquiv (E := E) eD eV)) (observe_law μ ν ρ δ read hread) | |
| _ = _ := reference_equiv ν δ ρ eD eV | |
| end | |
| end PerfectCompleteness.BucketDescriptorLaw | |
| end | |
| end OAI | |