| import Mathlib |
| import OAI.Computability.VertexCover.Games.Stochastic |
| import OAI.Computability.VertexCover.Information.GamesAdapter |
| import OAI.Computability.VertexCover.Sampling.SharedProfiles |
| import OAI.Computability.VertexCover.Repetition.Overlap |
|
|
| 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 |
|
|
| open scoped BigOperators |
| open Games |
| noncomputable section |
|
|
| universe u |
|
|
| def TraceSeed (σ : Type u) : Nat → Type u |
| | 0 => PUnit |
| | n + 1 => σ × TraceSeed σ n |
| |
| instance traceSeedFintype {σ : Type*} [Fintype σ] (n : Nat) : Fintype (TraceSeed σ n) := by |
| induction n with |
| | zero => exact inferInstanceAs (Fintype PUnit) |
| | succ n ih => exact inferInstanceAs (Fintype (σ × TraceSeed σ n)) |
| |
| instance traceSeedUniqueZero {σ : Type*} : Unique (TraceSeed σ 0) := |
| inferInstanceAs (Unique PUnit) |
| |
| def traceList {σ : Type*} : (n : Nat) → TraceSeed σ n → List σ |
| | 0, _ => [] |
| | n + 1, seed => seed.1 :: traceList n seed.2 |
| |
| def traceSeedLaw {σ : Type*} [Fintype σ] (μ : FiniteDistribution σ) : |
| (n : Nat) → FiniteDistribution (TraceSeed σ n) |
| | 0 => { weight := fun _ => 1, nonnegative := by intro; norm_num, |
| normalized := by simp } |
| | n + 1 => μ.product (traceSeedLaw μ n) |
| |
| theorem traceSeedLaw_expectation {σ : Type*} [Fintype σ] |
| (μ : FiniteDistribution σ) (n : Nat) (f : List σ → ℝ) : |
| (traceSeedLaw μ n).expectation (fun seed => f (traceList n seed)) = |
| CorrelatedSampling.traceAverage μ.weight n f := by |
| induction n generalizing f with |
| | zero => simp [traceSeedLaw, traceList, FiniteDistribution.expectation, |
| CorrelatedSampling.traceAverage] |
| | succ n ih => |
| change (μ.product (traceSeedLaw μ n)).expectation |
| (fun seed => f (seed.1 :: traceList n seed.2)) = _ |
| rw [FiniteDistribution.expectation_product] |
| simp only [CorrelatedSampling.traceAverage, FiniteDistribution.expectation] |
| apply Finset.sum_congr rfl |
| intro s _ |
| congr 1 |
| exact ih (fun xs => f (s :: xs)) |
| |
| def sharedOutputLaw {X Y S Seed : Type*} |
| [Fintype X] [Fintype Y] [Fintype S] [Fintype Seed] [DecidableEq S] |
| (μ : FiniteDistribution (X × Y)) (seedLaw : FiniteDistribution Seed) |
| (left : Seed → X → S) (right : Seed → Y → S) : |
| FiniteDistribution ((X × Y) × S × S) := |
| (μ.product seedLaw).pushforward |
| (fun z => (z.1, left z.2 z.1.1, right z.2 z.1.2)) |
| |
| theorem sharedOutputLaw_weight {X Y S Seed : Type*} |
| [Fintype X] [Fintype Y] [Fintype S] [Fintype Seed] [DecidableEq S] |
| (μ : FiniteDistribution (X × Y)) (seedLaw : FiniteDistribution Seed) |
| (left : Seed → X → S) (right : Seed → Y → S) (x : X) (y : Y) (a b : S) : |
| (sharedOutputLaw μ seedLaw left right).weight ((x,y),a,b) = |
| μ.weight (x,y) * seedLaw.expectation |
| (fun seed => if left seed x = a ∧ right seed y = b then 1 else 0) := by |
| classical |
| simp only [sharedOutputLaw, FiniteDistribution.pushforward, |
| FiniteDistribution.product, Fintype.sum_prod_type, Prod.mk.injEq] |
| simp only [and_assoc, ite_and] |
| simp [FiniteDistribution.expectation, Finset.mul_sum, mul_ite] |
| |
| section Rectangle |
| |
| open CorrelatedSampling |
| |
| variable {X Y S : Type*} [Fintype X] [Fintype Y] [Fintype S] |
| [Nonempty S] [DecidableEq S] |
| |
| def samplerLocal (thresholds : List ℝ) (profile : X → FiniteDistribution S) |
| (fallback : S) (n : Nat) (seed : TraceSeed (RectangleSeed thresholds S) n) |
| (x : X) : S := |
| localSample (rectangleAccept thresholds (profile x).weight) Prod.fst fallback |
| (traceList n seed) |
| |
| def samplerOutputLaw (thresholds : List ℝ) (μ : FiniteDistribution (X × Y)) |
| (L : X → FiniteDistribution S) (R : Y → FiniteDistribution S) |
| (fallback : S) (n : Nat) : FiniteDistribution ((X × Y) × S × S) := |
| sharedOutputLaw μ (traceSeedLaw (rectangleDistribution thresholds) n) |
| (samplerLocal thresholds L fallback n) (samplerLocal thresholds R fallback n) |
| |
| omit [Nonempty S] [DecidableEq S] in |
| theorem probability_weight_le_one (μ : FiniteDistribution S) (s : S) : μ.weight s ≤ 1 := by |
| calc |
| μ.weight s ≤ ∑ t, μ.weight t := |
| Finset.single_le_sum (fun t _ => μ.nonnegative t) (Finset.mem_univ s) |
| _ = 1 := μ.normalized |
| |
| theorem samplerOutputLaw_diagonal (thresholds : List ℝ) |
| (μ : FiniteDistribution (X × Y)) |
| (L : X → FiniteDistribution S) (R : Y → FiniteDistribution S) |
| (hL : ∀ x s, (L x).weight s ∈ thresholds) |
| (hR : ∀ y s, (R y).weight s ∈ thresholds) |
| (fallback : S) (n : Nat) (x : X) (y : Y) (a : S) : |
| μ.weight (x,y) * min ((L x).weight a) ((R y).weight a) / |
| (1 + Information.totalVariation (L x).weight (R y).weight) * |
| (1 - eventMass (rectangleWeight thresholds) |
| (fun s => !(rectangleAccept thresholds (L x).weight s || |
| rectangleAccept thresholds (R y).weight s)) ^ n) ≤ |
| (samplerOutputLaw thresholds μ L R fallback n).weight ((x,y),a,a) := by |
| have h := rectangle_label_diagonal_bound thresholds (L x).weight (R y).weight |
| fallback a (hL x) (hR y) (L x).nonnegative (R y).nonnegative |
| (probability_weight_le_one (L x)) (probability_weight_le_one (R y)) |
| (L x).normalized (R y).normalized n |
| rw [samplerOutputLaw, sharedOutputLaw_weight] |
| have he : (traceSeedLaw (rectangleDistribution (α := S) thresholds) n).expectation |
| (fun seed => if samplerLocal thresholds L fallback n seed x = a ∧ |
| samplerLocal thresholds R fallback n seed y = a then 1 else 0) = |
| traceAverage (rectangleWeight thresholds) n |
| (localDiagonal (rectangleAccept thresholds (L x).weight) |
| (rectangleAccept thresholds (R y).weight) Prod.fst fallback a) := by |
| exact traceSeedLaw_expectation (rectangleDistribution (α := S) thresholds) n |
| (localDiagonal (rectangleAccept thresholds (L x).weight) |
| (rectangleAccept thresholds (R y).weight) Prod.fst fallback a) |
| rw [he] |
| simp only [Information.totalVariation, CorrelatedSampling.totalVariation] at h ⊢ |
| simpa only [mul_div_assoc, mul_assoc] using |
| mul_le_mul_of_nonneg_left h (μ.nonnegative (x,y)) |
| |
| theorem samplerOutputLaw_uniform_diagonal |
| (μ : FiniteDistribution (X × Y)) |
| (L : X → FiniteDistribution S) (R : Y → FiniteDistribution S) |
| (fallback : S) (n : Nat) (x : X) (y : Y) (a : S) : |
| μ.weight (x,y) * min ((L x).weight a) ((R y).weight a) / |
| (1 + Information.totalVariation (L x).weight (R y).weight) * |
| (1 - uniformRejectionRate S ^ n) ≤ |
| (samplerOutputLaw (sharedProfileThresholds L R) μ L R fallback n).weight ((x,y),a,a) := by |
| have hp := pow_le_pow_left₀ (sharedProfileReject_nonnegative L R x y) |
| (sharedProfile_reject_le_rate L R x y) n |
| have hco : 0 ≤ μ.weight (x,y) * min ((L x).weight a) ((R y).weight a) / |
| (1 + Information.totalVariation (L x).weight (R y).weight) := |
| div_nonneg (mul_nonneg (μ.nonnegative (x,y)) |
| (le_min ((L x).nonnegative a) ((R y).nonnegative a))) |
| (by linarith [Information.totalVariation_nonneg (L x).weight (R y).weight]) |
| have h := samplerOutputLaw_diagonal (sharedProfileThresholds L R) μ L R |
| (left_mem_sharedProfileThresholds L R) (right_mem_sharedProfileThresholds L R) |
| fallback n x y a |
| exact (mul_le_mul_of_nonneg_left (sub_le_sub_left hp 1) hco).trans h |
| |
| theorem samplerOutputLaw_totalVariation |
| (p : FiniteDistribution ((X × Y) × S)) (μ : FiniteDistribution (X × Y)) |
| (L : X → FiniteDistribution S) (R : Y → FiniteDistribution S) |
| (fallback : S) (n : Nat) : |
| Information.totalVariation |
| (samplerOutputLaw (sharedProfileThresholds L R) μ L R fallback n).weight |
| (diagonalWeights p.weight) ≤ |
| 2 * Information.totalVariation p.weight (fun z => μ.weight z.1 * (L z.1.1).weight z.2) + |
| 2 * Information.totalVariation p.weight (fun z => μ.weight z.1 * (R z.1.2).weight z.2) + |
| uniformRejectionRate S ^ n := by |
| apply diagonal_sampler_totalVariation_le p.weight μ.weight |
| (fun xy => (L xy.1).weight) (fun xy => (R xy.2).weight) _ |
| (Information.gameLaw_isProbability p) (Information.gameLaw_isProbability μ) |
| (fun xy => Information.gameLaw_isProbability (L xy.1)) |
| (fun xy => Information.gameLaw_isProbability (R xy.2)) |
| (Information.gameLaw_isProbability _) |
| (pow_nonneg (uniformRejectionRate_nonnegative S) n) |
| · exact pow_le_one₀ (uniformRejectionRate_nonnegative S) |
| (uniformRejectionRate_lt_one S).le |
| · intro xy a |
| exact samplerOutputLaw_uniform_diagonal μ L R fallback n xy.1 xy.2 a |
| |
| theorem samplerOutputLaw_arbitrarily_close |
| (p : FiniteDistribution ((X × Y) × S)) (μ : FiniteDistribution (X × Y)) |
| (L : X → FiniteDistribution S) (R : Y → FiniteDistribution S) |
| (fallback : S) (η : ℝ) (hη : 0 < η) : ∃ n : Nat, |
| Information.totalVariation |
| (samplerOutputLaw (sharedProfileThresholds L R) μ L R fallback n).weight |
| (diagonalWeights p.weight) ≤ |
| 2 * Information.totalVariation p.weight (fun z => μ.weight z.1 * (L z.1.1).weight z.2) + |
| 2 * Information.totalVariation p.weight (fun z => μ.weight z.1 * (R z.1.2).weight z.2) + η := by |
| obtain ⟨n,hn⟩ := exists_uniformRejectionRate_pow_lt S η hη |
| exact ⟨n, (samplerOutputLaw_totalVariation p μ L R fallback n).trans |
| (by linarith)⟩ |
| |
| end Rectangle |
| |
| end |
| end UniqueGames.Foundations.Repetition |
| |
| 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 |
| |
