| import Mathlib |
| import OAI.Computability.VertexCover.Games.TotalVariation |
| import OAI.Computability.VertexCover.Games.KernelSampling |
| import OAI.Computability.VertexCover.Repetition.DistributionMaps |
| import OAI.Computability.VertexCover.Repetition.SharedSampling |
|
|
| namespace OAI |
|
|
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| |
| section |
|
|
| namespace UniqueGames.Foundations.Repetition.CompletedSampling |
|
|
| open scoped BigOperators |
| open Games |
|
|
| noncomputable section |
|
|
| section DistributionIdentities |
|
|
| variable {A B C D : Type*} [Fintype A] [Fintype B] [Fintype C] [Fintype D] |
|
|
| theorem mixture_pushforward_base (μ : FiniteDistribution A) (f : A → B) |
| (K : B → FiniteDistribution C) : |
| (μ.pushforward f).mixture K = μ.mixture (fun a => K (f a)) := by |
| apply FiniteDistribution.eq_of_weight_eq |
| intro «c» |
| exact FiniteDistribution.expectation_pushforward μ f (fun b => (K b).weight «c») |
|
|
| theorem product_pushforward_eq_mixture_right (μ : FiniteDistribution A) |
| (ν : FiniteDistribution B) (f : A × B → C) : |
| (μ.product ν).pushforward f = |
| ν.mixture (fun b => μ.pushforward (fun a => f (a, b))) := by |
| classical |
| apply FiniteDistribution.eq_of_weight_eq |
| intro «c» |
| simp only [FiniteDistribution.pushforward, FiniteDistribution.product, |
| FiniteDistribution.mixture, Fintype.sum_prod_type] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro b _ |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro a _ |
| by_cases h : f (a, b) = «c» <;> simp [h, mul_comm] |
|
|
| theorem product_product_pushforward_eq_mixture (μ : FiniteDistribution A) |
| (ν : FiniteDistribution B) (κ : FiniteDistribution C) (f : A → B → C → D) : |
| (μ.product (ν.product κ)).pushforward (fun z => f z.1 z.2.1 z.2.2) = |
| (μ.product ν).mixture |
| (fun z => κ.pushforward (fun «c» => f z.1 z.2 «c»)) := by |
| classical |
| apply FiniteDistribution.eq_of_weight_eq |
| intro d |
| simp only [FiniteDistribution.pushforward, FiniteDistribution.product, |
| FiniteDistribution.mixture, Fintype.sum_prod_type] |
| simp only [Finset.mul_sum, mul_ite, mul_zero, mul_assoc] |
|
|
| theorem mixture_totalVariation_le (μ ν : FiniteDistribution A) |
| (K : A → FiniteDistribution B) : |
| (μ.mixture K).totalVariation (ν.mixture K) ≤ μ.totalVariation ν := by |
| simpa only [FiniteDistribution.totalVariation, FiniteDistribution.mixture, |
| Information.totalVariation, kernelPushforward] using |
| totalVariation_kernelPushforward_le μ.weight ν.weight |
| (fun a => (K a).weight) (fun a => Information.gameLaw_isProbability (K a)) |
|
|
| end DistributionIdentities |
|
|
| section Diagonal |
|
|
| variable {Z S : Type*} [Fintype Z] [Fintype S] |
|
|
| def diagonalLaw (σ : FiniteDistribution (Z × S)) : FiniteDistribution (Z × S × S) := |
| Information.toGameLaw (diagonalWeights σ.weight) |
| (diagonalWeights_isProbability _ (Information.gameLaw_isProbability σ)) |
|
|
| theorem diagonalLaw_eq_pushforward (σ : FiniteDistribution (Z × S)) : |
| diagonalLaw σ = σ.pushforward (fun z => (z.1, z.2, z.2)) := by |
| classical |
| apply FiniteDistribution.eq_of_weight_eq |
| rintro ⟨z, a, b⟩ |
| change diagonalWeights σ.weight (z, a, b) = |
| (σ.pushforward (fun t => (t.1, t.2, t.2))).weight (z, a, b) |
| simp only [diagonalWeights, FiniteDistribution.pushforward, |
| Fintype.sum_prod_type, Prod.mk.injEq] |
| by_cases hab : a = b |
| · subst b |
| simp [ite_and] |
| · simp [hab, ite_and] |
|
|
| theorem diagonalLaw_mixture {T : Type*} [Fintype T] |
| (σ : FiniteDistribution (Z × S)) (K : Z × S × S → FiniteDistribution T) : |
| (diagonalLaw σ).mixture K = σ.mixture (fun z => K (z.1, z.2, z.2)) := by |
| rw [diagonalLaw_eq_pushforward, mixture_pushforward_base] |
|
|
| end Diagonal |
|
|
| section Completion |
|
|
| variable {X Y S Γ U V : Type*} |
| [Fintype X] [Fintype Y] [Fintype S] [Fintype Γ] [Fintype U] [Fintype V] |
| [DecidableEq X] [DecidableEq Y] [DecidableEq S] |
|
|
| abbrev Seed (Γ X Y S U V : Type*) := |
| Γ × KernelSampling.Seed (X × S) (Y × S) U V |
|
|
| def seedLaw (γ : FiniteDistribution Γ) |
| (L : X × S → FiniteDistribution U) (R : Y × S → FiniteDistribution V) : |
| FiniteDistribution (Seed Γ X Y S U V) := |
| γ.product (KernelSampling.seedLaw L R) |
|
|
| def left (sL : Γ → X → S) (seed : Seed Γ X Y S U V) (x : X) : U := |
| KernelSampling.readLeft seed.2 (x, sL seed.1 x) |
|
|
| def right (sR : Γ → Y → S) (seed : Seed Γ X Y S U V) (y : Y) : V := |
| KernelSampling.readRight seed.2 (y, sR seed.1 y) |
|
|
| def completionKernel (L : X × S → FiniteDistribution U) |
| (R : Y × S → FiniteDistribution V) (z : (X × Y) × S × S) : |
| FiniteDistribution (U × V) := |
| (L (z.1.1, z.2.1)).product (R (z.1.2, z.2.2)) |
|
|
| def outputLaw (μ : FiniteDistribution (X × Y)) (γ : FiniteDistribution Γ) |
| (sL : Γ → X → S) (sR : Γ → Y → S) |
| (L : X × S → FiniteDistribution U) (R : Y × S → FiniteDistribution V) : |
| FiniteDistribution (U × V) := |
| (seedLaw γ L R).mixture (fun seed => |
| μ.pushforward (fun q => (left sL seed q.1, right sR seed q.2))) |
|
|
| theorem outputLaw_eq_product_pushforward |
| (μ : FiniteDistribution (X × Y)) (γ : FiniteDistribution Γ) |
| (sL : Γ → X → S) (sR : Γ → Y → S) |
| (L : X × S → FiniteDistribution U) (R : Y × S → FiniteDistribution V) : |
| outputLaw μ γ sL sR L R = |
| (μ.product (seedLaw γ L R)).pushforward |
| (fun z => (left sL z.2 z.1.1, right sR z.2 z.1.2)) := by |
| exact (product_pushforward_eq_mixture_right μ (seedLaw γ L R) |
| (fun z : (X × Y) × Seed Γ X Y S U V => |
| (left sL z.2 z.1.1, right sR z.2 z.1.2))).symm |
|
|
| theorem outputLaw_eq_mixture |
| (μ : FiniteDistribution (X × Y)) (γ : FiniteDistribution Γ) |
| (sL : Γ → X → S) (sR : Γ → Y → S) |
| (L : X × S → FiniteDistribution U) (R : Y × S → FiniteDistribution V) : |
| outputLaw μ γ sL sR L R = |
| (sharedOutputLaw μ γ sL sR).mixture (completionKernel L R) := by |
| calc |
| outputLaw μ γ sL sR L R = |
| (μ.product γ).mixture (fun z => |
| (KernelSampling.seedLaw L R).pushforward (fun table => |
| (KernelSampling.readLeft table (z.1.1, sL z.2 z.1.1), |
| KernelSampling.readRight table (z.1.2, sR z.2 z.1.2)))) := by |
| rw [outputLaw_eq_product_pushforward] |
| exact product_product_pushforward_eq_mixture μ γ (KernelSampling.seedLaw L R) |
| (fun q seed table => |
| (KernelSampling.readLeft table (q.1, sL seed q.1), |
| KernelSampling.readRight table (q.2, sR seed q.2))) |
| _ = (μ.product γ).mixture (fun z => |
| completionKernel L R (z.1, sL z.2 z.1.1, sR z.2 z.1.2)) := by |
| apply congrArg ((μ.product γ).mixture) |
| funext z |
| exact KernelSampling.read_joint_pushforward L R |
| (z.1.1, sL z.2 z.1.1) (z.1.2, sR z.2 z.1.2) |
| _ = (sharedOutputLaw μ γ sL sR).mixture (completionKernel L R) := by |
| exact (mixture_pushforward_base (μ.product γ) |
| (fun z => (z.1, sL z.2 z.1.1, sR z.2 z.1.2)) (completionKernel L R)).symm |
|
|
| omit [DecidableEq X] [DecidableEq Y] [DecidableEq S] in |
| |
| theorem diagonalLaw_completion_mixture |
| (σ : FiniteDistribution ((X × Y) × S)) |
| (L : X × S → FiniteDistribution U) (R : Y × S → FiniteDistribution V) : |
| (diagonalLaw σ).mixture (completionKernel L R) = |
| σ.mixture (fun z => (L (z.1.1, z.2)).product (R (z.1.2, z.2))) := by |
| exact diagonalLaw_mixture σ (completionKernel L R) |
|
|
| theorem outputLaw_totalVariation_le |
| (μ : FiniteDistribution (X × Y)) (γ : FiniteDistribution Γ) |
| (sL : Γ → X → S) (sR : Γ → Y → S) |
| (L : X × S → FiniteDistribution U) (R : Y × S → FiniteDistribution V) |
| (σ : FiniteDistribution ((X × Y) × S)) : |
| (outputLaw μ γ sL sR L R).totalVariation |
| (σ.mixture (fun z => (L (z.1.1, z.2)).product (R (z.1.2, z.2)))) ≤ |
| (sharedOutputLaw μ γ sL sR).totalVariation (diagonalLaw σ) := by |
| rw [outputLaw_eq_mixture, ← diagonalLaw_completion_mixture σ L R] |
| exact mixture_totalVariation_le _ _ (completionKernel L R) |
|
|
| end Completion |
|
|
| section CoordinateCompletion |
|
|
| variable {I X Y S Γ : Type*} |
| [Fintype I] [Fintype X] [Fintype Y] [Fintype S] [Fintype Γ] |
| [DecidableEq I] [DecidableEq X] [DecidableEq Y] [DecidableEq S] |
|
|
| def coordinateLeft (j : I) (sL : Γ → X → S) |
| (seed : Seed Γ X Y S (I → X) (I → Y)) (x : X) : I → X := |
| KernelSampling.completedLeft j seed.2 (x, sL seed.1 x) |
|
|
| def coordinateRight (j : I) (sR : Γ → Y → S) |
| (seed : Seed Γ X Y S (I → X) (I → Y)) (y : Y) : I → Y := |
| KernelSampling.completedRight j seed.2 (y, sR seed.1 y) |
|
|
| omit [Fintype I] [Fintype X] [Fintype Y] [Fintype S] [Fintype Γ] |
| [DecidableEq X] [DecidableEq Y] [DecidableEq S] in |
| @[simp] theorem coordinateLeft_preserves (j : I) (sL : Γ → X → S) |
| (seed : Seed Γ X Y S (I → X) (I → Y)) (x : X) : |
| coordinateLeft j sL seed x j = x := by |
| simp [coordinateLeft] |
|
|
| omit [Fintype I] [Fintype X] [Fintype Y] [Fintype S] [Fintype Γ] |
| [DecidableEq X] [DecidableEq Y] [DecidableEq S] in |
| @[simp] theorem coordinateRight_preserves (j : I) (sR : Γ → Y → S) |
| (seed : Seed Γ X Y S (I → X) (I → Y)) (y : Y) : |
| coordinateRight j sR seed y j = y := by |
| simp [coordinateRight] |
|
|
| def coordinateOutputLaw (μ : FiniteDistribution (X × Y)) (γ : FiniteDistribution Γ) |
| (j : I) (sL : Γ → X → S) (sR : Γ → Y → S) |
| (L : X × S → FiniteDistribution (I → X)) |
| (R : Y × S → FiniteDistribution (I → Y)) : |
| FiniteDistribution ((I → X) × (I → Y)) := |
| (seedLaw γ L R).mixture (fun seed => μ.pushforward |
| (fun q => (coordinateLeft j sL seed q.1, coordinateRight j sR seed q.2))) |
|
|
| theorem coordinateOutputLaw_eq_mixture |
| (μ : FiniteDistribution (X × Y)) (γ : FiniteDistribution Γ) |
| (j : I) (sL : Γ → X → S) (sR : Γ → Y → S) |
| (L : X × S → FiniteDistribution (I → X)) |
| (R : Y × S → FiniteDistribution (I → Y)) |
| (hL : ∀ q xs, (L q).weight xs ≠ 0 → xs j = q.1) |
| (hR : ∀ q ys, (R q).weight ys ≠ 0 → ys j = q.1) : |
| coordinateOutputLaw μ γ j sL sR L R = |
| (sharedOutputLaw μ γ sL sR).mixture (completionKernel L R) := by |
| calc |
| coordinateOutputLaw μ γ j sL sR L R = |
| (μ.product (seedLaw γ L R)).pushforward |
| (fun z => (coordinateLeft j sL z.2 z.1.1, |
| coordinateRight j sR z.2 z.1.2)) := by |
| exact (product_pushforward_eq_mixture_right μ (seedLaw γ L R) |
| (fun z : (X × Y) × Seed Γ X Y S (I → X) (I → Y) => |
| (coordinateLeft j sL z.2 z.1.1, coordinateRight j sR z.2 z.1.2))).symm |
| _ = (μ.product γ).mixture (fun z => |
| (KernelSampling.seedLaw L R).pushforward (fun table => |
| (KernelSampling.completedLeft j table (z.1.1, sL z.2 z.1.1), |
| KernelSampling.completedRight j table (z.1.2, sR z.2 z.1.2)))) := by |
| exact product_product_pushforward_eq_mixture μ γ (KernelSampling.seedLaw L R) |
| (fun q seed table => |
| (KernelSampling.completedLeft j table (q.1, sL seed q.1), |
| KernelSampling.completedRight j table (q.2, sR seed q.2))) |
| _ = (μ.product γ).mixture (fun z => |
| completionKernel L R (z.1, sL z.2 z.1.1, sR z.2 z.1.2)) := by |
| apply congrArg ((μ.product γ).mixture) |
| funext z |
| exact KernelSampling.completed_joint_pushforward L R j hL hR |
| (z.1.1, sL z.2 z.1.1) (z.1.2, sR z.2 z.1.2) |
| _ = (sharedOutputLaw μ γ sL sR).mixture (completionKernel L R) := by |
| exact (mixture_pushforward_base (μ.product γ) |
| (fun z => (z.1, sL z.2 z.1.1, sR z.2 z.1.2)) (completionKernel L R)).symm |
|
|
| theorem coordinateOutputLaw_eq_outputLaw |
| (μ : FiniteDistribution (X × Y)) (γ : FiniteDistribution Γ) |
| (j : I) (sL : Γ → X → S) (sR : Γ → Y → S) |
| (L : X × S → FiniteDistribution (I → X)) |
| (R : Y × S → FiniteDistribution (I → Y)) |
| (hL : ∀ q xs, (L q).weight xs ≠ 0 → xs j = q.1) |
| (hR : ∀ q ys, (R q).weight ys ≠ 0 → ys j = q.1) : |
| coordinateOutputLaw μ γ j sL sR L R = outputLaw μ γ sL sR L R := by |
| rw [coordinateOutputLaw_eq_mixture μ γ j sL sR L R hL hR, outputLaw_eq_mixture] |
|
|
| theorem coordinateOutputLaw_totalVariation_le |
| (μ : FiniteDistribution (X × Y)) (γ : FiniteDistribution Γ) |
| (j : I) (sL : Γ → X → S) (sR : Γ → Y → S) |
| (L : X × S → FiniteDistribution (I → X)) |
| (R : Y × S → FiniteDistribution (I → Y)) |
| (hL : ∀ q xs, (L q).weight xs ≠ 0 → xs j = q.1) |
| (hR : ∀ q ys, (R q).weight ys ≠ 0 → ys j = q.1) |
| (σ : FiniteDistribution ((X × Y) × S)) : |
| (coordinateOutputLaw μ γ j sL sR L R).totalVariation |
| (σ.mixture (fun z => (L (z.1.1, z.2)).product (R (z.1.2, z.2)))) ≤ |
| (sharedOutputLaw μ γ sL sR).totalVariation (diagonalLaw σ) := by |
| rw [coordinateOutputLaw_eq_outputLaw μ γ j sL sR L R hL hR] |
| exact outputLaw_totalVariation_le μ γ sL sR L R σ |
|
|
| end CoordinateCompletion |
|
|
| end |
|
|
| end UniqueGames.Foundations.Repetition.CompletedSampling |
|
|
| end |
|
|
|
|
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
