File size: 6,509 Bytes
760f90e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 | import Mathlib.Tactic.FinCases
import OAI.Computability.UniqueGames.Foundations.SamplingLemmas
import OAI.Computability.UniqueGames.Soundness.SubsetIntersectionLemmas
import OAI.Computability.UniqueGames.Soundness.ZeroInformationLemmas
namespace OAI
section
/-!
Uniform raw advice coefficients obtained by discarding unused flat coordinates.
The intercept, both full columns at every position, and one singleton column at
every position are independent. For a fixed singleton set, selecting the used
columns gives exactly the uniform law on the dynamic raw coefficient type.
The identity holds for every joint test function, not merely for marginals.
-/
namespace UniqueGamesTheorem.Clean.CoefficientSampling
open Foundations.Games
open Soundness.ConditionalIncidences
open Soundness.PartnerFullSampling
open scoped BigOperators
noncomputable section
variable {P C : Type} [Fintype P] [DecidableEq P] [Fintype C] [Nonempty C]
def selectCoefficients (J : Finset P) (extra : C × (P → C × C)) (single : P → C) :
RawCoefficients J C :=
fun slot => match slot with
| none => extra.1
| some (.inl (i, j)) => if j = 0 then (extra.2 i.val).1 else (extra.2 i.val).2
| some (.inr i) => single i.val
/-- Splitting a raw coefficient tuple into its actual independent coordinates. -/
def coefficientProductEquiv (J : Finset P) :
RawCoefficients J C ≃ C × ((PositionOutside J → C × C) × (PositionInside J → C)) where
toFun gamma := (gamma none,
((fun i => (gamma (some (.inl (i, 0))), gamma (some (.inl (i, 1))))),
fun i => gamma (some (.inr i))))
invFun parts := fun slot => match slot with
| none => parts.1
| some (.inl (i, j)) => if j = 0 then (parts.2.1 i).1 else (parts.2.1 i).2
| some (.inr i) => parts.2.2 i
left_inv gamma := by
funext slot
cases slot with
| none => rfl
| some slot =>
cases slot with
| inl pair => rcases pair with ⟨i, j⟩; fin_cases j <;> rfl
| inr i => rfl
right_inv parts := by
rcases parts with ⟨intercept, full, single⟩
rfl
/-- The complement restriction is also uniform, including an empty complement. -/
theorem expect_outside (J : Finset P) (f : (PositionOutside J → C) → ℝ) :
(𝔼 full : P → C, f (fun j => full j.val)) =
𝔼 outside : PositionOutside J → C, f outside := by
calc
_ = 𝔼 parts : (PositionInside J → C) × (PositionOutside J → C), f parts.2 :=
Fintype.expect_equiv (restrictionProductEquiv J) _ _ (fun _ => rfl)
_ = _ := by
simpa only [Finset.univ_product_univ, Fintype.expect_const] using
(Finset.expect_product (Finset.univ : Finset (PositionInside J → C))
(Finset.univ : Finset (PositionOutside J → C)) (fun parts => f parts.2))
omit [Nonempty C] in
theorem expect_rawCoefficients (J : Finset P) (F : RawCoefficients J C → ℝ) :
(𝔼 gamma : RawCoefficients J C, F gamma) =
𝔼 intercept : C, 𝔼 full : PositionOutside J → C × C,
𝔼 single : PositionInside J → C,
F ((coefficientProductEquiv J).symm (intercept, full, single)) := by
calc
_ = 𝔼 parts : C × ((PositionOutside J → C × C) × (PositionInside J → C)),
F ((coefficientProductEquiv J).symm parts) :=
Fintype.expect_equiv (coefficientProductEquiv J) _ _ (fun _ => by simp)
_ = _ := by
rw [← Finset.univ_product_univ, Finset.expect_product]
apply Finset.expect_congr rfl
intro intercept _
rw [← Finset.univ_product_univ, Finset.expect_product]
/-- Sampling all columns and then discarding unused ones has exactly the
uniform joint law on the coefficients used by this singleton set. -/
theorem expect_selectCoefficients (J : Finset P) (F : RawCoefficients J C → ℝ) :
(𝔼 extra : C × (P → C × C), 𝔼 single : P → C,
F (selectCoefficients J extra single)) =
𝔼 gamma : RawCoefficients J C, F gamma := by
calc
_ = 𝔼 intercept : C, 𝔼 full : P → C × C, 𝔼 single : P → C,
F (selectCoefficients J (intercept, full) single) := by
rw [← Finset.univ_product_univ, Finset.expect_product]
_ = 𝔼 intercept : C, 𝔼 full : P → C × C,
𝔼 single : PositionInside J → C,
F ((coefficientProductEquiv J).symm
(intercept, (fun i => full i.val), single)) := by
apply Finset.expect_congr rfl
intro intercept _
apply Finset.expect_congr rfl
intro full _
exact expect_restrictIndices J (fun single =>
F ((coefficientProductEquiv J).symm (intercept, (fun i => full i.val), single)))
_ = 𝔼 intercept : C, 𝔼 full : PositionOutside J → C × C,
𝔼 single : PositionInside J → C,
F ((coefficientProductEquiv J).symm (intercept, full, single)) := by
apply Finset.expect_congr rfl
intro intercept _
exact expect_outside J (fun full => 𝔼 single : PositionInside J → C,
F ((coefficientProductEquiv J).symm (intercept, full, single)))
_ = _ := (expect_rawCoefficients J F).symm
private theorem uniform_expectation_eq_expect {X : Type*} [Fintype X] [Nonempty X]
(f : X → ℝ) : (FiniteDistribution.uniform X).expectation f = 𝔼 x : X, f x := by
rw [FiniteDistribution.expectation_uniform, Fintype.expect_eq_sum_div_card]
theorem uniform_selectCoefficients (J : Finset P) (F : RawCoefficients J C → ℝ) :
(FiniteDistribution.uniform (C × (P → C × C))).expectation (fun extra =>
(FiniteDistribution.uniform (P → C)).expectation (fun single =>
F (selectCoefficients J extra single))) =
(FiniteDistribution.uniform (RawCoefficients J C)).expectation F := by
simp_rw [uniform_expectation_eq_expect]
exact expect_selectCoefficients J F
/-- The fixed-mask identity may be averaged under any independent mask law. -/
theorem mask_average_selectCoefficients (maskLaw : FiniteDistribution (Finset P))
(F : (J : Finset P) → RawCoefficients J C → ℝ) :
maskLaw.expectation (fun J =>
(FiniteDistribution.uniform (C × (P → C × C))).expectation (fun extra =>
(FiniteDistribution.uniform (P → C)).expectation (fun single =>
F J (selectCoefficients J extra single)))) =
maskLaw.expectation (fun J =>
(FiniteDistribution.uniform (RawCoefficients J C)).expectation (F J)) := by
apply FiniteDistribution.expectation_congr
intro J
exact uniform_selectCoefficients J (F J)
end
end UniqueGamesTheorem.Clean.CoefficientSampling
end
end OAI
|