introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
35.5 kB
import Mathlib
import OAI.Computability.DirectedFeedback.Games.ChainRule
namespace OAI
noncomputable section
namespace DFVSGames.Foundations.Hastad
open scoped BigOperators
open Finset
variable {I J : Type*} [Fintype I] [DecidableEq I] [Fintype J] [DecidableEq J]
def parityProjection (π : J → I) (s : Cube J) : Cube I := fun i =>
decide (Odd ((support s).filter fun y => π y = i).card)
theorem walsh_support (s x : Cube I) :
walsh s x = ∏ i ∈ support s, bitSign (x i) := by
unfold walsh support
rw [Finset.prod_filter]
apply Finset.prod_congr rfl
intro i _
cases s i <;> simp [bitSign]
theorem sign_power_parity (b : Bool) (n : Nat) :
bitSign b ^ n = bitSign (decide (Odd n) && b) := by
cases b
· simp [bitSign]
· simp only [Bool.and_true, bitSign, ite_true, decide_eq_true_eq]
rw [neg_one_pow_eq_ite]
by_cases h : Even n
· simp [h, Nat.not_odd_iff_even.mpr h]
· simp [h, Nat.not_even_iff_odd.mp h]
theorem walsh_pullback (π : J → I) (s : Cube J) (f : Cube I) :
walsh s (fun y => f (π y)) = walsh (parityProjection π s) f := by
rw [walsh_support]
rw [← Finset.prod_fiberwise' (support s) π (fun i => bitSign (f i))]
unfold walsh parityProjection
apply Finset.prod_congr rfl
intro i _
simp only [Finset.prod_const]
exact sign_power_parity (f i) _
theorem projectedCoefficient_eq (π : J → I) (A : Cube I → ℝ) (s : Cube J) :
projectedCoefficient π A s = coefficient A (parityProjection π s) := by
simp only [projectedCoefficient, coefficient, walsh_pullback]
omit [DecidableEq J] in
theorem projection_has_preimage (π : J → I) (s : Cube J) (i : I)
(hi : i ∈ support (parityProjection π s)) :
∃ y ∈ support s, π y = i := by
have hodd : Odd ((support s).filter fun y => π y = i).card := by
have hbit := (Finset.mem_filter.mp hi).2
simpa only [parityProjection, decide_eq_true_eq] using hbit
have hp : 0 < ((support s).filter fun y => π y = i).card := by
obtain ⟨n, hn⟩ := hodd
omega
obtain ⟨y, hy⟩ := Finset.card_pos.mp hp
exact ⟨y, (Finset.mem_filter.mp hy).1, (Finset.mem_filter.mp hy).2⟩
theorem scaled_geometric_power_le_one {t : ℝ} (ht : 0 ≤ t) (ht' : t ≤ 1) (n : Nat) :
(n : ℝ) * (1 - t) * t ^ n ≤ 1 := by
have hsum : (n : ℝ) * t ^ n ≤ ∑ j ∈ Finset.range n, t ^ j := by
calc
(n : ℝ) * t ^ n = ∑ _j ∈ Finset.range n, t ^ n := by simp
_ ≤ ∑ j ∈ Finset.range n, t ^ j := by
apply Finset.sum_le_sum
intro j hj
exact pow_le_pow_of_le_one ht ht' (Nat.le_of_lt (Finset.mem_range.mp hj))
have hm := mul_le_mul_of_nonneg_right hsum (sub_nonneg.mpr ht')
rw [geom_sum_mul_neg] at hm
have hp : 0 ≤ t ^ n := pow_nonneg ht _
nlinarith
theorem noise_decay_bound {ε : ℝ} (hε : 0 < ε) (hε' : ε ≤ 1 / 2)
{k : Nat} (hk : 0 < k) :
4 * ε * ((1 - 2 * ε) ^ k) ^ 2 ≤ 1 / (k : ℝ) := by
have h := scaled_geometric_power_le_one (t := 1 - 2 * ε)
(by linarith) (by linarith) (2 * k)
have hkp : (0 : ℝ) < k := Nat.cast_pos.mpr hk
apply (le_div_iff₀ hkp).mpr
have hpow : (1 - 2 * ε) ^ (2 * k) = ((1 - 2 * ε) ^ k) ^ 2 := by
rw [Nat.mul_comm, pow_mul]
rw [hpow] at h
norm_num only [Nat.cast_mul, Nat.cast_ofNat] at h
nlinarith
def zeroMask : Cube I := fun _ => false
omit [DecidableEq I] in
theorem support_eq_empty_iff (s : Cube I) : support s = ∅ ↔ s = zeroMask := by
constructor
· intro h
funext i
have hi : i ∉ support s := by rw [h]; simp
have : s i ≠ true := by simpa [support] using hi
cases hs : s i <;> simp_all [zeroMask]
· intro h
subst s
simp [zeroMask, support]
omit [Fintype I] [DecidableEq J] in
theorem parityProjection_zero (π : J → I) :
parityProjection π (zeroMask : Cube J) = zeroMask := by
funext i
simp [parityProjection, support, zeroMask]
def agreementProbability (π : J → I) (a : Cube I) (b : Cube J) : ℝ :=
(∑ i ∈ support a, (((support b).filter fun y => π y = i).card : ℝ)) /
((support a).card * (support b).card : ℝ)
omit [DecidableEq J] in
theorem agreementProbability_nonneg (π : J → I) (a : Cube I) (b : Cube J) :
0 ≤ agreementProbability π a b := by
unfold agreementProbability
apply div_nonneg
· exact Finset.sum_nonneg (fun _ _ => Nat.cast_nonneg _)
· exact mul_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _)
omit [DecidableEq J] in
theorem agreementProbability_projection (π : J → I) (b : Cube J)
(ha : (support (parityProjection π b)).Nonempty) :
1 / ((support b).card : ℝ) ≤ agreementProbability π (parityProjection π b) b := by
have hca : (0 : ℝ) < (support (parityProjection π b)).card :=
Nat.cast_pos.mpr (Finset.card_pos.mpr ha)
have hb : (support b).Nonempty := by
obtain ⟨i, hi⟩ := ha
obtain ⟨y, hy, _⟩ := projection_has_preimage π b i hi
exact ⟨y, hy⟩
have hcb : (0 : ℝ) < (support b).card := Nat.cast_pos.mpr (Finset.card_pos.mpr hb)
have hsum : ((support (parityProjection π b)).card : ℝ) ≤
∑ i ∈ support (parityProjection π b),
(((support b).filter fun y => π y = i).card : ℝ) := by
calc
_ = ∑ _i ∈ support (parityProjection π b), (1 : ℝ) := by simp
_ ≤ _ := by
apply Finset.sum_le_sum
intro i hi
obtain ⟨y, hy, hπ⟩ := projection_has_preimage π b i hi
have hp : 0 < ((support b).filter fun y => π y = i).card :=
Finset.card_pos.mpr ⟨y, Finset.mem_filter.mpr ⟨hy, hπ⟩⟩
exact_mod_cast hp
unfold agreementProbability
apply (div_le_div_iff₀ hcb (mul_pos hca hcb)).mpr
nlinarith
def decoderSuccess (π : J → I) (A : Cube I → Bool) (B : Cube J → Bool) : ℝ :=
∑ b, coefficient (fun g => bitSign (B g)) b ^ 2 *
(∑ a, coefficient (fun f => bitSign (A f)) a ^ 2 * agreementProbability π a b)
def decodingEnergy (π : J → I) (A : Cube I → ℝ) (B : Cube J → ℝ) : ℝ :=
∑ b, projectedCoefficient π A b ^ 2 * coefficient B b ^ 2 / (support b).card
theorem decodingEnergy_le_success (π : J → I) (A : Cube I → Bool) (B : Cube J → Bool)
(hzero : coefficient (fun f => bitSign (A f)) zeroMask = 0) :
decodingEnergy π (fun f => bitSign (A f)) (fun g => bitSign (B g)) ≤
decoderSuccess π A B := by
unfold decodingEnergy decoderSuccess
apply Finset.sum_le_sum
intro b _
rw [projectedCoefficient_eq]
have hsum :
coefficient (fun f => bitSign (A f)) (parityProjection π b) ^ 2 *
agreementProbability π (parityProjection π b) b ≤
∑ a, coefficient (fun f => bitSign (A f)) a ^ 2 * agreementProbability π a b := by
apply Finset.single_le_sum (s := Finset.univ)
(f := fun a => coefficient (fun f => bitSign (A f)) a ^ 2 * agreementProbability π a b)
· intro a _
exact mul_nonneg (sq_nonneg _) (agreementProbability_nonneg π a b)
· exact Finset.mem_univ _
have hm := mul_le_mul_of_nonneg_left hsum
(sq_nonneg (coefficient (fun g => bitSign (B g)) b))
by_cases ha : (support (parityProjection π b)).Nonempty
· have hagree := agreementProbability_projection π b ha
have ht := mul_le_mul_of_nonneg_left hagree
(mul_nonneg (sq_nonneg (coefficient (fun f => bitSign (A f))
(parityProjection π b))) (sq_nonneg (coefficient (fun g => bitSign (B g)) b)))
have heq : coefficient (fun f => bitSign (A f)) (parityProjection π b) ^ 2 *
coefficient (fun g => bitSign (B g)) b ^ 2 / (support b).card =
(coefficient (fun f => bitSign (A f)) (parityProjection π b) ^ 2 *
coefficient (fun g => bitSign (B g)) b ^ 2) * (1 / (support b).card) := by ring
rw [heq]
exact ht.trans (by convert hm using 1 ; ring)
· have hempty : support (parityProjection π b) = ∅ := Finset.not_nonempty_iff_eq_empty.mp ha
have hz := (support_eq_empty_iff _).mp hempty
simpa [hz, hzero] using hm
theorem bias_sq_le_weighted_energy (ε : ℝ) (π : J → I)
(A : Cube I → ℝ) (B : Cube J → Bool) :
testBias ε π A (fun g => bitSign (B g)) ^ 2 ≤
∑ b, (projectedCoefficient π A b * coefficient (fun g => bitSign (B g)) b *
(1 - 2 * ε) ^ (support b).card) ^ 2 := by
rw [testBias_fourier]
have h := Finset.sum_mul_sq_le_sq_mul_sq Finset.univ
(fun b => projectedCoefficient π A b * coefficient (fun g => bitSign (B g)) b *
(1 - 2 * ε) ^ (support b).card)
(fun b => coefficient (fun g => bitSign (B g)) b)
rw [sign_parseval, mul_one] at h
convert h using 1
congr 1
apply Finset.sum_congr rfl
intro b _
ring
theorem decoder_four_epsilon_bias_sq (ε : ℝ) (π : J → I)
(A : Cube I → Bool) (B : Cube J → Bool)
(hε : 0 < ε) (hε' : ε ≤ 1 / 2)
(hzero : coefficient (fun f => bitSign (A f)) zeroMask = 0) :
4 * ε * testBias ε π (fun f => bitSign (A f)) (fun g => bitSign (B g)) ^ 2 ≤
decoderSuccess π A B := by
apply le_trans _ (decodingEnergy_le_success π A B hzero)
have hcs := mul_le_mul_of_nonneg_left
(bias_sq_le_weighted_energy ε π (fun f => bitSign (A f)) B)
(by linarith : 0 ≤ 4 * ε)
apply hcs.trans
rw [Finset.mul_sum]
unfold decodingEnergy
apply Finset.sum_le_sum
intro b _
by_cases hk : 0 < (support b).card
· have hd := noise_decay_bound hε hε' hk
have hm := mul_le_mul_of_nonneg_left hd
(mul_nonneg (sq_nonneg (projectedCoefficient π (fun f => bitSign (A f)) b))
(sq_nonneg (coefficient (fun g => bitSign (B g)) b)))
convert hm using 1 <;> ring
· have hb : support b = ∅ := Finset.card_eq_zero.mp (by omega)
have hbzero := (support_eq_empty_iff b).mp hb
subst b
simp [projectedCoefficient_eq, parityProjection_zero, hzero, support, zeroMask]
theorem folded_decoder_bound (ε : ℝ) (π : J → I)
(i₀ : I) (table : HalfCube i₀ → Bool) (B : Cube J → Bool)
(hε : 0 < ε) (hε' : ε ≤ 1 / 2) :
4 * ε * testBias ε π (fun f => bitSign (foldedAnswer i₀ table f))
(fun g => bitSign (B g)) ^ 2 ≤ decoderSuccess π (foldedAnswer i₀ table) B := by
exact decoder_four_epsilon_bias_sq ε π (foldedAnswer i₀ table) B hε hε'
(foldedAnswer_zero_coefficient i₀ table)
def validAgreementProbability (valid : J → Bool) (π : J → I)
(a : Cube I) (b : Cube J) : ℝ :=
(∑ i ∈ support a,
(((support b).filter fun y => π y = i ∧ valid y = true).card : ℝ)) /
((support a).card * (support b).card : ℝ)
omit [DecidableEq J] in
theorem validAgreementProbability_eq (valid : J → Bool) (π : J → I)
(a : Cube I) (b : Cube J) (hb : ∀ y ∈ support b, valid y = true) :
validAgreementProbability valid π a b = agreementProbability π a b := by
unfold validAgreementProbability agreementProbability
congr 1
apply Finset.sum_congr rfl
intro i _
congr 1
apply congrArg Finset.card
apply Finset.filter_congr
intro y hy
simp [hb y hy]
def validDecoderSuccess (valid : J → Bool) (π : J → I)
(A : Cube I → Bool) (B : Cube J → Bool) : ℝ :=
∑ b, coefficient (fun g => bitSign (B g)) b ^ 2 *
(∑ a, coefficient (fun f => bitSign (A f)) a ^ 2 *
validAgreementProbability valid π a b)
theorem conditioned_validDecoderSuccess (valid : J → Bool) (π : J → I)
(A : Cube I → Bool) (j₀ : {j : J // valid j = true})
(table : HalfCube j₀ → Bool) :
validDecoderSuccess valid π A (conditionedFoldedAnswer valid j₀ table) =
decoderSuccess π A (conditionedFoldedAnswer valid j₀ table) := by
unfold validDecoderSuccess decoderSuccess
apply Finset.sum_congr rfl
intro b _
by_cases hc : coefficient (fun g => bitSign (conditionedFoldedAnswer valid j₀ table g)) b = 0
· simp [hc]
· have hb : ∀ y ∈ support b, valid y = true := by
apply conditioned_coefficient_support valid (fun g => bitSign (foldedAnswer j₀ table g)) b
exact hc
congr 1
apply Finset.sum_congr rfl
intro a _
rw [validAgreementProbability_eq valid π a b hb]
theorem conditioned_folded_decoder_bound (ε : ℝ) (π : J → I) (valid : J → Bool)
(i₀ : I) (tableA : HalfCube i₀ → Bool)
(j₀ : {j : J // valid j = true}) (tableB : HalfCube j₀ → Bool)
(hε : 0 < ε) (hε' : ε ≤ 1 / 2) :
4 * ε * testBias ε π (fun f => bitSign (foldedAnswer i₀ tableA f))
(fun g => bitSign (conditionedFoldedAnswer valid j₀ tableB g)) ^ 2 ≤
validDecoderSuccess valid π (foldedAnswer i₀ tableA)
(conditionedFoldedAnswer valid j₀ tableB) := by
rw [conditioned_validDecoderSuccess]
exact folded_decoder_bound ε π i₀ tableA
(conditionedFoldedAnswer valid j₀ tableB) hε hε'
end DFVSGames.Foundations.Hastad
end
noncomputable section
namespace DFVSGames.Foundations.Hastad
open scoped BigOperators
open Finset
open DFVSGames.Foundations.Games
variable {I J : Type*} [Fintype I] [DecidableEq I]
[Fintype J] [DecidableEq J]
def supportResponse (fallback : I) (s : Cube I) : FiniteDistribution I where
weight i := if (support s).Nonempty then
if i ∈ support s then 1 / ((support s).card : ℝ) else 0
else if i = fallback then 1 else 0
nonnegative i := by
split_ifs <;> positivity
normalized := by
by_cases hs : (support s).Nonempty
· have hc : ((support s).card : ℝ) ≠ 0 :=
ne_of_gt (Nat.cast_pos.mpr (Finset.card_pos.mpr hs))
simp [hs, hc]
· simp [hs]
theorem supportResponse_expectation (fallback : I) (s : Cube I) (H : I → ℝ)
(hs : (support s).Nonempty) :
(supportResponse fallback s).expectation H =
(∑ i ∈ support s, H i) / ((support s).card : ℝ) := by
simp only [FiniteDistribution.expectation, supportResponse, hs, ite_true]
simp_rw [ite_mul, zero_mul]
rw [Finset.sum_ite_mem]
simp only [div_eq_mul_inv, one_mul, Finset.univ_inter]
rw [← Finset.mul_sum]
ring
def fourierResponse (fallback : I) (F : Cube I → Bool) : FiniteDistribution I where
weight i := ∑ s, coefficient (fun f => bitSign (F f)) s ^ 2 *
(supportResponse fallback s).weight i
nonnegative i := Finset.sum_nonneg fun s _ =>
mul_nonneg (sq_nonneg _) ((supportResponse fallback s).nonnegative i)
normalized := by
rw [Finset.sum_comm]
simp_rw [← Finset.mul_sum, FiniteDistribution.normalized, mul_one]
exact sign_parseval F
theorem fourierResponse_expectation (fallback : I) (F : Cube I → Bool)
(H : I → ℝ) :
(fourierResponse fallback F).expectation H =
∑ s, coefficient (fun f => bitSign (F f)) s ^ 2 *
(supportResponse fallback s).expectation H := by
unfold FiniteDistribution.expectation fourierResponse
simp_rw [Finset.sum_mul]
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro s _
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro i _
ring
theorem response_expectation_nonnegative {K : Type*} [Fintype K]
(law : FiniteDistribution K) (H : K → ℝ) (hH : ∀ k, 0 ≤ H k) :
0 ≤ law.expectation H :=
Finset.sum_nonneg fun k _ => mul_nonneg (law.nonnegative k) (hH k)
def responseAgreement (π : J → I) (fallbackI : I) (fallbackJ : J)
(A : Cube I → Bool) (B : Cube J → Bool) : ℝ :=
(fourierResponse fallbackI A).expectation fun i =>
(fourierResponse fallbackJ B).expectation fun j => if π j = i then 1 else 0
def validResponseAgreement (valid : J → Bool) (π : J → I)
(fallbackI : I) (fallbackJ : J)
(A : Cube I → Bool) (B : Cube J → Bool) : ℝ :=
(fourierResponse fallbackI A).expectation fun i =>
(fourierResponse fallbackJ B).expectation fun j =>
if π j = i ∧ valid j = true then 1 else 0
theorem supportResponse_validAgreement (valid : J → Bool) (π : J → I)
(fallbackI : I) (fallbackJ : J) (a : Cube I) (b : Cube J)
(ha : (support a).Nonempty) (hb : (support b).Nonempty) :
(supportResponse fallbackI a).expectation (fun i =>
(supportResponse fallbackJ b).expectation (fun j =>
if π j = i ∧ valid j = true then 1 else 0)) =
validAgreementProbability valid π a b := by
rw [supportResponse_expectation fallbackI a _ ha]
simp_rw [supportResponse_expectation fallbackJ b _ hb, Finset.sum_boole]
unfold validAgreementProbability
simp only [div_eq_mul_inv]
rw [← Finset.sum_mul]
ring
theorem validAgreement_le_supportResponses (valid : J → Bool) (π : J → I)
(fallbackI : I) (fallbackJ : J) (a : Cube I) (b : Cube J) :
validAgreementProbability valid π a b ≤
(supportResponse fallbackI a).expectation (fun i =>
(supportResponse fallbackJ b).expectation (fun j =>
if π j = i ∧ valid j = true then 1 else 0)) := by
by_cases ha : (support a).Nonempty
· by_cases hb : (support b).Nonempty
· exact le_of_eq (supportResponse_validAgreement valid π fallbackI fallbackJ a b ha hb).symm
· have he : support b = ∅ := Finset.not_nonempty_iff_eq_empty.mp hb
simp only [validAgreementProbability, he, Finset.card_empty, Nat.cast_zero,
mul_zero, div_zero]
apply response_expectation_nonnegative
intro i
apply response_expectation_nonnegative
intro j
split_ifs <;> norm_num
· have he : support a = ∅ := Finset.not_nonempty_iff_eq_empty.mp ha
simp only [validAgreementProbability, he, Finset.sum_empty, Finset.card_empty,
Nat.cast_zero, zero_mul, div_zero]
apply response_expectation_nonnegative
intro i
apply response_expectation_nonnegative
intro j
split_ifs <;> norm_num
theorem validDecoderSuccess_le_response (valid : J → Bool) (π : J → I)
(fallbackI : I) (fallbackJ : J) (A : Cube I → Bool) (B : Cube J → Bool) :
validDecoderSuccess valid π A B ≤
validResponseAgreement valid π fallbackI fallbackJ A B := by
unfold validDecoderSuccess validResponseAgreement
rw [FiniteDistribution.expectation_comm]
rw [fourierResponse_expectation fallbackJ B]
apply Finset.sum_le_sum
intro b _
apply mul_le_mul_of_nonneg_left _ (sq_nonneg _)
rw [FiniteDistribution.expectation_comm]
rw [fourierResponse_expectation fallbackI A]
apply Finset.sum_le_sum
intro a _
apply mul_le_mul_of_nonneg_left _ (sq_nonneg _)
exact validAgreement_le_supportResponses valid π fallbackI fallbackJ a b
theorem conditioned_folded_response_bound (ε : ℝ) (π : J → I) (valid : J → Bool)
(i₀ : I) (tableA : HalfCube i₀ → Bool)
(j₀ : {j : J // valid j = true}) (tableB : HalfCube j₀ → Bool)
(hε : 0 < ε) (hε' : ε ≤ 1 / 2) :
4 * ε * testBias ε π (fun f => bitSign (foldedAnswer i₀ tableA f))
(fun g => bitSign (conditionedFoldedAnswer valid j₀ tableB g)) ^ 2 ≤
validResponseAgreement valid π i₀ j₀.val (foldedAnswer i₀ tableA)
(conditionedFoldedAnswer valid j₀ tableB) :=
(conditioned_folded_decoder_bound ε π valid i₀ tableA j₀ tableB hε hε').trans
(validDecoderSuccess_le_response valid π i₀ j₀.val _ _)
end DFVSGames.Foundations.Hastad
end
noncomputable section
namespace DFVSGames.Foundations.Hastad
open scoped BigOperators
open Finset
open DFVSGames.Foundations.Games
theorem distribution_sq_expectation_le {Ω : Type*} [Fintype Ω]
(law : FiniteDistribution Ω) (F : Ω → ℝ) :
law.expectation F ^ 2 ≤ law.expectation (fun x => F x ^ 2) := by
let m := law.expectation F
have h := response_expectation_nonnegative law (fun x => (F x - m) ^ 2)
(fun x => sq_nonneg _)
have he : law.expectation (fun x => (F x - m) ^ 2) =
law.expectation (fun x => F x ^ 2) - m ^ 2 := by
unfold FiniteDistribution.expectation
calc
_ = ∑ x, ((law.weight x * F x ^ 2 - 2 * m * (law.weight x * F x)) +
law.weight x * m ^ 2) := by
apply Finset.sum_congr rfl
intro x _
ring
_ = _ := by
rw [Finset.sum_add_distrib, Finset.sum_sub_distrib,
← Finset.mul_sum, ← Finset.sum_mul, law.normalized]
change (law.expectation (fun x => F x ^ 2) - 2 * m * m) + 1 * m ^ 2 = _
simp only [FiniteDistribution.expectation]
ring
rw [he] at h
dsimp [m] at h
linarith
variable {Q₁ Q₂ I J : Type*}
[Fintype Q₁] [DecidableEq Q₁] [Fintype Q₂] [DecidableEq Q₂]
[Fintype I] [DecidableEq I] [Nonempty I]
[Fintype J] [DecidableEq J] [Nonempty J]
def projectionGame (questions : FiniteDistribution (Q₁ × Q₂))
(π : Q₁ → Q₂ → J → I) (valid : Q₂ → J → Bool) : Game Q₁ Q₂ I J where
questions := questions
accepts q₁ q₂ i j := decide (π q₁ q₂ j = i ∧ valid q₂ j = true)
def questionBias (ε : ℝ) (π : Q₁ → Q₂ → J → I)
(A : Q₁ → Cube I → Bool) (B : Q₂ → Cube J → Bool) (q : Q₁ × Q₂) : ℝ :=
testBias ε (π q.1 q.2) (fun f => bitSign (A q.1 f)) (fun g => bitSign (B q.2 g))
def questionAcceptance (ε : ℝ) (π : Q₁ → Q₂ → J → I)
(A : Q₁ → Cube I → Bool) (B : Q₂ → Cube J → Bool) (q : Q₁ × Q₂) : ℝ :=
testAcceptance ε (π q.1 q.2) (A q.1) (B q.2)
omit [DecidableEq Q₁] [DecidableEq Q₂] [Nonempty I] [Nonempty J] in
theorem questionAcceptance_eq (questions : FiniteDistribution (Q₁ × Q₂))
(ε : ℝ) (π : Q₁ → Q₂ → J → I)
(A : Q₁ → Cube I → Bool) (B : Q₂ → Cube J → Bool) :
questions.expectation (questionAcceptance ε π A B) =
(1 + questions.expectation (questionBias ε π A B)) / 2 := by
unfold questionAcceptance
simp_rw [testAcceptance_eq]
unfold questionBias FiniteDistribution.expectation
simp only [div_eq_mul_inv, mul_add, mul_one, ← mul_assoc,
Finset.sum_add_distrib, ← Finset.sum_mul, questions.normalized]
inductive ConditionedOracle (valid : J → Bool) where
| empty (noLegal : ∀ j, valid j = false)
| stored (j₀ : {j : J // valid j = true}) (table : HalfCube j₀ → Bool)
def ConditionedOracle.answer {valid : J → Bool} : ConditionedOracle valid → Cube J → Bool
| .empty _ => fun _ => false
| .stored j₀ table => conditionedFoldedAnswer valid j₀ table
def ConditionedOracle.fallback {valid : J → Bool} (default : J) :
ConditionedOracle valid → J
| .empty _ => default
| .stored j₀ _ => j₀.val
omit [Nonempty I] [Nonempty J] in
theorem testBias_constant_right (ε : ℝ) (π : J → I) (A : Cube I → ℝ) :
testBias ε π A (fun _ => 1) = 𝔼 f, A f := by
unfold testBias
simp only [mul_one, Fintype.expect_const]
simp_rw [← Finset.sum_mul, noiseWeight_sum, one_mul]
omit [Nonempty I] [Nonempty J] in
theorem empty_conditioned_bias (ε : ℝ) (π : J → I)
(i₀ : I) (tableA : HalfCube i₀ → Bool) :
testBias ε π (fun f => bitSign (foldedAnswer i₀ tableA f))
(fun _ => bitSign false) = 0 := by
simp only [bitSign, Bool.false_eq_true, ite_false]
rw [testBias_constant_right]
have hz := foldedAnswer_zero_coefficient i₀ tableA
simpa [coefficient, walsh, bitSign] using hz
omit [Nonempty I] [Nonempty J] in
theorem conditionedOracle_response_bound (ε : ℝ) (π : J → I) (valid : J → Bool)
(i₀ : I) (tableA : HalfCube i₀ → Bool) (default : J)
(right : ConditionedOracle valid) (hε : 0 < ε) (hε' : ε ≤ 1 / 2) :
4 * ε * testBias ε π (fun f => bitSign (foldedAnswer i₀ tableA f))
(fun g => bitSign (right.answer g)) ^ 2 ≤
validResponseAgreement valid π i₀ (right.fallback default)
(foldedAnswer i₀ tableA) right.answer := by
cases right with
| empty noLegal =>
simp only [ConditionedOracle.answer, ConditionedOracle.fallback,
empty_conditioned_bias, pow_two, mul_zero]
unfold validResponseAgreement
apply response_expectation_nonnegative
intro i
apply response_expectation_nonnegative
intro j
split_ifs <;> norm_num
| stored j₀ table =>
exact conditioned_folded_response_bound ε π valid i₀ tableA j₀ table hε hε'
theorem folded_game_decoder_bound
(questions : FiniteDistribution (Q₁ × Q₂))
(ε : ℝ) (π : Q₁ → Q₂ → J → I) (valid : Q₂ → J → Bool)
(i₀ : Q₁ → I) (tableA : ∀ q, HalfCube (i₀ q) → Bool)
(j₀ : ∀ q, {j : J // valid q j = true})
(tableB : ∀ q, HalfCube (j₀ q) → Bool)
(hε : 0 < ε) (hε' : ε ≤ 1 / 2) :
4 * ε * questions.expectation (questionBias ε π
(fun q => foldedAnswer (i₀ q) (tableA q))
(fun q => conditionedFoldedAnswer (valid q) (j₀ q) (tableB q))) ^ 2 ≤
(projectionGame questions π valid).value := by
let A := fun q => foldedAnswer (i₀ q) (tableA q)
let B := fun q => conditionedFoldedAnswer (valid q) (j₀ q) (tableB q)
let bias := questionBias ε π A B
calc
_ ≤ 4 * ε * questions.expectation (fun q => bias q ^ 2) :=
mul_le_mul_of_nonneg_left (distribution_sq_expectation_le questions bias) (by linarith)
_ = questions.expectation (fun q => 4 * ε * bias q ^ 2) := by
unfold FiniteDistribution.expectation
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro q _
ring
_ ≤ questions.expectation (fun q =>
validResponseAgreement (valid q.2) (π q.1 q.2) (i₀ q.1) (j₀ q.2).val
(A q.1) (B q.2)) := by
unfold FiniteDistribution.expectation
apply Finset.sum_le_sum
intro q _
apply mul_le_mul_of_nonneg_left _ (questions.nonnegative q)
exact conditioned_folded_response_bound ε (π q.1 q.2) (valid q.2)
(i₀ q.1) (tableA q.1) (j₀ q.2) (tableB q.2) hε hε'
_ = (projectionGame questions π valid).stochasticSuccess
(fun q => fourierResponse (i₀ q) (A q))
(fun q => fourierResponse (j₀ q).val (B q)) := by
simp [Game.stochasticSuccess, projectionGame, validResponseAgreement]
_ ≤ _ := Game.stochasticSuccess_le_value _ _ _
theorem conditionedOracle_game_decoder_bound
(questions : FiniteDistribution (Q₁ × Q₂))
(ε : ℝ) (π : Q₁ → Q₂ → J → I) (valid : Q₂ → J → Bool)
(i₀ : Q₁ → I) (tableA : ∀ q, HalfCube (i₀ q) → Bool)
(default : J) (right : ∀ q, ConditionedOracle (valid q))
(hε : 0 < ε) (hε' : ε ≤ 1 / 2) :
4 * ε * questions.expectation (questionBias ε π
(fun q => foldedAnswer (i₀ q) (tableA q)) (fun q => (right q).answer)) ^ 2 ≤
(projectionGame questions π valid).value := by
let A := fun q => foldedAnswer (i₀ q) (tableA q)
let B := fun q => (right q).answer
let bias := questionBias ε π A B
calc
_ ≤ 4 * ε * questions.expectation (fun q => bias q ^ 2) :=
mul_le_mul_of_nonneg_left (distribution_sq_expectation_le questions bias) (by linarith)
_ = questions.expectation (fun q => 4 * ε * bias q ^ 2) := by
unfold FiniteDistribution.expectation
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro q _
ring
_ ≤ questions.expectation (fun q =>
validResponseAgreement (valid q.2) (π q.1 q.2) (i₀ q.1)
((right q.2).fallback default) (A q.1) (B q.2)) := by
unfold FiniteDistribution.expectation
apply Finset.sum_le_sum
intro q _
apply mul_le_mul_of_nonneg_left _ (questions.nonnegative q)
exact conditionedOracle_response_bound ε (π q.1 q.2) (valid q.2)
(i₀ q.1) (tableA q.1) default (right q.2) hε hε'
_ = (projectionGame questions π valid).stochasticSuccess
(fun q => fourierResponse (i₀ q) (A q))
(fun q => fourierResponse ((right q).fallback default) (B q)) := by
simp [Game.stochasticSuccess, projectionGame, validResponseAgreement]
_ ≤ _ := Game.stochasticSuccess_le_value _ _ _
theorem conditionedOracle_acceptance_bound
(questions : FiniteDistribution (Q₁ × Q₂))
(ε δ : ℝ) (π : Q₁ → Q₂ → J → I) (valid : Q₂ → J → Bool)
(i₀ : Q₁ → I) (tableA : ∀ q, HalfCube (i₀ q) → Bool)
(default : J) (right : ∀ q, ConditionedOracle (valid q))
(hε : 0 < ε) (hε' : ε ≤ 1 / 2) (hδ : 0 ≤ δ)
(hvalue : (projectionGame questions π valid).value ≤ 4 * ε * δ ^ 2) :
questions.expectation (questionAcceptance ε π
(fun q => foldedAnswer (i₀ q) (tableA q)) (fun q => (right q).answer)) ≤
(1 + δ) / 2 := by
have hd := conditionedOracle_game_decoder_bound questions ε π valid i₀ tableA
default right hε hε'
have hpos : 0 < 4 * ε := by positivity
have hs := le_of_mul_le_mul_left (hd.trans hvalue) hpos
rw [questionAcceptance_eq]
nlinarith
end DFVSGames.Foundations.Hastad
end
noncomputable section
namespace DFVSGames.Foundations.Games
open scoped BigOperators
namespace FiniteDistribution
def reindexEquiv {ι κ Ω : Type*} (e : κ ≃ ι) : (ι → Ω) ≃ (κ → Ω) where
toFun f := f ∘ e
invFun g := g ∘ e.symm
left_inv f := by funext i; simp
right_inv g := by funext i; simp
theorem pushforward_equiv {Ω Γ : Type*} [Fintype Ω] [Fintype Γ]
(μ : FiniteDistribution Ω) (e : Ω ≃ Γ) :
μ.pushforward e = μ.transport e := by
classical
apply eq_of_weight_eq
intro y
simp only [pushforward, transport]
have he : ∀ x : Ω, (e x = y) = (x = e.symm y) := by
intro x
apply propext
constructor
· intro h
simpa using congrArg e.symm h
· intro h
rw [h, e.apply_symm_apply]
simp_rw [he]
simp
theorem table_const_reindex {ι κ Ω : Type*}
[Fintype ι] [Fintype κ] [Fintype Ω] [DecidableEq ι] [DecidableEq κ]
(μ : FiniteDistribution Ω) (e : κ ≃ ι) :
(table (fun _ : ι => μ)).pushforward (fun f => f ∘ e) =
table (fun _ : κ => μ) := by
classical
change (table (fun _ : ι => μ)).pushforward (reindexEquiv e) = _
rw [pushforward_equiv]
apply eq_of_weight_eq
intro g
change (∏ i : ι, μ.weight (g (e.symm i))) = ∏ k : κ, μ.weight (g k)
exact e.symm.prod_comp (fun k => μ.weight (g k))
theorem iid_reindex {Ω : Type*} [Fintype Ω]
(μ : FiniteDistribution Ω) {n m : Nat} (e : Fin m ≃ Fin n) :
(μ.iid n).pushforward (fun f => f ∘ e) = μ.iid m := by
classical
change (μ.iid n).pushforward (reindexEquiv e) = _
rw [pushforward_equiv]
apply eq_of_weight_eq
intro g
change (∏ i : Fin n, μ.weight (g (e.symm i))) = ∏ k : Fin m, μ.weight (g k)
exact e.symm.prod_comp (fun k => μ.weight (g k))
theorem probability_reindex_of_weight {Ω Γ : Type*} [Fintype Ω] [Fintype Γ]
(μ : FiniteDistribution Ω) (ν : FiniteDistribution Γ) (e : Ω ≃ Γ)
(hweight : ∀ x, ν.weight (e x) = μ.weight x) (event : Γ → Bool) :
ν.probability event = μ.probability (fun x => event (e x)) := by
classical
change (∑ y, if event y then ν.weight y else 0) =
∑ x, if event (e x) then μ.weight x else 0
rw [← e.sum_comp (fun y => if event y then ν.weight y else 0)]
apply Finset.sum_congr rfl
intro x _
rw [hweight]
end FiniteDistribution
namespace Game
variable {Q₁ Q₂ A₁ A₂ : Type*}
variable [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂]
def questionReindexEquiv {n m : Nat} (e : Fin m ≃ Fin n) :
((Fin n → Q₁) × (Fin n → Q₂)) ≃ ((Fin m → Q₁) × (Fin m → Q₂)) :=
Equiv.prodCongr (FiniteDistribution.reindexEquiv e)
(FiniteDistribution.reindexEquiv e)
def reindexStrategy {n m : Nat} (e : Fin m ≃ Fin n)
(s : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) :
Strategy (Fin m → Q₁) (Fin m → Q₂) (Fin m → A₁) (Fin m → A₂) :=
(fun x i => s.1 (x ∘ e.symm) (e i),
fun y i => s.2 (y ∘ e.symm) (e i))
theorem repetition_question_weight_reindex (G : Game Q₁ Q₂ A₁ A₂)
{n m : Nat} (e : Fin m ≃ Fin n)
(q : (Fin n → Q₁) × (Fin n → Q₂)) :
(G.repetition m).questions.weight (questionReindexEquiv e q) =
(G.repetition n).questions.weight q := by
classical
rw [repetition_question_weight, repetition_question_weight]
change (∏ i : Fin m, G.questions.weight (q.1 (e i), q.2 (e i))) =
∏ j : Fin n, G.questions.weight (q.1 j, q.2 j)
exact e.prod_comp (fun j => G.questions.weight (q.1 j, q.2 j))
theorem repetition_questions_reindex (G : Game Q₁ Q₂ A₁ A₂)
{n m : Nat} (e : Fin m ≃ Fin n) :
(G.repetition n).questions.pushforward (questionReindexEquiv e) =
(G.repetition m).questions := by
classical
rw [FiniteDistribution.pushforward_equiv]
apply FiniteDistribution.eq_of_weight_eq
intro q
change (G.repetition n).questions.weight ((questionReindexEquiv e).symm q) =
(G.repetition m).questions.weight q
have h := repetition_question_weight_reindex G e ((questionReindexEquiv e).symm q)
simpa only [Equiv.apply_symm_apply] using h.symm
theorem coordinateWin_reindex (G : Game Q₁ Q₂ A₁ A₂)
{n m : Nat} (e : Fin m ≃ Fin n)
(s : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂))
(i : Fin m) (q : (Fin n → Q₁) × (Fin n → Q₂)) :
G.coordinateWin (reindexStrategy e s) i (questionReindexEquiv e q) =
G.coordinateWin s (e i) q := by
have h₁ : (fun j : Fin n => q.1 (e (e.symm j))) = q.1 := by
funext j
rw [e.apply_symm_apply]
have h₂ : (fun j : Fin n => q.2 (e (e.symm j))) = q.2 := by
funext j
rw [e.apply_symm_apply]
change G.accepts (q.1 (e i)) (q.2 (e i))
(s.1 (fun j => q.1 (e (e.symm j))) (e i))
(s.2 (fun j => q.2 (e (e.symm j))) (e i)) =
G.accepts (q.1 (e i)) (q.2 (e i)) (s.1 q.1 (e i)) (s.2 q.2 (e i))
rw [h₁, h₂]
theorem selectedWins_reindex (G : Game Q₁ Q₂ A₁ A₂)
{n m : Nat} (e : Fin m ≃ Fin n)
(s : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂))
(S : Finset (Fin m)) (q : (Fin n → Q₁) × (Fin n → Q₂)) :
G.selectedWins (reindexStrategy e s) S (questionReindexEquiv e q) =
G.selectedWins s (S.map e.toEmbedding) q := by
classical
unfold selectedWins
congr 1
apply propext
constructor
· intro h j hj
obtain ⟨i, hi, rfl⟩ := Finset.mem_map.mp hj
have hw := h i hi
rw [coordinateWin_reindex] at hw
exact hw
· intro h i hi
rw [coordinateWin_reindex]
exact h (e i) (Finset.mem_map.mpr ⟨i, hi, rfl⟩)
theorem selectedSuccess_reindex (G : Game Q₁ Q₂ A₁ A₂)
{n m : Nat} (e : Fin m ≃ Fin n)
(s : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂))
(S : Finset (Fin m)) :
G.selectedSuccess (reindexStrategy e s) S =
G.selectedSuccess s (S.map e.toEmbedding) := by
classical
unfold selectedSuccess
rw [FiniteDistribution.probability_reindex_of_weight
(G.repetition n).questions (G.repetition m).questions (questionReindexEquiv e)
(repetition_question_weight_reindex G e)]
congr 1
funext q
exact selectedWins_reindex G e s S q
theorem repetition_success_reindex (G : Game Q₁ Q₂ A₁ A₂)
{n m : Nat} (e : Fin m ≃ Fin n)
(s : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) :
(G.repetition m).success (reindexStrategy e s) =
(G.repetition n).success s := by
classical
have huniv : (Finset.univ : Finset (Fin m)).map e.toEmbedding = Finset.univ := by
ext j
constructor
· intro _
exact Finset.mem_univ j
· intro _
exact Finset.mem_map.mpr ⟨e.symm j, Finset.mem_univ _, e.apply_symm_apply j⟩
have h := selectedSuccess_reindex G e s Finset.univ
rw [huniv, selectedSuccess_univ, selectedSuccess_univ] at h
exact h
end Game
end DFVSGames.Foundations.Games
end
end OAI