| import Mathlib |
| import OAI.Computability.MaxCut.PCP.Folding |
|
|
| namespace OAI |
|
|
| /-! The parity projection and finite Fourier decoder used in Håstad's |
| three-query argument. Probabilities are explicit finite sums. -/ |
|
|
| noncomputable section |
|
|
| namespace MaxCutGames.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⟩ |
|
|
| /-- A purely algebraic decay estimate used instead of exponential bounds. -/ |
| 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] |
|
|
| /-- Choose uniform coordinates in the two masks and check the projection. |
| An empty support contributes zero. -/ |
| 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 |
|
|
| /-- Select independent Walsh masks by squared coefficients and uniform points |
| in each support. The two selections use only the respective private tables. -/ |
| 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] |
|
|
| /-- A concrete folded half-table discharges the zero-coefficient condition. -/ |
| 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) |
|
|
| /-- Clause validity in the decoded game follows from the concrete conditioned |
| table; no Fourier-support hypothesis is passed to this theorem. -/ |
| 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 MaxCutGames.Foundations.Hastad |
| end |
|
|
| end OAI |
|
|
