import OAI.NumberTheory.TwoPoint.Circuits.FourierCorrection

namespace OAI

/-!
# Bounded-independence circuit comparison after Fourier correction

The comparison uses the fixed-depth specialization of Mark Braverman,
*Polylogarithmic independence fools AC⁰ circuits*, J. ACM 57 (2010), Article 28,
Corollary 2 in the author's version. We use depth 22, with absolute constants
and natural logarithms. Circuits below have actual finite syntax: literals
and arbitrary finite-fan-in AND/OR gates. They are tree circuits, a subclass
of the circuits covered by Braverman's theorem. The size counts both input
occurrences and gates; the depth counts AND/OR levels.
-/

namespace TwoPointCorrelations

open Finset

/-- Finite AC⁰ syntax in negation normal form. Sharing is not needed for the
finite residue tests; literals can have either polarity. -/
inductive AC0Circuit (n : ℕ) where
  | literal (i : Fin n) (positive : Bool)
  | andGate {k : ℕ} (children : Fin k → AC0Circuit n)
  | orGate {k : ℕ} (children : Fin k → AC0Circuit n)

namespace AC0Circuit

/-- Evaluation on a Boolean input vector. Empty AND/OR gates are true/false. -/
def eval {n : ℕ} : AC0Circuit n → BooleanCube n → Bool
  | .literal i positive, x => if positive then x i else !(x i)
  | .andGate children, x => decide (∀ i, eval (children i) x = true)
  | .orGate children, x => decide (∃ i, eval (children i) x = true)

/-- AND/OR depth, with literals at depth zero. -/
def depth {n : ℕ} : AC0Circuit n → ℕ
  | .literal _ _ => 0
  | .andGate children => 1 + Finset.univ.sup (fun i => depth (children i))
  | .orGate children => 1 + Finset.univ.sup (fun i => depth (children i))

/-- Gates plus input occurrences. -/
def size {n : ℕ} : AC0Circuit n → ℕ
  | .literal _ _ => 1
  | .andGate children => 1 + ∑ i, size (children i)
  | .orGate children => 1 + ∑ i, size (children i)

lemma size_pos {n : ℕ} (c : AC0Circuit n) : 0 < c.size := by
  cases c <;> simp [size]

/-- Real indicator of the circuit accepting its input. -/
noncomputable def indicator {n : ℕ} (c : AC0Circuit n) (x : BooleanCube n) : ℝ :=
  if c.eval x then 1 else 0

lemma abs_centered_indicator {n : ℕ} (c : AC0Circuit n) (x : BooleanCube n) :
    |c.indicator x - 1 / 2| = (1 / 2 : ℝ) := by
  unfold indicator
  cases c.eval x <;> norm_num

end AC0Circuit

/-- Braverman's Corollary 2 at depth twenty-two. The constants absorb a
choice of logarithm base. Distributions are represented by nonnegative
densities relative to the uniform law on the Boolean cube. -/
def BravermanDepth22Input : Prop :=
  ∃ K C : ℕ, 0 < K ∧ 0 < C ∧ ∀ (n : ℕ) (c : AC0Circuit n), c.depth ≤ 22 →
    ∀ ε : ℝ, 0 < ε → ε ≤ 1 / 2 → ∀ t : ℕ,
      (K : ℝ) * (Real.log ((c.size : ℝ) / ε)) ^ C ≤ (t : ℝ) →
      ∀ g : BooleanCube n → ℝ, (∀ x, 0 ≤ g x) → cubeAverage g = 1 →
        TWiseUniformDensity g t →
        |cubeAverage (fun x => g x * c.indicator x) - cubeAverage c.indicator| ≤ ε

lemma abs_cubeAverage_le {n : ℕ} (f : BooleanCube n → ℝ) :
    |cubeAverage f| ≤ cubeAverage (fun x => |f x|) := by
  unfold cubeAverage
  rw [abs_div, show |(Fintype.card (BooleanCube n) : ℝ)| =
    (Fintype.card (BooleanCube n) : ℝ) from abs_of_nonneg (Nat.cast_nonneg _)]
  exact div_le_div_of_nonneg_right (Finset.abs_sum_le_sum_abs _ _) (Nat.cast_nonneg _)

