import Mathlib
import OAI.Computability.MaxCut.Gadgets.Polynomial
import OAI.Computability.MaxCut.Encoding.BitCube

namespace OAI

noncomputable section
namespace OptimalMaxCut.MISProof
open scoped BigOperators
open Finset Set MaxCutGames.Foundations.Hastad Analytic BooleanFourthMoment GaussianBellman

 theorem degree_cons {n : ℕ} (a : Bool) (s : Cube (Fin n)) :
    degree (Fin.cons a s) = degree s + if a then 1 else 0 := by
  simp only [degree, Finset.card_eq_sum_ones, Finset.sum_filter, Fin.sum_univ_succ,
    Fin.cons_zero, Fin.cons_succ]
  cases a <;> simp [Nat.add_comm]

 theorem corrAverage_sum {ι : Type*} (S : Finset ι) (t : ℝ) (n : ℕ)
    (F : ι → BitCube n → BitCube n → ℝ) :
    corrAverage t n (fun x y => ∑ i ∈ S, F i x y) = ∑ i ∈ S, corrAverage t n (F i) := by
  classical
  induction S using Finset.induction_on with
  | empty => simpa using corrAverage_fst t n (fun _ => 0)
  | @insert a S ha ih => simp only [Finset.sum_insert ha, corrAverage_add, ih]

 theorem corrAverage_walsh (t : ℝ) (n : ℕ) (s r : Cube (Fin n)) :
    corrAverage t n (fun x y => walsh s x * walsh r y) =
      if s = r then t ^ degree s else 0 := by
  induction n with
  | zero => simp [corrAverage, walsh, degree, Subsingleton.elim s r]
  | succ n ih =>
    obtain ⟨⟨a, s⟩, rfl⟩ := (Fin.consEquiv (fun _ : Fin (n + 1) => Bool)).surjective s
    obtain ⟨⟨b, r⟩, rfl⟩ := (Fin.consEquiv (fun _ : Fin (n + 1) => Bool)).surjective r
    change corrAverage t (n + 1) (fun x y => walsh (Fin.cons a s) x * walsh (Fin.cons b r) y) =
      if (Fin.cons a s : Cube (Fin (n + 1))) = Fin.cons b r then t ^ degree (Fin.cons a s) else 0
    have hp (x y : Cube (Fin n)) :
        (∑ e : Bool, ∑ f : Bool, bitPairWeight t e f *
          (walsh (Fin.cons a s) (Fin.cons e x) * walsh (Fin.cons b r) (Fin.cons f y))) =
        (if a = b then (if a then t else 1) else 0) * (walsh s x * walsh r y) := by
      cases a <;> cases b <;>
        simp only [Fintype.sum_bool, bitPairWeight, sign, walsh_cons, bitSign,
          Bool.false_eq_true, Bool.true_eq_false, ↓reduceIte] <;> ring
    simp only [corrAverage, hp, corrAverage_const_mul, ih, Fin.cons_inj, degree_cons]
    cases a <;> cases b <;> by_cases h : s = r <;> simp [h, pow_succ, mul_comm]

 theorem corrAverage_polynomial (t : ℝ) (n : ℕ) (c d : Cube (Fin n) → ℝ) :
    corrAverage t n (fun x y => polynomial c x * polynomial d y) =
      ∑ s, t ^ degree s * c s * d s := by
  have hp (x y : Cube (Fin n)) : polynomial c x * polynomial d y =
      ∑ s, ∑ r, (c s * d r) * (walsh s x * walsh r y) := by
    simp only [polynomial]
    rw [Finset.sum_mul]
    simp only [Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro s _
    apply Finset.sum_congr rfl
    intro r _
    ring
  simp only [hp, corrAverage_sum, corrAverage_const_mul, corrAverage_walsh]
  apply Finset.sum_congr rfl
  intro s _
  simp [mul_ite]
  ring

 theorem corrAverage_stability (t : ℝ) (n : ℕ) (f : Cube (Fin n) → ℝ) :
    corrAverage t n (fun x y => f x * f y) = stability t f := by
  have hf : polynomial (coefficient f) = f := funext (walsh_inversion f)
  rw [← hf, corrAverage_polynomial]
  simp only [stability, coefficient_polynomial]
  apply Finset.sum_congr rfl
  intro s _
  ring

noncomputable def clip (x : ℝ) : ℝ := max (-1) (min 1 x)

 theorem clip_mem (x : ℝ) : clip x ∈ Icc (-1 : ℝ) 1 := by
  constructor
  · exact le_max_left _ _
  · exact max_le (by norm_num) (min_le_left _ _)

 theorem clip_eq {x : ℝ} (hx : x ∈ Icc (-1 : ℝ) 1) : clip x = x := by
  rw [clip, min_eq_right hx.2, max_eq_right hx.1]

 theorem clip_lipschitz (a b : ℝ) : |clip a - clip b| ≤ |a - b| := by
  have h1 := le_abs_self (a - b)
  have h2 := neg_le_abs (a - b)
  unfold clip
  simp only [max_def, min_def]
  split_ifs <;> apply abs_le.mpr <;> constructor <;> linarith

noncomputable def interiorClip (η x : ℝ) : ℝ := η + (1 - 2 * η) * (clip x + 1) / 2

 theorem interiorClip_mem {η : ℝ} (_hη : 0 ≤ η) (hη' : η ≤ 1 / 2) (x : ℝ) :
    interiorClip η x ∈ Icc η (1 - η) := by
  have hx := clip_mem x
  have hl := mul_nonneg (by linarith : 0 ≤ 1 - 2 * η) (by linarith [hx.1] : 0 ≤ clip x + 1)
  have hu := mul_le_mul_of_nonneg_left (by linarith [hx.2] : clip x + 1 ≤ 2)
    (by linarith : 0 ≤ 1 - 2 * η)
  unfold interiorClip
  constructor <;> linarith

 theorem interiorClip_lipschitz {η : ℝ} (hη : 0 ≤ η) (hη' : η ≤ 1 / 2) (a b : ℝ) :
    |interiorClip η a - interiorClip η b| ≤ |a - b| := by
  have hc : 0 ≤ (1 - 2 * η) / 2 := by linarith
  have hc' : (1 - 2 * η) / 2 ≤ 1 := by linarith
  have he : interiorClip η a - interiorClip η b = (1 - 2 * η) / 2 * (clip a - clip b) := by
    unfold interiorClip; ring
  rw [he, abs_mul, abs_of_nonneg hc]
  exact (mul_le_mul_of_nonneg_left (clip_lipschitz a b) hc).trans
    (by simpa using mul_le_mul_of_nonneg_right hc' (abs_nonneg (a - b)))

 theorem interiorClip_approx {η b : ℝ} (hη : 0 ≤ η) (hb : b ∈ Icc (-1 : ℝ) 1) (a : ℝ) :
    |interiorClip η a - (b + 1) / 2| ≤ |a - b| + η := by
  have he : interiorClip η a - (b + 1) / 2 = (clip a - b) / 2 + (-η * clip a) := by
    unfold interiorClip; ring
  have hc : |clip a| ≤ 1 := abs_le.mpr (clip_mem a)
  have hab : |clip a - b| ≤ |a - b| := by
    simpa only [clip_eq hb] using clip_lipschitz a b
  rw [he]
  calc
    _ ≤ |(clip a - b) / 2| + |-η * clip a| := abs_add_le _ _
    _ = |clip a - b| / 2 + η * |clip a| := by
      rw [abs_div, abs_mul, abs_neg, abs_of_nonneg hη]; norm_num
    _ ≤ |a - b| / 2 + η * 1 := add_le_add (by linarith) (mul_le_mul_of_nonneg_left hc hη)
    _ ≤ _ := by linarith [abs_nonneg (a - b)]

 theorem mean_abs_diff_le {n : ℕ} (f g : BitCube n → ℝ) :
    |(𝔼 x, f x) - (𝔼 x, g x)| ≤ 𝔼 x, |f x - g x| := by
  rw [← Finset.expect_sub_distrib]
  apply abs_le.mpr
  constructor
  · rw [← Finset.expect_neg_distrib]
    exact Finset.expect_le_expect (fun x _ => neg_le_of_abs_le (le_refl |f x - g x|))
  · exact Finset.expect_le_expect (fun x _ => le_abs_self _)

 theorem correlation_diff_le {t : ℝ} (ht : t ∈ Icc (-1 : ℝ) 1) {n : ℕ}
    (f g : BitCube n → ℝ) (hf : ∀ x, f x ∈ Icc (0 : ℝ) 1) (hg : ∀ x, g x ∈ Icc (0 : ℝ) 1) :
    corrAverage t n (fun x y => f x * f y) ≤
      corrAverage t n (fun x y => g x * g y) + 2 * (𝔼 x, |f x - g x|) := by
  have hp (x y : BitCube n) : f x * f y ≤ g x * g y + |f x - g x| + |f y - g y| := by
    have h1 := mul_le_mul_of_nonneg_right (le_abs_self (f x - g x)) (hf y).1
    have h2 := mul_le_mul_of_nonneg_left (hf y).2 (abs_nonneg (f x - g x))
    have h3 := mul_le_mul_of_nonneg_left (le_abs_self (f y - g y)) (hg x).1
    have h4 := mul_le_mul_of_nonneg_right (hg x).2 (abs_nonneg (f y - g y))
    nlinarith
  have hh := corrAverage_mono ht n hp
  rw [corrAverage_add, corrAverage_add, corrAverage_fst, corrAverage_snd] at hh
  linarith

 theorem centered_half_correlation (t : ℝ) (n : ℕ) (h : BitCube n → ℝ) (hm : (𝔼 x, h x) = 0) :
    4 * corrAverage t n (fun x y => ((h x + 1) / 2) * ((h y + 1) / 2)) - 1 = stability t h := by
  have hp (x y : BitCube n) : ((h x + 1) / 2) * ((h y + 1) / 2) =
      (h x * h y + h x + h y + 1) * (1 / 4) := by ring
  simp_rw [hp]
  rw [corrAverage_mul_const, corrAverage_add, corrAverage_add, corrAverage_add,
    corrAverage_fst, corrAverage_fst, corrAverage_snd, corrAverage_stability, hm,
    Fintype.expect_const]
  ring

noncomputable def smoothedTruncCoeff {n : ℕ} (K : ℕ) (u : ℝ) (h : BitCube n → ℝ)
    (s : BitCube n) : ℝ := if degree s ≤ K then u ^ degree s * coefficient h s else 0

 theorem smoothedTrunc_high {n K : ℕ} (u : ℝ) (h : BitCube n → ℝ)
    (s : BitCube n) (hs : K < degree s) : smoothedTruncCoeff K u h s = 0 := by
  simp [smoothedTruncCoeff, not_le.mpr hs]

 theorem smoothedTrunc_sq_le {n K : ℕ} {u : ℝ} (hu : u ∈ Icc (0 : ℝ) 1)
    (h : BitCube n → ℝ) (s : BitCube n) : smoothedTruncCoeff K u h s ^ 2 ≤ coefficient h s ^ 2 := by
  unfold smoothedTruncCoeff
  split_ifs
  · rw [mul_pow]
    exact (mul_le_mul_of_nonneg_right (pow_le_one₀ (pow_nonneg hu.1 _) (pow_le_one₀ hu.1 hu.2))
      (sq_nonneg _)).trans_eq (one_mul _)
  · simpa only [zero_pow (by omega : 2 ≠ 0)] using sq_nonneg (coefficient h s)

 theorem smoothedTrunc_second_le {n K : ℕ} {u : ℝ} (hu : u ∈ Icc (0 : ℝ) 1)
    (h : BitCube n → ℝ) (hh : ∀ x, h x ∈ Icc (-1 : ℝ) 1) :
    (𝔼 x, polynomial (smoothedTruncCoeff K u h) x ^ 2) ≤ 1 := by
  rw [polynomial_second_moment]
  exact (Finset.sum_le_sum (fun s _ => smoothedTrunc_sq_le hu h s)).trans (spectral_energy_le_one h hh)

 theorem smoothedTrunc_diff_second {n K : ℕ} {u : ℝ} (hu : u ∈ Icc (0 : ℝ) 1)
    (h : BitCube n → ℝ) (i : Fin n) :
    (𝔼 x, discreteDiff (polynomial (smoothedTruncCoeff K u h)) i x ^ 2) ≤ cutoffInfluence K i h := by
  rw [polynomial_diff, polynomial_second_moment]
  unfold cutoffInfluence
  rw [Finset.sum_filter]
  apply Finset.sum_le_sum
  intro s _
  by_cases hi : s i = true
  · simp only [hi, ↓reduceIte, true_and]
    by_cases hs : degree s ≤ K
    · rw [ite_eq_left hs]; exact smoothedTrunc_sq_le hu h s
    · simp [smoothedTruncCoeff, hs]
  · simp [hi]

 theorem coefficient_sub {n : ℕ} (f g : BitCube n → ℝ) (s : BitCube n) :
    coefficient (fun x => f x - g x) s = coefficient f s - coefficient g s := by
  simp only [coefficient, sub_mul, Finset.expect_sub_distrib]

 theorem smoothedTrunc_tail_second {n K : ℕ} {u : ℝ} (hu : u ∈ Icc (0 : ℝ) 1)
    (h : BitCube n → ℝ) (hh : ∀ x, h x ∈ Icc (-1 : ℝ) 1) :
    (𝔼 x, (polynomial (smoothedTruncCoeff K u h) x - noise u h x) ^ 2) ≤ u ^ (2 * (K + 1)) := by
  rw [← walsh_parseval]
  simp only [coefficient_sub, coefficient_polynomial, coefficient_noise]
  calc
    _ ≤ ∑ s, u ^ (2 * (K + 1)) * coefficient h s ^ 2 := by
      apply Finset.sum_le_sum
      intro s _
      by_cases hs : degree s ≤ K
      · simp only [smoothedTruncCoeff, ite_eq_left hs, sub_self, zero_pow (by omega : 2 ≠ 0)]
        exact mul_nonneg (pow_nonneg hu.1 _) (sq_nonneg _)
      · have hd : 2 * (K + 1) ≤ degree s * 2 := by omega
        have hp := pow_le_pow_of_le_one hu.1 hu.2 hd
        simp only [smoothedTruncCoeff, ite_eq_right hs, zero_sub, neg_sq, mul_pow, ← pow_mul]
        exact mul_le_mul_of_nonneg_right hp (sq_nonneg _)
    _ = u ^ (2 * (K + 1)) * ∑ s, coefficient h s ^ 2 := (Finset.mul_sum ..).symm
    _ ≤ u ^ (2 * (K + 1)) * 1 := mul_le_mul_of_nonneg_left (spectral_energy_le_one h hh) (pow_nonneg hu.1 _)
    _ = _ := mul_one _

 theorem mean_abs_le_of_second {n : ℕ} (f : BitCube n → ℝ) {ε : ℝ} (hε : 0 ≤ ε)
    (hf : (𝔼 x, f x ^ 2) ≤ ε ^ 2) : (𝔼 x, |f x|) ≤ ε := by
  have hCS := Finset.expect_mul_sq_le_sq_mul_sq Finset.univ (fun x => |f x|) (fun _ => (1 : ℝ))
  simp only [mul_one, one_pow, sq_abs, Fintype.expect_const] at hCS
  exact (sq_le_sq₀ (by positivity) hε).mp (hCS.trans hf)

 theorem smoothedTrunc_tail_first {n K : ℕ} {u ε : ℝ} (hu : u ∈ Icc (0 : ℝ) 1)
    (hε : 0 ≤ ε) (htail : u ^ (2 * (K + 1)) ≤ ε ^ 2)
    (h : BitCube n → ℝ) (hh : ∀ x, h x ∈ Icc (-1 : ℝ) 1) :
    (𝔼 x, |polynomial (smoothedTruncCoeff K u h) x - noise u h x|) ≤ ε :=
  mean_abs_le_of_second _ hε ((smoothedTrunc_tail_second hu h hh).trans htail)

 theorem clipped_polynomial_bellman {t η : ℝ} (ht : t ∈ Ico (0 : ℝ) 1)
    (hη : 0 < η) (hη' : η ≤ 1 / 2) :
    ∃ C : ℝ, 0 ≤ C ∧ ∀ (n K : ℕ) (c : BitCube n → ℝ) (τ : ℝ), 0 ≤ τ →
      (∀ s, K < degree s → c s = 0) →
      (𝔼 x, polynomial c x ^ 2) ≤ 1 →
      (∀ i, (𝔼 x, discreteDiff (polynomial c) i x ^ 2) ≤ τ ^ 2) →
      corrAverage t n (fun x y => interiorClip η (polynomial c x) * interiorClip η (polynomial c y)) ≤
        kernel t (𝔼 x, interiorClip η (polynomial c x)) (𝔼 x, interiorClip η (polynomial c x)) +
          2 * C * (3 ^ K * τ * K) := by
  obtain ⟨C, hC0, hC⟩ := kernel_one_bit ht hη hη'
  refine ⟨C, hC0, ?_⟩
  intro n K c τ hτ hc hsecond hsmall
  let F : BitCube n → ℝ := fun x => interiorClip η (polynomial c x)
  have hcost : cubicCost n F ≤ 3 ^ K * τ * K := by
    calc
      _ ≤ ∑ i, 𝔼 x, |gradient F i x| ^ 3 := cubicCost_le_gradients n F
      _ ≤ ∑ i, 𝔼 x, |discreteDiff (polynomial c) i x| ^ 3 := by
        apply Finset.sum_le_sum
        intro i _
        apply Finset.expect_le_expect
        intro x _
        exact pow_le_pow_left₀ (abs_nonneg _)
          (gradient_lipschitz (interiorClip η) (interiorClip_lipschitz hη.le hη') (polynomial c) i x) 3
      _ ≤ 3 ^ K * τ * K * (𝔼 x, polynomial c x ^ 2) := total_diff_third_truncated c hc hτ hsmall
      _ ≤ 3 ^ K * τ * K * 1 := mul_le_mul_of_nonneg_left hsecond (by positivity)
      _ = _ := mul_one _
  have hF (x : BitCube n) : F x ∈ Icc η (1 - η) := interiorClip_mem hη.le hη' _
  have htt : t ∈ Icc (-1 : ℝ) 1 := ⟨by linarith [ht.1], ht.2.le⟩
  have hb := finite_bellman_tensorization htt (kernel t) hC n F F hF hF
  have hm := corrAverage_mono htt n (fun x y => kernel_ge_product ht (F x) (F y))
  have he := mul_le_mul_of_nonneg_left hcost hC0
  change corrAverage t n (fun x y => F x * F y) ≤
    kernel t (𝔼 x, F x) (𝔼 x, F x) + 2 * C * (3 ^ K * τ * K)
  linarith

 theorem mean_mem_Icc {n : ℕ} {l u : ℝ} (f : BitCube n → ℝ) (hf : ∀ x, f x ∈ Icc l u) :
    (𝔼 x, f x) ∈ Icc l u :=
  ⟨Finset.le_expect Finset.univ_nonempty (fun x _ => (hf x).1),
    Finset.expect_le Finset.univ_nonempty (fun x _ => (hf x).2)⟩

 theorem smoothed_stability_bellman {t η u τ C : ℝ} {n K : ℕ}
    (ht : t ∈ Ico (0 : ℝ) 1) (hη : 0 < η) (hη' : η ≤ 1 / 2)
    (hu : u ∈ Icc (0 : ℝ) 1)
    (h : BitCube n → ℝ) (hh : ∀ x, h x ∈ Icc (-1 : ℝ) 1) (hm : (𝔼 x, h x) = 0)
    (htail : u ^ (2 * (K + 1)) ≤ η ^ 2)
    (hb : corrAverage t n (fun x y =>
        interiorClip η (polynomial (smoothedTruncCoeff K u h) x) *
          interiorClip η (polynomial (smoothedTruncCoeff K u h) y)) ≤
      kernel t (𝔼 x, interiorClip η (polynomial (smoothedTruncCoeff K u h) x))
        (𝔼 x, interiorClip η (polynomial (smoothedTruncCoeff K u h) x)) + 2 * C * (3 ^ K * τ * K)) :
    stability t (noise u h) ≤ 2 / Real.pi * Real.arcsin t + 32 * η + 8 * C * (3 ^ K * τ * K) := by
  let P := polynomial (smoothedTruncCoeff K u h)
  let F : BitCube n → ℝ := fun x => interiorClip η (P x)
  let G : BitCube n → ℝ := fun x => (noise u h x + 1) / 2
  have hnoise := noise_bounded u hu.1 hu.2 h hh
  have hmean : (𝔼 x, G x) = 1 / 2 := by
    change (𝔼 x, ((noise u h x + 1) / 2)) = 1 / 2
    rw [← Finset.expect_div, Finset.expect_add_distrib, noise_mean, hm, Fintype.expect_const]
    ring
  have hF (x : BitCube n) : F x ∈ Icc η (1 - η) := interiorClip_mem hη.le hη' _
  have hF01 (x : BitCube n) : F x ∈ Icc (0 : ℝ) 1 := by
    have hhx := hF x
    constructor <;> linarith [hhx.1, hhx.2]
  have hG01 (x : BitCube n) : G x ∈ Icc (0 : ℝ) 1 := by
    dsimp [G]
    constructor <;> linarith [(hnoise x).1, (hnoise x).2]
  have hdiff : (𝔼 x, |F x - G x|) ≤ 2 * η := by
    calc
      _ ≤ 𝔼 x, (|P x - noise u h x| + η) :=
        Finset.expect_le_expect (fun x _ => interiorClip_approx hη.le (hnoise x) (P x))
      _ = (𝔼 x, |P x - noise u h x|) + η := by rw [Finset.expect_add_distrib, Fintype.expect_const]
      _ ≤ 2 * η := by linarith [smoothedTrunc_tail_first hu hη.le htail h hh]
  have hmeanF : (𝔼 x, F x) ∈ Ioo (0 : ℝ) 1 := by
    have hhF := mean_mem_Icc F hF
    constructor <;> linarith [hhF.1, hhF.2]
  have hmeanDiff : |(𝔼 x, F x) - (1 / 2 : ℝ)| ≤ 2 * η := by
    have hbnd := (mean_abs_diff_le F G).trans hdiff
    rwa [hmean] at hbnd
  have hhalf : (1 / 2 : ℝ) ∈ Ioo (0 : ℝ) 1 := by constructor <;> norm_num
  have hk := kernel_lipschitz ht hhalf hmeanF hhalf hmeanF
  have hk' := (abs_le.mp hk).2
  rw [kernel_half ht] at hk'
  have hcorr := correlation_diff_le ⟨by linarith [ht.1], ht.2.le⟩ G F hG01 hF01
  have heq : (𝔼 x, |G x - F x|) = 𝔼 x, |F x - G x| := by simp only [abs_sub_comm]
  rw [heq] at hcorr
  have hnmean : (𝔼 x, noise u h x) = 0 := (noise_mean u h).trans hm
  have hid := centered_half_correlation t n (noise u h) hnmean
  change 4 * corrAverage t n (fun x y => G x * G y) - 1 = stability t (noise u h) at hid
  change corrAverage t n (fun x y => F x * F y) ≤
    kernel t (𝔼 x, F x) (𝔼 x, F x) + 2 * C * (3 ^ K * τ * K) at hb
  have halg : 4 * (Real.arcsin t / (2 * Real.pi)) = 2 / Real.pi * Real.arcsin t := by ring
  linarith

 theorem majority_is_stablest : MajorityIsStablest := by
  intro t ht ht1 ξ hξ
  obtain ⟨u, hu, hu1, huerr⟩ := exists_uniform_noise_error t ξ ht.le ht1 hξ
  let η : ℝ := min (1 / 4) (ξ / 128)
  have hη : 0 < η := lt_min (by norm_num) (by positivity)
  have hηsmall : η ≤ 1 / 4 := min_le_left _ _
  have hηξ : η ≤ ξ / 128 := min_le_right _ _
  have hηhalf : η ≤ 1 / 2 := by linarith
  obtain ⟨C, hC0, hC⟩ := clipped_polynomial_bellman ⟨ht.le, ht1⟩ hη hηhalf
  obtain ⟨K, hK, htail⟩ := exists_influence_tail_cutoff u (2 * η ^ 2) hu.le hu1 (by positivity)
  have htail' : u ^ (2 * (K + 1)) ≤ η ^ 2 := by linarith
  let D : ℝ := 8 * C * 3 ^ K * K
  have hD : 0 ≤ D := by dsimp [D]; positivity
  let r : ℝ := (ξ / 4) / (D + 1)
  have hr : 0 < r := by dsimp [r]; positivity
  have hrEq : (D + 1) * r = ξ / 4 := by
    dsimp [r]
    field_simp
  have herr : D * r ≤ ξ / 4 := by nlinarith
  refine ⟨K, hK, r ^ 2, sq_pos_of_pos hr, ?_⟩
  intro n h hh hm hi
  have hsmall (i : Fin n) :
      (𝔼 x, discreteDiff (polynomial (smoothedTruncCoeff K u h)) i x ^ 2) ≤ r ^ 2 :=
    (smoothedTrunc_diff_second ⟨hu.le, hu1.le⟩ h i).trans (hi i).le
  have hb := hC n K (smoothedTruncCoeff K u h) r hr.le
    (smoothedTrunc_high u h) (smoothedTrunc_second_le ⟨hu.le, hu1.le⟩ h hh) hsmall
  have hst := smoothed_stability_bellman ⟨ht.le, ht1⟩ hη hηhalf ⟨hu.le, hu1.le⟩ h hh hm htail' hb
  have hsmooth := stability_sub_noise_le t u (ξ / 2) h hh (by positivity) huerr
  have halg : 8 * C * (3 ^ K * r * K) = D * r := by dsimp [D]; ring
  rw [halg] at hst
  linarith

 theorem cutoffInfluence_le_influence {n : ℕ} (K : ℕ) (i : Fin n) (h : BitCube n → ℝ) :
    cutoffInfluence K i h ≤ influence i h := by
  unfold cutoffInfluence influence
  apply Finset.sum_le_sum_of_subset_of_nonneg
  · intro s hs
    simp only [Finset.mem_filter, Finset.mem_univ, true_and] at hs ⊢
    exact hs.1
  · intro s _ _; exact sq_nonneg _

 theorem untruncated_majority_is_stablest : UntruncatedMajorityIsStablest := by
  intro t ht ht1 ξ hξ
  obtain ⟨K, _, τ, hτ, hbound⟩ := majority_is_stablest t ht ht1 ξ hξ
  refine ⟨τ, hτ, ?_⟩
  intro n h hh hm hi
  exact hbound n h hh hm (fun i => (cutoffInfluence_le_influence K i h).trans_lt (hi i))

end OptimalMaxCut.MISProof

namespace OptimalMaxCut.LongCode

open scoped BigOperators
open Finset MaxCutGames.Foundations.Hastad OptimalMaxCut.Analytic
open OptimalMaxCut.GaussianBellman OptimalMaxCut.MISProof

/-- Explicit rational finite probability law. The weighted test below is a
finite rational graph construction, not an oracle distribution. -/
structure Law (I : Type*) [Fintype I] where
  weight : I → ℚ
  nonneg : ∀ i, 0 ≤ weight i
  total : ∑ i, weight i = 1

namespace Law
variable {I J : Type*} [Fintype I] [Fintype J]

def avg (p : Law I) (f : I → ℝ) : ℝ := ∑ i, (p.weight i : ℝ) * f i

theorem weight_nonneg (p : Law I) (i : I) : 0 ≤ (p.weight i : ℝ) := by
  exact_mod_cast p.nonneg i

theorem total_real (p : Law I) : ∑ i, (p.weight i : ℝ) = 1 := by
  exact_mod_cast p.total

@[simp] theorem avg_const (p : Law I) (a : ℝ) : p.avg (fun _ => a) = a := by
  simp [avg, ← sum_mul, total_real]

theorem avg_mono (p : Law I) {f g : I → ℝ} (h : ∀ i, f i ≤ g i) : p.avg f ≤ p.avg g :=
  sum_le_sum fun i _ => mul_le_mul_of_nonneg_left (h i) (p.weight_nonneg i)

theorem avg_nonneg (p : Law I) {f : I → ℝ} (h : ∀ i, 0 ≤ f i) : 0 ≤ p.avg f := by
  simpa using p.avg_mono h

@[simp] theorem avg_add (p : Law I) (f g : I → ℝ) :
    p.avg (fun i => f i + g i) = p.avg f + p.avg g := by simp [avg, mul_add, sum_add_distrib]

@[simp] theorem avg_sub (p : Law I) (f g : I → ℝ) :
    p.avg (fun i => f i - g i) = p.avg f - p.avg g := by simp [avg, mul_sub, sum_sub_distrib]

@[simp] theorem avg_mul (p : Law I) (f : I → ℝ) (a : ℝ) :
    p.avg (fun i => f i * a) = p.avg f * a := by simp [avg, sum_mul, mul_assoc]

@[simp] theorem avg_smul (p : Law I) (f : I → ℝ) (a : ℝ) :
    p.avg (fun i => a * f i) = a * p.avg f := by simp [avg, mul_left_comm, mul_sum]

@[simp] theorem avg_div (p : Law I) (f : I → ℝ) (a : ℝ) :
    p.avg (fun i => f i / a) = p.avg f / a := by simp [div_eq_mul_inv]

theorem avg_sum (p : Law I) (f : J → I → ℝ) :
    p.avg (fun i => ∑ j, f j i) = ∑ j, p.avg (f j) := by
  simp_rw [avg, mul_sum]
  rw [sum_comm]

theorem avg_avg (p : Law I) (q : Law J) (f : I → J → ℝ) :
    p.avg (fun i => q.avg (f i)) = q.avg (fun j => p.avg (fun i => f i j)) := by
  simp_rw [avg, mul_sum]
  rw [sum_comm]
  simp_rw [mul_left_comm]

theorem avg_sq_le (p : Law I) (f : I → ℝ) : p.avg f ^ 2 ≤ p.avg (fun i => f i ^ 2) := by
  have h := p.avg_nonneg (fun i => sq_nonneg (f i - p.avg f))
  have he : p.avg (fun i => (f i - p.avg f) ^ 2) = p.avg (fun i => f i ^ 2) - p.avg f ^ 2 := by
    simp_rw [sub_sq]
    rw [avg_add, avg_sub, avg_mul, avg_smul, avg_const]
    ring
  rw [he] at h
  linarith

theorem avg_mem (p : Law I) {f : I → ℝ} {a b : ℝ} (h : ∀ i, f i ∈ Set.Icc a b) :
    p.avg f ∈ Set.Icc a b := by
  constructor
  · simpa using p.avg_mono (fun i => (h i).1)
  · simpa using p.avg_mono (fun i => (h i).2)

 theorem avg_expect {n : ℕ} (p : Law I) (f : I → Cube (Fin n) → ℝ) :
    (𝔼 x, p.avg (fun i => f i x)) = p.avg (fun i => 𝔼 x, f i x) := by
  simp_rw [avg, Finset.expect_sum_comm, ← Finset.mul_expect]

 theorem coefficient_avg {n : ℕ} (p : Law I) (f : I → Cube (Fin n) → ℝ)
    (s : Cube (Fin n)) :
    coefficient (fun x => p.avg (fun i => f i x)) s = p.avg (fun i => coefficient (f i) s) := by
  simp_rw [coefficient, avg, sum_mul, mul_assoc, Finset.expect_sum_comm, ← Finset.mul_expect]

 theorem cutoffInfluence_avg {n : ℕ} (p : Law I) (f : I → Cube (Fin n) → ℝ)
    (K : ℕ) (a : Fin n) :
    cutoffInfluence K a (fun x => p.avg (fun i => f i x)) ≤
      p.avg (fun i => cutoffInfluence K a (f i)) := by
  unfold cutoffInfluence
  simp_rw [coefficient_avg]
  calc
    _ ≤ ∑ s ∈ univ.filter (fun s : Cube (Fin n) => s a = true ∧ degree s ≤ K),
        p.avg (fun i => coefficient (f i) s ^ 2) := sum_le_sum fun s _ => p.avg_sq_le _
    _ = _ := by simp_rw [avg, mul_sum]; rw [sum_comm]

end Law

/-- The generative presentation of a finite rational weighted Unique Game:
choose a right question, then an incident edge. All actual games have this
presentation after deleting zero-marginal right questions. -/
structure Game (X Y E : Type*) [Fintype X] [Fintype Y] [Fintype E] (q : ℕ) where
  rightLaw : Law Y
  edgeLaw : Y → Law E
  source : E → X
  permutation : E → Equiv.Perm (Fin q)

namespace Game
variable {X Y E : Type*} [Fintype X] [Fintype Y] [Fintype E] {q : ℕ}

noncomputable def satisfied (G : Game X Y E q) (lx : X → Fin q) (ly : Y → Fin q) : ℝ :=
  G.rightLaw.avg (fun y => (G.edgeLaw y).avg (fun e =>
    if G.permutation e (lx (G.source e)) = ly y then 1 else 0))

/-- A semantic bound on this *input* game, not a hypothesis asserting NP-hardness
or an assumed Max-Cut reduction. -/
def Sound (G : Game X Y E q) (δ : ℝ) : Prop := ∀ lx ly, G.satisfied lx ly ≤ δ

end Game

noncomputable def antipode {n : ℕ} (x : Cube (Fin n)) : Cube (Fin n) := fun i => !(x i)

 theorem antipode_involutive {n : ℕ} : Function.Involutive (@antipode n) := by
  intro x
  funext i
  simp [antipode]

noncomputable def oddPart {n : ℕ} (f : Cube (Fin n) → ℝ) (x : Cube (Fin n)) : ℝ :=
  (f x - f (antipode x)) / 2
noncomputable def evenPart {n : ℕ} (f : Cube (Fin n) → ℝ) (x : Cube (Fin n)) : ℝ :=
  (f x + f (antipode x)) / 2

 theorem oddPart_bounded {n : ℕ} (f : Cube (Fin n) → ℝ)
    (hf : ∀ x, f x ∈ Set.Icc (-1 : ℝ) 1) (x : Cube (Fin n)) :
    oddPart f x ∈ Set.Icc (-1 : ℝ) 1 := by
  have h1 := hf x
  have h2 := hf (antipode x)
  constructor <;> dsimp [oddPart] <;> linarith [h1.1,h1.2,h2.1,h2.2]

 theorem oddPart_mean {n : ℕ} (f : Cube (Fin n) → ℝ) : (𝔼 x, oddPart f x) = 0 := by
  have he : (𝔼 x, f (antipode x)) = 𝔼 x, f x := by
    exact Fintype.expect_equiv antipode_involutive.toPerm _ _ (fun _ => rfl)
  simp_rw [oddPart]
  rw [← Finset.expect_div, Finset.expect_sub_distrib, he]
  ring

 theorem sum_cutoffInfluences {n : ℕ} (K : ℕ) (f : Cube (Fin n) → ℝ)
    (hf : ∀ x, f x ∈ Set.Icc (-1 : ℝ) 1) :
    (∑ i, cutoffInfluence K i f) ≤ K := by
  classical
  have hiden : (∑ i, cutoffInfluence K i f) =
      ∑ s : Cube (Fin n), if degree s ≤ K then (degree s : ℝ) * coefficient f s ^ 2 else 0 := by
    unfold cutoffInfluence
    simp_rw [sum_filter]
    rw [sum_comm]
    apply sum_congr rfl
    intro s _
    by_cases hs : degree s ≤ K
    · simp only [hs, and_true, ↓reduceIte]
      rw [← sum_filter]
      simp [degree, sum_const, nsmul_eq_mul]
    · simp [hs]
  rw [hiden]
  calc
    _ ≤ ∑ s : Cube (Fin n), (K : ℝ) * coefficient f s ^ 2 := by
      apply sum_le_sum
      intro s _
      split_ifs with hs
      · exact mul_le_mul_of_nonneg_right (by exact_mod_cast hs) (sq_nonneg _)
      · positivity
    _ = (K : ℝ) * ∑ s, coefficient f s ^ 2 := (mul_sum _ _ _).symm
    _ ≤ (K : ℝ) * 1 := mul_le_mul_of_nonneg_left (spectral_energy_le_one f hf) (Nat.cast_nonneg _)
    _ = _ := mul_one _

end OptimalMaxCut.LongCode

end

end OAI