lean/OAI/Computability/MaxCut/Graphs/TestCut.lean

import Mathlib
import OAI.Computability.MaxCut.Analysis.CubePerm

namespace OAI

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

 theorem stability_nonneg {n : ℕ} (t : ℝ) (ht : 0 ≤ t) (f : Cube (Fin n) → ℝ) :
    0 ≤ stability t f := by
  exact sum_nonneg (fun s _ => mul_nonneg (pow_nonneg ht _) (sq_nonneg _))

 theorem stability_le_one {n : ℕ} (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) 1)
    (f : Cube (Fin n) → ℝ) (hf : ∀ x, f x ∈ Set.Icc (-1 : ℝ) 1) :
    stability t f ≤ 1 := by
  apply le_trans _ (spectral_energy_le_one f hf)
  apply sum_le_sum
  intro s _
  exact mul_le_of_le_one_left (sq_nonneg _) (pow_le_one₀ ht.1 ht.2)

 theorem corrAverage_sub (t : ℝ) (n : ℕ) (F G : BitCube n → BitCube n → ℝ) :
    corrAverage t n (fun x y => F x y - G x y) = corrAverage t n F - corrAverage t n G := by
  have he (x y : BitCube n) : F x y - G x y = F x y + G x y * (-1) := by ring
  simp_rw [he, corrAverage_add, corrAverage_mul_const]
  ring

 theorem corrAverage_swap (t : ℝ) (n : ℕ) (F : BitCube n → BitCube n → ℝ) :
    corrAverage t n (fun x y => F y x) = corrAverage t n F := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [corrAverage]
    rw [ih]
    congr 1
    funext x y
    rw [sum_comm]
    apply sum_congr rfl
    intro a _
    apply sum_congr rfl
    intro b _
    congr 1
    simp only [bitPairWeight]
    ring

 theorem correlation_antipode (t : ℝ) {n : ℕ} (f : Cube (Fin n) → ℝ) :
    corrAverage t n (fun x y => f x * f (antipode y)) =
      stability t (evenPart f) - stability t (oddPart f) := by
  have hp (x y : Cube (Fin n)) : f x * f (antipode y) =
      (evenPart f x * evenPart f y - oddPart f x * oddPart f y) +
        (oddPart f x * evenPart f y - evenPart f x * oddPart f y) := by
    unfold evenPart oddPart
    ring
  have hs : corrAverage t n (fun x y => oddPart f x * evenPart f y) =
      corrAverage t n (fun x y => evenPart f x * oddPart f y) := by
    simpa only [mul_comm] using corrAverage_swap t n (fun x y => evenPart f x * oddPart f y)
  simp_rw [hp]
  rw [corrAverage_add, corrAverage_sub, corrAverage_sub, hs,
    corrAverage_stability, corrAverage_stability]
  ring

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

 theorem oddPart_averageCode (G : Game X Y E q) (f : X → Cube (Fin q) → ℝ) (y : Y) :
    oddPart (G.averageCode f y) = G.averageCode (fun x => oddPart (f x)) y := by
  funext z
  simp only [oddPart, averageCode, reindex, Law.avg_div, Law.avg_sub]
  rfl