/-- For measures of equal total mass, an event difference is bounded by one
half of the mean absolute density difference. -/
lemma circuit_event_le_totalVariation {n : ℕ} (c : AC0Circuit n)
    (f g : BooleanCube n → ℝ) (hmass : cubeAverage f = cubeAverage g) :
    |cubeAverage (fun x => f x * c.indicator x) -
      cubeAverage (fun x => g x * c.indicator x)| ≤
        cubeAverage (fun x => |f x - g x|) / 2 := by
  have hzero : cubeAverage (fun x => f x - g x) = 0 := by
    rw [cubeAverage_sub, hmass, sub_self]
  have heq : cubeAverage (fun x => f x * c.indicator x) -
      cubeAverage (fun x => g x * c.indicator x) =
      cubeAverage (fun x => (f x - g x) * (c.indicator x - 1 / 2)) := by
    have hpoint : (fun x => (f x - g x) * (c.indicator x - 1 / 2)) =
        (fun x => (f x * c.indicator x - g x * c.indicator x) -
          (1 / 2 : ℝ) * (f x - g x)) := by
      funext x
      ring
    rw [hpoint, cubeAverage_sub, cubeAverage_sub, cubeAverage_mul_const, hzero]
    ring
  rw [heq]
  apply (abs_cubeAverage_le _).trans
  have hpoint : (fun x => |(f x - g x) * (c.indicator x - 1 / 2)|) =
      (fun x => (1 / 2 : ℝ) * |f x - g x|) := by
    funext x
    rw [abs_mul, c.abs_centered_indicator]
    ring
  rw [hpoint, cubeAverage_mul_const]
  exact le_of_eq (by ring)

/-- Fourier correction followed by Braverman's published theorem compares
the original density against uniform inputs, with the correction error
made explicit. -/
theorem BravermanDepth22Input.fourier_comparison (hBraverman : BravermanDepth22Input) :
    ∃ K C : ℕ, 0 < K ∧ 0 < C ∧ ∀ (n : ℕ) (c : AC0Circuit n), c.depth ≤ 22 →
      ∀ ε : ℝ, 0 < ε → ε ≤ 1 / 2 → ∀ t : ℕ,
        (K : ℝ) * (Real.log ((c.size : ℝ) / ε)) ^ C ≤ (t : ℝ) →
        ∀ (f : BooleanCube n → ℝ) (a : ℝ),
          (∀ x, 0 ≤ f x) → cubeAverage f = 1 → 0 ≤ a → lowWalshMass f t ≤ a →
          |cubeAverage (fun x => f x * c.indicator x) - cubeAverage c.indicator| ≤
            3 * a / 2 + ε := by
  obtain ⟨K, C, hK, hC, hbound⟩ := hBraverman
  refine ⟨K, C, hK, hC, ?_⟩
  intro n c hdepth ε hε hεmax t ht f a hf hmean ha hmass
  let g := correctedCubeDensity f t a
  have hcorr := fourierCorrection f t a hf hmean ha hmass
  have hBrav := hbound n c hdepth ε hε hεmax t ht g hcorr.1 hcorr.2.1 hcorr.2.2.1
  have hTV := circuit_event_le_totalVariation c f g (hmean.trans hcorr.2.1.symm)
  have hTVbound : cubeAverage (fun x => |f x - g x|) / 2 ≤ 3 * a / 2 := by
    simpa only [abs_sub_comm] using hcorr.2.2.2
  calc
    |cubeAverage (fun x => f x * c.indicator x) - cubeAverage c.indicator| ≤
        |cubeAverage (fun x => f x * c.indicator x) -
          cubeAverage (fun x => g x * c.indicator x)| +
        |cubeAverage (fun x => g x * c.indicator x) - cubeAverage c.indicator| :=
      abs_sub_le _ _ _
    _ ≤ 3 * a / 2 + ε := add_le_add (hTV.trans hTVbound) hBrav

end TwoPointCorrelations

end OAI