| import Mathlib |
| import OAI.Computability.MinUncut.PCP.Overlap |
|
|
| namespace OAI |
|
|
| namespace MinUncutGames.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 |
|
|
| 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 |
|
|
| end MinUncutGames.Foundations.Repetition.CompletedSampling |
|
|
| namespace MinUncutGames.Foundations.Games.Game |
|
|
| noncomputable section |
|
|
| variable {Q₁ Q₂ A₁ A₂ R₁ R₂ B₁ B₂ Seed : Type*} |
| [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂] |
| [Fintype R₁] [Fintype R₂] [Fintype B₁] [Fintype B₂] [Fintype Seed] |
| [Nonempty A₁] [Nonempty A₂] |
|
|
| def localEmbeddingLaw (G : Game Q₁ Q₂ A₁ A₂) |
| (seedLaw : FiniteDistribution Seed) |
| (left : Seed → Q₁ → R₁) (right : Seed → Q₂ → R₂) : |
| FiniteDistribution (R₁ × R₂) := |
| seedLaw.mixture fun seed => |
| G.questions.pushforward fun q => (left seed q.1, right seed q.2) |
|
|
| theorem success_le_value_add_embedding_distance |
| (G : Game Q₁ Q₂ A₁ A₂) (H : Game R₁ R₂ B₁ B₂) |
| (seedLaw : FiniteDistribution Seed) |
| (left : Seed → Q₁ → R₁) (right : Seed → Q₂ → R₂) |
| (answerLeft : Seed → Q₁ → B₁ → A₁) |
| (answerRight : Seed → Q₂ → B₂ → A₂) |
| (acceptance : ∀ seed x y a b, |
| H.accepts (left seed x) (right seed y) a b = true → |
| G.accepts x y (answerLeft seed x a) (answerRight seed y b) = true) |
| (strategy : Strategy R₁ R₂ B₁ B₂) : |
| H.success strategy ≤ G.value + |
| H.questions.totalVariation (G.localEmbeddingLaw seedLaw left right) := by |
| have localBound (seed : Seed) : |
| (G.questions.pushforward (fun q => (left seed q.1, right seed q.2))).probability |
| (H.wins strategy) ≤ G.value := by |
| let embedded : Game R₁ R₂ B₁ B₂ := |
| { questions := G.questions.pushforward fun q => (left seed q.1, right seed q.2) |
| accepts := H.accepts } |
| change embedded.success strategy ≤ G.value |
| exact (G.success_le_of_localSimulation embedded (left seed) (right seed) |
| (answerLeft seed) (answerRight seed) rfl (acceptance seed) strategy).trans |
| (G.success_le_value _) |
| have mixtureBound : |
| (G.localEmbeddingLaw seedLaw left right).probability (H.wins strategy) ≤ G.value := |
| seedLaw.probability_mixture_le _ _ _ localBound |
| exact (H.questions.probability_le_add_totalVariation |
| (G.localEmbeddingLaw seedLaw left right) (H.wins strategy)).trans |
| (add_le_add mixtureBound (le_refl _)) |
|
|
| def coordinateGame (G : Game Q₁ Q₂ A₁ A₂) {n : Nat} (coordinate : Fin n) |
| (law : FiniteDistribution ((Fin n → Q₁) × (Fin n → Q₂))) : |
| Game (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂) where |
| questions := law |
| accepts x y a b := G.accepts (x coordinate) (y coordinate) (a coordinate) (b coordinate) |
|
|
| theorem coordinate_probability_le_value_add_embedding_distance |
| (G : Game Q₁ Q₂ A₁ A₂) {n : Nat} (coordinate : Fin n) |
| (law : FiniteDistribution ((Fin n → Q₁) × (Fin n → Q₂))) |
| (seedLaw : FiniteDistribution Seed) |
| (left : Seed → Q₁ → Fin n → Q₁) (right : Seed → Q₂ → Fin n → Q₂) |
| (left_preserves : ∀ seed x, left seed x coordinate = x) |
| (right_preserves : ∀ seed y, right seed y coordinate = y) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) : |
| law.probability (G.coordinateWin strategy coordinate) ≤ G.value + |
| law.totalVariation (G.localEmbeddingLaw seedLaw left right) := by |
| apply G.success_le_value_add_embedding_distance (G.coordinateGame coordinate law) |
| seedLaw left right (fun _ _ a => a coordinate) (fun _ _ b => b coordinate) |
| intro seed x y a b h |
| simpa only [coordinateGame, left_preserves, right_preserves] using h |
|
|
| theorem coordinate_probability_le_value_of_approximate_embeddings |
| {SeedFamily : Nat → Type*} [∀ t, Fintype (SeedFamily t)] |
| (G : Game Q₁ Q₂ A₁ A₂) {n : Nat} (coordinate : Fin n) |
| (law : FiniteDistribution ((Fin n → Q₁) × (Fin n → Q₂))) |
| (seedLaw : (t : Nat) → FiniteDistribution (SeedFamily t)) |
| (left : (t : Nat) → SeedFamily t → Q₁ → Fin n → Q₁) |
| (right : (t : Nat) → SeedFamily t → Q₂ → Fin n → Q₂) |
| (left_preserves : ∀ t seed x, left t seed x coordinate = x) |
| (right_preserves : ∀ t seed y, right t seed y coordinate = y) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (distance : ℝ) |
| (close : ∀ η : ℝ, 0 < η → ∃ t, |
| law.totalVariation (G.localEmbeddingLaw (seedLaw t) (left t) (right t)) ≤ |
| distance + η) : |
| law.probability (G.coordinateWin strategy coordinate) ≤ G.value + distance := by |
| by_contra h |
| have gap : 0 < law.probability (G.coordinateWin strategy coordinate) - |
| (G.value + distance) := sub_pos.mpr (lt_of_not_ge h) |
| obtain ⟨t, ht⟩ := close |
| ((law.probability (G.coordinateWin strategy coordinate) - (G.value + distance)) / 2) |
| (by linarith) |
| have bound := G.coordinate_probability_le_value_add_embedding_distance coordinate law |
| (seedLaw t) (left t) (right t) (left_preserves t) (right_preserves t) strategy |
| linarith |
|
|
| end |
| end MinUncutGames.Foundations.Games.Game |
|
|
| namespace MinUncutGames.Foundations.Repetition |
| open scoped BigOperators |
| open Games CorrelatedSampling |
| noncomputable section |
| variable {Q₁ Q₂ A₁ A₂ S : Type*} |
| [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂] [Fintype S] |
| [Nonempty A₁] [Nonempty A₂] [Nonempty S] |
| [DecidableEq Q₁] [DecidableEq Q₂] [DecidableEq S] {n : Nat} |
|
|
| theorem coordinate_probability_le_value_of_local_completion |
| (G : Game Q₁ Q₂ A₁ A₂) (j : Fin n) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (σ : FiniteDistribution ((Q₁ × Q₂) × S)) |
| (profileL : Q₁ → FiniteDistribution S) (profileR : Q₂ → FiniteDistribution S) |
| (completionL : Q₁ × S → FiniteDistribution (Fin n → Q₁)) |
| (completionR : Q₂ × S → FiniteDistribution (Fin n → Q₂)) |
| (supportL : ∀ q xs, (completionL q).weight xs ≠ 0 → xs j = q.1) |
| (supportR : ∀ q ys, (completionR q).weight ys ≠ 0 → ys j = q.1) |
| (fallback : S) : |
| (σ.mixture (fun z => (completionL (z.1.1,z.2)).product |
| (completionR (z.1.2,z.2)))).probability (G.coordinateWin strategy j) ≤ |
| G.value + |
| (2 * Information.totalVariation σ.weight |
| (fun z => G.questions.weight z.1 * (profileL z.1.1).weight z.2) + |
| 2 * Information.totalVariation σ.weight |
| (fun z => G.questions.weight z.1 * (profileR z.1.2).weight z.2)) := by |
| let targetLaw := σ.mixture (fun z => (completionL (z.1.1,z.2)).product (completionR (z.1.2,z.2))) |
| let δ := 2 * Information.totalVariation σ.weight |
| (fun z => G.questions.weight z.1 * (profileL z.1.1).weight z.2) + |
| 2 * Information.totalVariation σ.weight |
| (fun z => G.questions.weight z.1 * (profileR z.1.2).weight z.2) |
| change targetLaw.probability (G.coordinateWin strategy j) ≤ G.value + δ |
| by_contra h |
| have gap : 0 < targetLaw.probability (G.coordinateWin strategy j) - (G.value + δ) := |
| sub_pos.mpr (lt_of_not_ge h) |
| let η := (targetLaw.probability (G.coordinateWin strategy j) - (G.value + δ)) / 2 |
| have hη : 0 < η := by dsimp [η]; linarith |
| obtain ⟨N,hN⟩ := samplerOutputLaw_arbitrarily_close σ G.questions profileL profileR fallback η hη |
| let thresholds := sharedProfileThresholds profileL profileR |
| let γ := traceSeedLaw (rectangleDistribution (α := S) thresholds) N |
| let sL := samplerLocal thresholds profileL fallback N |
| let sR := samplerLocal thresholds profileR fallback N |
| have hvariation := CompletedSampling.coordinateOutputLaw_totalVariation_le |
| G.questions γ j sL sR completionL completionR supportL supportR σ |
| have hclose : (CompletedSampling.coordinateOutputLaw G.questions γ j sL sR completionL completionR).totalVariation targetLaw ≤ δ + η := |
| hvariation.trans hN |
| have hsuccess := G.coordinate_probability_le_value_add_embedding_distance j targetLaw |
| (CompletedSampling.seedLaw γ completionL completionR) |
| (CompletedSampling.coordinateLeft j sL) (CompletedSampling.coordinateRight j sR) |
| (CompletedSampling.coordinateLeft_preserves j sL) |
| (CompletedSampling.coordinateRight_preserves j sR) strategy |
| have hsym : targetLaw.totalVariation |
| (G.localEmbeddingLaw (CompletedSampling.seedLaw γ completionL completionR) |
| (CompletedSampling.coordinateLeft j sL) (CompletedSampling.coordinateRight j sR)) = |
| (CompletedSampling.coordinateOutputLaw G.questions γ j sL sR completionL completionR).totalVariation targetLaw := by |
| unfold FiniteDistribution.totalVariation |
| congr 1 |
| apply Finset.sum_congr rfl |
| intro q _ |
| exact abs_sub_comm _ _ |
| rw [hsym] at hsuccess |
| dsimp [η] at hclose |
| linarith |
|
|
| end |
|
|
| noncomputable def logTwo (x : ℝ) : ℝ := Real.log x / Real.log 2 |
|
|
| @[simp] theorem logTwo_one : logTwo 1 = 0 := by simp [logTwo] |
|
|
| theorem logTwo_inv_le_of_half_pow_le {p : ℝ} (m : ℕ) |
| (h : (1 / 2 : ℝ) ^ m ≤ p) : logTwo (1 / p) ≤ m := by |
| have hp : 0 < p := (pow_pos (by norm_num : (0 : ℝ) < 1 / 2) m).trans_le h |
| have hlog := Real.log_le_log (pow_pos (by norm_num : (0 : ℝ) < 1 / 2) m) h |
| have hhalf : Real.log (1 / 2 : ℝ) = -Real.log 2 := by |
| rw [one_div, Real.log_inv] |
| rw [Real.log_pow, hhalf] at hlog |
| unfold logTwo |
| rw [one_div, Real.log_inv] |
| apply (div_le_iff₀ (Real.log_pos (by norm_num : (1 : ℝ) < 2))).2 |
| nlinarith |
|
|
| theorem contraction_step {v ell : ℝ} {n m : ℕ} {p next : ℝ} |
| (hv0 : 0 ≤ v) (hv1 : v < 1) (hell : 1 ≤ ell) |
| (hm : 1 ≤ m) (hmn : m < n) (hp : 0 ≤ p) |
| (hmono : next ≤ p) |
| (hprev : p ≤ ((1 + v) / 2) ^ m) |
| (hcut : 2700 * (m : ℝ) * ell ≤ (1 - v) ^ 2 * ((n : ℝ) - m)) |
| (hstep : next ≤ p * (v + 15 * Real.sqrt |
| (((m : ℝ) * ell + logTwo (1 / p)) / ((n : ℝ) - m)))) : |
| next ≤ ((1 + v) / 2) ^ (m + 1) := by |
| by_cases hsmall : p ≤ ((1 + v) / 2) ^ (m + 1) |
| · exact hmono.trans hsmall |
| have hq : (1 / 2 : ℝ) ≤ (1 + v) / 2 := by linarith |
| have hhalf : (1 / 2 : ℝ) ^ (m + 1) ≤ p := |
| (pow_le_pow_left₀ (by norm_num) hq (m + 1)).trans (le_of_not_ge hsmall) |
| have hlog := logTwo_inv_le_of_half_pow_le (m + 1) hhalf |
| have hmreal : (1 : ℝ) ≤ m := by exact_mod_cast hm |
| have hden : 0 < (n : ℝ) - m := by |
| have hmnreal : (m : ℝ) < n := by exact_mod_cast hmn |
| linarith |
| have hmell : (m : ℝ) ≤ (m : ℝ) * ell := by nlinarith |
| have hbudget : (m : ℝ) * ell + logTwo (1 / p) ≤ 3 * (m : ℝ) * ell := by |
| simp only [Nat.cast_add, Nat.cast_one] at hlog |
| nlinarith |
| have hsqrt : Real.sqrt |
| (((m : ℝ) * ell + logTwo (1 / p)) / ((n : ℝ) - m)) ≤ (1 - v) / 30 := by |
| apply (Real.sqrt_le_left (by linarith : 0 ≤ (1 - v) / 30)).2 |
| apply (div_le_iff₀ hden).2 |
| nlinarith |
| have hfactor : v + 15 * Real.sqrt |
| (((m : ℝ) * ell + logTwo (1 / p)) / ((n : ℝ) - m)) ≤ (1 + v) / 2 := by |
| linarith |
| calc |
| next ≤ p * (v + 15 * Real.sqrt |
| (((m : ℝ) * ell + logTwo (1 / p)) / ((n : ℝ) - m))) := hstep |
| _ ≤ p * ((1 + v) / 2) := mul_le_mul_of_nonneg_left hfactor hp |
| _ ≤ ((1 + v) / 2) ^ m * ((1 + v) / 2) := |
| mul_le_mul_of_nonneg_right hprev (by linarith) |
| _ = ((1 + v) / 2) ^ (m + 1) := (pow_succ _ _).symm |
|
|
| theorem initial_step {v ell next : ℝ} {n : ℕ} |
| (hstep : next ≤ 1 * (v + 15 * Real.sqrt |
| (((0 : ℝ) * ell + logTwo (1 / 1)) / ((n : ℝ) - 0)))) : |
| next ≤ v := by simpa using hstep |
|
|
| theorem cutoff_step {v ell : ℝ} {n m : ℕ} |
| (hv0 : 0 ≤ v) (hv1 : v < 1) (hell : 1 ≤ ell) |
| (hm : (m : ℝ) < (n : ℝ) * (1 - v) ^ 2 / (2925 * ell)) : |
| 2700 * (m : ℝ) * ell ≤ (1 - v) ^ 2 * ((n : ℝ) - m) := by |
| have hell0 : 0 < ell := by linarith |
| have hd : (1 - v) ^ 2 ≤ 1 := by nlinarith |
| have hmul : (m : ℝ) * (2925 * ell) < (n : ℝ) * (1 - v) ^ 2 := |
| (lt_div_iff₀ (by positivity : 0 < 2925 * ell)).1 hm |
| have hdell : (1 - v) ^ 2 ≤ 225 * ell := by linarith |
| have hprod := mul_le_mul_of_nonneg_left hdell (Nat.cast_nonneg m : (0 : ℝ) ≤ m) |
| nlinarith |
|
|
| theorem cutoff_le_length {v ell : ℝ} (n : ℕ) |
| (hv0 : 0 ≤ v) (hv1 : v < 1) (hell : 1 ≤ ell) : |
| (n : ℝ) * (1 - v) ^ 2 / (2925 * ell) ≤ n := by |
| have hell0 : 0 < ell := by linarith |
| apply (div_le_iff₀ (by positivity : 0 < 2925 * ell)).2 |
| have hd : (1 - v) ^ 2 ≤ 2925 * ell := by nlinarith |
| nlinarith [mul_le_mul_of_nonneg_left hd (Nat.cast_nonneg n : (0 : ℝ) ≤ n)] |
|
|
| def ScalarRecurrence (p : ℕ → ℝ) (n : ℕ) (v ell : ℝ) : Prop := |
| ∀ m, m < n → p (m + 1) ≤ p m * (v + 15 * Real.sqrt |
| (((m : ℝ) * ell + logTwo (1 / p m)) / ((n : ℝ) - m))) |
|
|
| theorem decay_to_cutoff (p : ℕ → ℝ) (n : ℕ) {v ell : ℝ} |
| (hv0 : 0 ≤ v) (hv1 : v < 1) (hell : 1 ≤ ell) |
| (hp0 : p 0 = 1) (hpnonneg : ∀ m, 0 ≤ p m) |
| (hpmono : Antitone p) (hrec : ScalarRecurrence p n v ell) : |
| p n ≤ ((1 + v) / 2) ^ |
| ((n : ℝ) * (1 - v) ^ 2 / (2925 * ell)) := by |
| let T : ℝ := (n : ℝ) * (1 - v) ^ 2 / (2925 * ell) |
| let M : ℕ := Nat.ceil T |
| have hMn : M ≤ n := Nat.ceil_le.mpr (cutoff_le_length n hv0 hv1 hell) |
| have hind : ∀ m, m ≤ M → p m ≤ ((1 + v) / 2) ^ m := by |
| intro m |
| induction m with |
| | zero => intro _; simp [hp0] |
| | succ m ih => |
| intro hmM |
| have hmM' : m < M := Nat.lt_of_succ_le hmM |
| have hmn : m < n := hmM'.trans_le hMn |
| have hprev := ih (Nat.le_of_lt hmM') |
| by_cases hm0 : m = 0 |
| · subst m |
| have hinit : p 1 ≤ v := by |
| have hs := hrec 0 hmn |
| simpa [hp0] using hs |
| simpa using hinit.trans (by linarith : v ≤ (1 + v) / 2) |
| · have hmT : (m : ℝ) < T := Nat.lt_ceil.mp hmM' |
| exact contraction_step hv0 hv1 hell (Nat.one_le_iff_ne_zero.mpr hm0) |
| hmn (hpnonneg m) (hpmono (Nat.le_succ m)) hprev |
| (cutoff_step hv0 hv1 hell hmT) (hrec m hmn) |
| have hq0 : 0 < (1 + v) / 2 := by linarith |
| have hq1 : (1 + v) / 2 ≤ 1 := by linarith |
| calc |
| p n ≤ p M := hpmono hMn |
| _ ≤ ((1 + v) / 2) ^ M := hind M le_rfl |
| _ = ((1 + v) / 2) ^ (M : ℝ) := (Real.rpow_natCast _ _).symm |
| _ ≤ ((1 + v) / 2) ^ T := |
| Real.rpow_le_rpow_of_exponent_ge hq0 hq1 (Nat.le_ceil T) |
|
|
| theorem block_contraction {v : ℝ} (hv0 : 0 ≤ v) (hv1 : v < 1) : |
| ((1 + v) / 2) ^ ((1 - v) ^ 2 / 2925 : ℝ) ≤ |
| 1 - (1 - v) ^ 3 / 5850 := by |
| have hd : (1 - v) ^ 2 ≤ 1 := by nlinarith |
| have hb := rpow_one_add_le_one_add_mul_self |
| (s := -(1 - v) / 2) (p := (1 - v) ^ 2 / 2925) |
| (by linarith) (by positivity) (by nlinarith) |
| have hbase : 1 + -(1 - v) / 2 = (1 + v) / 2 := by ring |
| have hrhs : 1 + (1 - v) ^ 2 / 2925 * (-(1 - v) / 2) = |
| 1 - (1 - v) ^ 3 / 5850 := by ring |
| rwa [hbase, hrhs] at hb |
|
|
| theorem scalar_bound_6000 (p : ℕ → ℝ) (n : ℕ) {v ell : ℝ} |
| (hv0 : 0 ≤ v) (hv1 : v < 1) (hell : 1 ≤ ell) |
| (hp0 : p 0 = 1) (hpnonneg : ∀ m, 0 ≤ p m) |
| (hpmono : Antitone p) (hrec : ScalarRecurrence p n v ell) : |
| p n ≤ (1 - (1 - v) ^ 3 / 6000) ^ ((n : ℝ) / ell) := by |
| have hell0 : 0 < ell := by linarith |
| have hq0 : 0 ≤ (1 + v) / 2 := by linarith |
| have hexp : 0 ≤ (n : ℝ) / ell := by positivity |
| have hblock := block_contraction hv0 hv1 |
| have hweak : 1 - (1 - v) ^ 3 / 5850 ≤ 1 - (1 - v) ^ 3 / 6000 := by |
| have : 0 ≤ (1 - v) ^ 3 := by positivity |
| nlinarith |
| calc |
| p n ≤ ((1 + v) / 2) ^ |
| ((n : ℝ) * (1 - v) ^ 2 / (2925 * ell)) := |
| decay_to_cutoff p n hv0 hv1 hell hp0 hpnonneg hpmono hrec |
| _ = (((1 + v) / 2) ^ ((1 - v) ^ 2 / 2925 : ℝ)) ^ ((n : ℝ) / ell) := by |
| rw [← Real.rpow_mul hq0] |
| congr 1 |
| ring |
| _ ≤ (1 - (1 - v) ^ 3 / 6000) ^ ((n : ℝ) / ell) := |
| Real.rpow_le_rpow (Real.rpow_nonneg hq0 _) (hblock.trans hweak) hexp |
|
|
| noncomputable def incidenceRate : ℝ := 1 - 1 / (100000 * 192 ^ 3) |
|
|
| theorem incidenceRate_pos : 0 < incidenceRate := by norm_num [incidenceRate] |
|
|
| theorem incidenceRate_lt_one : incidenceRate < 1 := by norm_num [incidenceRate] |
|
|
| theorem incidenceRate_fourth : |
| 1 - (1 / 192 : ℝ) ^ 3 / 6000 ≤ incidenceRate ^ 4 := by |
| norm_num [incidenceRate] |
|
|
| theorem incidence_rate_comparison (n : ℕ) : |
| (1 - (1 / 192 : ℝ) ^ 3 / 6000) ^ ((n : ℝ) / 4) ≤ incidenceRate ^ n := by |
| calc |
| (1 - (1 / 192 : ℝ) ^ 3 / 6000) ^ ((n : ℝ) / 4) |
| ≤ (incidenceRate ^ 4) ^ ((n : ℝ) / 4) := |
| Real.rpow_le_rpow (by norm_num) incidenceRate_fourth (by positivity) |
| _ = incidenceRate ^ ((4 : ℝ) * ((n : ℝ) / 4)) := |
| (Real.rpow_natCast_mul incidenceRate_pos.le 4 ((n : ℝ) / 4)).symm |
| _ = incidenceRate ^ (n : ℝ) := by congr 1; ring |
| _ = incidenceRate ^ n := Real.rpow_natCast _ _ |
|
|
| theorem scalar_incidence_bound (p : ℕ → ℝ) (n : ℕ) {v : ℝ} |
| (hv : v ≤ 1 - (1 / 192 : ℝ)) |
| (hp0 : p 0 = 1) (hpnonneg : ∀ m, 0 ≤ p m) |
| (hpmono : Antitone p) (hrec : ScalarRecurrence p n v 4) : |
| p n ≤ incidenceRate ^ n := by |
| have hrec' : ScalarRecurrence p n (1 - (1 / 192 : ℝ)) 4 := by |
| intro m hm |
| exact (hrec m hm).trans (mul_le_mul_of_nonneg_left (by linarith) (hpnonneg m)) |
| have hbound := scalar_bound_6000 p n |
| (v := 1 - (1 / 192 : ℝ)) (ell := 4) |
| (by norm_num) (by norm_num) (by norm_num) hp0 hpnonneg hpmono hrec' |
| norm_num only [sub_sub_cancel] at hbound |
| have hcomparison := incidence_rate_comparison n |
| norm_num at hcomparison |
| exact hbound.trans hcomparison |
|
|
| end MinUncutGames.Foundations.Repetition |
|
|
| end OAI |
|
|
