| import Mathlib |
| import OAI.Computability.MaxCut.Estimates.Clip |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace OptimalMaxCut.LongCode |
| open scoped BigOperators |
| open Finset MaxCutGames.Foundations.Hastad OptimalMaxCut.Analytic |
|
|
| noncomputable def cubePerm {n : ℕ} (π : Equiv.Perm (Fin n)) : Equiv.Perm (Cube (Fin n)) where |
| toFun x := fun i => x (π i) |
| invFun x := fun i => x (π.symm i) |
| left_inv x := by funext i; simp |
| right_inv x := by funext i; simp |
|
|
| @[simp] theorem cubePerm_apply {n : ℕ} (π : Equiv.Perm (Fin n)) (x : Cube (Fin n)) (i : Fin n) : |
| cubePerm π x i = x (π i) := rfl |
|
|
| theorem degree_cubePerm {n : ℕ} (π : Equiv.Perm (Fin n)) (s : Cube (Fin n)) : |
| degree (cubePerm π s) = degree s := by |
| unfold degree |
| simp only [card_eq_sum_ones, sum_filter] |
| exact Fintype.sum_equiv π _ _ (fun _ => rfl) |
|
|
| theorem walsh_cubePerm {n : ℕ} (π : Equiv.Perm (Fin n)) (s x : Cube (Fin n)) : |
| walsh (cubePerm π s) (cubePerm π x) = walsh s x := by |
| unfold walsh |
| exact Fintype.prod_equiv π _ _ (fun _ => rfl) |
|
|
| noncomputable def reindex {n : ℕ} (π : Equiv.Perm (Fin n)) (f : Cube (Fin n) → ℝ) |
| (x : Cube (Fin n)) : ℝ := f (cubePerm π x) |
|
|
| theorem coefficient_reindex {n : ℕ} (π : Equiv.Perm (Fin n)) (f : Cube (Fin n) → ℝ) |
| (s : Cube (Fin n)) : coefficient (reindex π f) s = coefficient f (cubePerm π s) := by |
| unfold coefficient reindex |
| apply Fintype.expect_equiv (cubePerm π) |
| intro x |
| rw [walsh_cubePerm] |
|
|
| theorem mean_reindex {n : ℕ} (π : Equiv.Perm (Fin n)) (f : Cube (Fin n) → ℝ) : |
| (𝔼 x, reindex π f x) = 𝔼 x, f x := |
| Fintype.expect_equiv (cubePerm π) _ _ (fun _ => rfl) |
|
|
| theorem cutoffInfluence_reindex {n : ℕ} (π : Equiv.Perm (Fin n)) (f : Cube (Fin n) → ℝ) |
| (K : ℕ) (i : Fin n) : |
| cutoffInfluence K i (reindex π f) = cutoffInfluence K (π.symm i) f := by |
| classical |
| unfold cutoffInfluence |
| simp only [sum_filter, coefficient_reindex] |
| apply Fintype.sum_equiv (cubePerm π) |
| intro s |
| simp [degree_cubePerm] |
|
|
| theorem cutoffInfluence_nonneg {n : ℕ} (K : ℕ) (i : Fin n) (f : Cube (Fin n) → ℝ) : |
| 0 ≤ cutoffInfluence K i f := |
| sum_nonneg (fun _ _ => sq_nonneg _) |
|
|
| namespace Game |
| variable {X Y E : Type*} [Fintype X] [Fintype Y] [Fintype E] {q : ℕ} |
|
|
| /-- A real weighted averaging of all pulled-back odd long codes at a right |
| question. The graph/test itself uses only rational probabilities. -/ |
| noncomputable def averageCode (G : Game X Y E q) (f : X → Cube (Fin q) → ℝ) |
| (y : Y) (z : Cube (Fin q)) : ℝ := |
| (G.edgeLaw y).avg (fun e => reindex (G.permutation e) (f (G.source e)) z) |
|
|
| theorem averageCode_bounded (G : Game X Y E q) (f : X → Cube (Fin q) → ℝ) |
| (hf : ∀ x z, f x z ∈ Set.Icc (-1 : ℝ) 1) (y : Y) (z : Cube (Fin q)) : |
| G.averageCode f y z ∈ Set.Icc (-1 : ℝ) 1 := |
| (G.edgeLaw y).avg_mem (fun e => hf (G.source e) _) |
|
|
| theorem averageCode_mean (G : Game X Y E q) (f : X → Cube (Fin q) → ℝ) |
| (hf : ∀ x, (𝔼 z, f x z) = 0) (y : Y) : (𝔼 z, G.averageCode f y z) = 0 := by |
| unfold averageCode |
| rw [Law.avg_expect] |
| simp_rw [mean_reindex, hf] |
| exact Law.avg_const _ _ |
|
|
| theorem averageCode_influence (G : Game X Y E q) (f : X → Cube (Fin q) → ℝ) |
| (K : ℕ) (y : Y) (i : Fin q) : |
| cutoffInfluence K i (G.averageCode f y) ≤ (G.edgeLaw y).avg (fun e => |
| cutoffInfluence K ((G.permutation e).symm i) (f (G.source e))) := by |
| apply (Law.cutoffInfluence_avg (G.edgeLaw y) _ K i).trans_eq |
| simp_rw [cutoffInfluence_reindex] |
|
|
| /-- Low-degree Fourier influence decodes an actual labeling. There is no |
| assumed decoder or hardness assertion in this inequality. -/ |
| theorem decoding_bound (G : Game X Y E q) (hq : 0 < q) (K : ℕ) |
| (f : X → Cube (Fin q) → ℝ) (hf : ∀ x z, f x z ∈ Set.Icc (-1 : ℝ) 1) |
| (δ : ℝ) (hsound : G.Sound δ) (ly : Y → Fin q) : |
| G.rightLaw.avg (fun y => (G.edgeLaw y).avg (fun e => |
| cutoffInfluence K ((G.permutation e).symm (ly y)) (f (G.source e)))) ≤ (K : ℝ) * δ := by |
| classical |
| let : Nonempty (Fin q) := ⟨⟨0, hq⟩⟩ |
| let P (x : X) (i : Fin q) : ℝ := cutoffInfluence K i (f x) |
| let score (x : X) (i : Fin q) : ℝ := G.rightLaw.avg (fun y => |
| (G.edgeLaw y).avg (fun e => if G.source e = x then |
| (if G.permutation e i = ly y then 1 else 0) else 0)) |
| have hP (x : X) (i : Fin q) : 0 ≤ P x i := cutoffInfluence_nonneg _ _ _ |
| have hPsum (x : X) : (∑ i, P x i) ≤ (K : ℝ) := sum_cutoffInfluences K (f x) (hf x) |
| have hscore (x : X) (i : Fin q) : 0 ≤ score x i := by |
| apply Law.avg_nonneg |
| intro y |
| apply Law.avg_nonneg |
| intro e |
| split_ifs <;> norm_num |
| have hmax (x : X) : ∃ i : Fin q, ∀ j, score x j ≤ score x i := by |
| obtain ⟨i, _, hi⟩ := exists_max_image univ (score x) univ_nonempty |
| exact ⟨i, fun j => hi j (mem_univ _)⟩ |
| choose lx hlx using hmax |
| have hweighted (x : X) : (∑ i, P x i * score x i) ≤ (K : ℝ) * score x (lx x) := by |
| calc |
| _ ≤ ∑ i, P x i * score x (lx x) := |
| sum_le_sum (fun i _ => mul_le_mul_of_nonneg_left (hlx x i) (hP x i)) |
| _ = (∑ i, P x i) * score x (lx x) := (sum_mul _ _ _).symm |
| _ ≤ _ := mul_le_mul_of_nonneg_right (hPsum x) (hscore x (lx x)) |
| have htotal : (∑ x, score x (lx x)) = G.satisfied lx ly := by |
| dsimp [score, satisfied] |
| simp_rw [← Law.avg_sum] |
| congr 1 |
| funext y |
| congr 1 |
| funext e |
| simp |
| have hinfluence : (∑ x, ∑ i, P x i * score x i) = |
| G.rightLaw.avg (fun y => (G.edgeLaw y).avg (fun e => |
| P (G.source e) ((G.permutation e).symm (ly y)))) := by |
| calc |
| _ = ∑ x, ∑ i, G.rightLaw.avg (fun y => (G.edgeLaw y).avg (fun e => |
| P x i * (if G.source e = x then (if G.permutation e i = ly y then 1 else 0) else 0))) := by |
| simp only [Law.avg_smul, score] |
| _ = G.rightLaw.avg (fun y => (G.edgeLaw y).avg (fun e => |
| ∑ x, ∑ i, P x i * (if G.source e = x then (if G.permutation e i = ly y then 1 else 0) else 0))) := by |
| simp_rw [Law.avg_sum] |
| _ = _ := by |
| congr 1 |
| funext y |
| congr 1 |
| funext e |
| simp only [← Equiv.eq_symm_apply, mul_ite, mul_one, mul_zero] |
| simp |
| change G.rightLaw.avg (fun y => (G.edgeLaw y).avg (fun e => |
| P (G.source e) ((G.permutation e).symm (ly y)))) ≤ _ |
| rw [← hinfluence] |
| calc |
| _ ≤ ∑ x, (K : ℝ) * score x (lx x) := sum_le_sum (fun x _ => hweighted x) |
| _ = (K : ℝ) * G.satisfied lx ly := by rw [← mul_sum, htotal] |
| _ ≤ (K : ℝ) * δ := mul_le_mul_of_nonneg_left (hsound lx ly) (Nat.cast_nonneg _) |
|
|
| end Game |
| end OptimalMaxCut.LongCode |
|
|
| end |
|
|
| end OAI |
|
|