/-- Value of the usual correlated long-code Max-Cut test, before aggregating
its finite rational outcomes into graph weights. -/
noncomputable def testCut (G : Game X Y E q) (t : ℝ) (f : X → Cube (Fin q) → ℝ) : ℝ :=
  G.rightLaw.avg (fun y => (1 - corrAverage t q (fun z z' =>
    G.averageCode f y z * G.averageCode f y (antipode z'))) / 2)

 theorem testCut_stability (G : Game X Y E q) (t : ℝ) (f : X → Cube (Fin q) → ℝ) :
    G.testCut t f = 1 / 2 +
      G.rightLaw.avg (fun y => stability t (G.averageCode (fun x => oddPart (f x)) y)) / 2 -
      G.rightLaw.avg (fun y => stability t (evenPart (G.averageCode f y))) / 2 := by
  unfold testCut
  simp_rw [correlation_antipode, oddPart_averageCode]
  simp only [Law.avg_div, Law.avg_sub, Law.avg_const]
  ring

 theorem testCut_le_stability (G : Game X Y E q) (t : ℝ) (ht : 0 ≤ t)
    (f : X → Cube (Fin q) → ℝ) :
    G.testCut t f ≤ (1 +
      G.rightLaw.avg (fun y => stability t (G.averageCode (fun x => oddPart (f x)) y))) / 2 := by
  rw [testCut_stability]
  have h : 0 ≤ G.rightLaw.avg (fun y => stability t (evenPart (G.averageCode f y))) :=
    G.rightLaw.avg_nonneg (fun _ => stability_nonneg t ht _)
  linarith

/-- Dimension-uniform soundness, with an actual Fourier-influence decoding
proof. Every input game soundness bound feeds the finite long-code cut test. -/
 theorem stability_soundness (G : Game X Y E q) (hq : 0 < q)
    {t ξ τ : ℝ} {K : ℕ} (ht : 0 < t) (ht1 : t < 1) (hξ : 0 < ξ) (hτ : 0 < τ)
    (hMIS : ∀ (n : ℕ) (h : Cube (Fin n) → ℝ),
      (∀ x, -1 ≤ h x ∧ h x ≤ 1) → (𝔼 x, h x) = 0 →
      (∀ i, cutoffInfluence K i h < τ) → stability t h ≤ 2 / Real.pi * Real.arcsin t + ξ)
    (f : X → Cube (Fin q) → ℝ) (hf : ∀ x z, f x z ∈ Set.Icc (-1 : ℝ) 1)
    (hm : ∀ x, (𝔼 z, f x z) = 0) (δ : ℝ) (hsound : G.Sound δ) :
    G.rightLaw.avg (fun y => stability t (G.averageCode f y)) ≤
      2 / Real.pi * Real.arcsin t + ξ + (K : ℝ) * δ / τ := by
  classical
  let : Nonempty (Fin q) := ⟨⟨0, hq⟩⟩
  have hp (y : Y) : ∃ i : Fin q, ∀ j,
      cutoffInfluence K j (G.averageCode f y) ≤ cutoffInfluence K i (G.averageCode f y) := by
    obtain ⟨i, _, hi⟩ := exists_max_image univ (fun i => cutoffInfluence K i (G.averageCode f y)) univ_nonempty
    exact ⟨i, fun j => hi j (mem_univ _)⟩
  choose ly hly using hp
  have hB : 0 ≤ 2 / Real.pi * Real.arcsin t + ξ := by
    have h := Real.arcsin_nonneg.mpr ht.le
    positivity
  have hy (y : Y) : stability t (G.averageCode f y) ≤ 2 / Real.pi * Real.arcsin t + ξ +
      cutoffInfluence K (ly y) (G.averageCode f y) / τ := by
    by_cases h : ∀ i, cutoffInfluence K i (G.averageCode f y) < τ
    · have hmis := hMIS q (G.averageCode f y) (G.averageCode_bounded f hf y)
        (G.averageCode_mean f hm y) h
      have hnon : 0 ≤ cutoffInfluence K (ly y) (G.averageCode f y) / τ :=
        div_nonneg (cutoffInfluence_nonneg _ _ _) hτ.le
      linarith
    · push Not at h
      obtain ⟨i, hi⟩ := h
      have hmτ := hi.trans (hly y i)
      have hratio : 1 ≤ cutoffInfluence K (ly y) (G.averageCode f y) / τ :=
        (le_div_iff₀ hτ).mpr (by simpa using hmτ)
      have hstab := stability_le_one t ⟨ht.le, ht1.le⟩ (G.averageCode f y) (G.averageCode_bounded f hf y)
      linarith
  calc
    _ ≤ G.rightLaw.avg (fun y => 2 / Real.pi * Real.arcsin t + ξ +
        cutoffInfluence K (ly y) (G.averageCode f y) / τ) := G.rightLaw.avg_mono hy
    _ = 2 / Real.pi * Real.arcsin t + ξ +
        G.rightLaw.avg (fun y => cutoffInfluence K (ly y) (G.averageCode f y)) / τ := by
      rw [Law.avg_add, Law.avg_const, Law.avg_div]
    _ ≤ 2 / Real.pi * Real.arcsin t + ξ +
        G.rightLaw.avg (fun y => (G.edgeLaw y).avg (fun e =>
          cutoffInfluence K ((G.permutation e).symm (ly y)) (f (G.source e)))) / τ := by
      gcongr
      exact G.rightLaw.avg_mono (fun y => G.averageCode_influence f K y (ly y))
    _ ≤ _ := by
      gcongr
      exact G.decoding_bound hq K f hf δ hsound ly

/-- The MIS threshold and low-degree cutoff are actually proved, not supplied
as assumptions. This theorem is the soundness component of the main reduction. -/
 theorem exists_test_soundness (t ξ : ℝ) (ht : 0 < t) (ht1 : t < 1) (hξ : 0 < ξ) :
    ∃ δ : ℝ, 0 < δ ∧ ∀ {X Y E : Type} [Fintype X] [Fintype Y] [Fintype E]
      (q : ℕ) (_hq : 0 < q) (G : Game X Y E q), G.Sound δ →
      ∀ f : X → Cube (Fin q) → ℝ, (∀ x z, f x z ∈ Set.Icc (-1 : ℝ) 1) →
        G.testCut t f ≤ (1 + 2 / Real.pi * Real.arcsin t) / 2 + ξ := by
  obtain ⟨K, hK, τ, hτ, hMIS⟩ := majority_is_stablest t ht ht1 ξ hξ
  have hKr : 0 < (K : ℝ) := by exact_mod_cast hK
  refine ⟨ξ * τ / K, by positivity, ?_⟩
  intro X Y E _ _ _ q hq G hs f hf
  have ho (x : X) (z : Cube (Fin q)) := oddPart_bounded (f x) (hf x) z
  have hb := G.stability_soundness hq ht ht1 hξ hτ hMIS (fun x => oddPart (f x)) ho
    (fun x => oddPart_mean (f x)) (ξ * τ / K) hs
  have he : (K : ℝ) * (ξ * τ / K) / τ = ξ := by field_simp
  rw [he] at hb
  have hc := G.testCut_le_stability t ht.le f
  linarith

end Game
end OptimalMaxCut.LongCode

end

end OAI