Download data/lean/OAI/Computability/MinUncut/PCP/CompletedSampling.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 29.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/MinUncut/PCP/CompletedSampling.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/MinUncut/PCP/CompletedSampling.lean
-
curl -L -o CompletedSampling.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/MinUncut/PCP/CompletedSampling.lean
29.9 kB
| 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 | |