lean/OAI/Computability/MinUncut/Estimates/Convolution.lean

import Mathlib
import OAI.Computability.MinUncut.Estimates.F2
import OAI.Computability.MinUncut.Analysis.Gradient

namespace OAI

noncomputable section
open scoped BigOperators
open MeasureTheory ProbabilityTheory Filter
open scoped Topology NNReal
open scoped BigOperators
open MeasureTheory ProbabilityTheory Polynomial Filter
open scoped BigOperators Topology
namespace MinUncut.GaussianHermite
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

lemma noise_derivative (ρ s : ℝ) (hs : s ≠ 0) {Q : (ι → ℝ) → ℝ}
    (hQ : Measurable Q) (hb : ∀ x, |Q x| ≤ 1) (x : ι → ℝ) (i : ι) :
    HasDerivAt (fun t => noise ρ s Q (Function.update x i t)) (gradient ρ s Q i x) (x i) := by
  have hd := GaussianSmoothing.product_convolution_derivative hQ hb hs (ρ • x) i
  have hm : HasDerivAt (fun t : ℝ => ρ*t) ρ (x i) := by
    simpa only [mul_one, id_eq] using (hasDerivAt_id (x i)).const_mul ρ
  have hc := hd.comp (x i) hm
  convert! hc using 1
  · funext t
    unfold noise
    congr 1
    funext g
    congr 2
    ext j
    by_cases hj : j = i
    · subst j; simp; rfl
    · simp [Function.update_of_ne hj]
  · dsimp [gradient, score]
    ring

def convolution (σ : ℝ) (Q : (ι → ℝ) → ℝ) (x : ι → ℝ) : ℝ :=
  ∫ g, Q (x + σ • g) ∂γpi ι

def convolutionGradient (σ : ℝ) (Q : (ι → ℝ) → ℝ) (i : ι) (x : ι → ℝ) : ℝ :=
  σ⁻¹ * ∫ g, g i * Q (x + σ • g) ∂γpi ι

lemma convolution_derivative {σ : ℝ} (hσ : σ ≠ 0) {Q : (ι → ℝ) → ℝ}
    (hQ : Measurable Q) (hb : ∀ x, |Q x| ≤ 1) (x : ι → ℝ) (i : ι) :
    HasDerivAt (fun t => convolution σ Q (Function.update x i t))
      (convolutionGradient σ Q i x) (x i) :=
  GaussianSmoothing.product_convolution_derivative hQ hb hσ x i

omit [DecidableEq ι] in
lemma convolution_as_noise {ρ σ : ℝ} (hρ : ρ ≠ 0) (Q : (ι → ℝ) → ℝ) :
    convolution σ Q = noise ρ (σ*ρ) (fun v => Q (ρ⁻¹ • v)) := by
  funext x
  unfold convolution noise
  congr 1
  funext g
  congr 1
  ext i
  dsimp
  field_simp

omit [DecidableEq ι] in
lemma convolutionGradient_as_noise {ρ σ : ℝ} (hρ : ρ ≠ 0) (hσ : σ ≠ 0)
    (Q : (ι → ℝ) → ℝ) (i : ι) :
    convolutionGradient σ Q i = gradient ρ (σ*ρ) (fun v => Q (ρ⁻¹ • v)) i := by
  funext x
  unfold convolutionGradient gradient score
  have hc : ρ/(σ*ρ) = σ⁻¹ := by field_simp
  rw [hc]
  congr 1
  apply integral_congr_ae
  filter_upwards [] with g
  congr 2
  ext j
  dsimp
  field_simp

lemma convolution_poincare {ρ σ : ℝ} (hρ : ρ ≠ 0) (hσ : σ ≠ 0)
    (h : ρ^2+(σ*ρ)^2=1) {Q : (ι → ℝ) → ℝ} (hQ : Measurable Q)
    (hb : ∀ x, |Q x| ≤ 1) (hmean : (∫ x, convolution σ Q x ∂γpi ι) = 0) :
    (∫ x, (convolution σ Q x)^2 ∂γpi ι) ≤
      ∑ i, ∫ x, (convolutionGradient σ Q i x)^2 ∂γpi ι := by
  simp_rw [convolution_as_noise hρ, convolutionGradient_as_noise hρ hσ] at *
  exact poincare ρ (σ*ρ) h (mul_ne_zero hσ hρ) (hQ.comp (by fun_prop))
    (fun x => hb _) hmean

lemma convolution_gradient_tail {ρ σ ε : ℝ} (hρ : ρ ≠ 0) (hσ : σ ≠ 0)
    (h : ρ^2+(σ*ρ)^2=1) (hε : 0 ≤ ε) (d : ℕ)
    (hd : ∀ k : ℕ, d+2 ≤ k → (k:ℝ)*ρ^(2*k) ≤ ε)
    {Q : (ι → ℝ) → ℝ} (hQ : Measurable Q) (hb : ∀ x, |Q x| ≤ 1) :
    (∑ i, ∫ x, (convolutionGradient σ Q i x -
      project d (convolutionGradient σ Q i) x)^2 ∂γpi ι) ≤ ε := by
  simp_rw [convolutionGradient_as_noise hρ hσ]
  exact gradient_tail_le ρ (σ*ρ) h (mul_ne_zero hσ hρ) (hQ.comp (by fun_prop))
    (fun x => hb _) d hε hd

end MinUncut.GaussianHermite

namespace MinUncut.RowNoise
open BinaryFourier
local instance convolutionDualFintype {U : Type*} [AddCommGroup U] [Module F₂ U] [Fintype U] :
    Fintype (Module.Dual F₂ U) := BinaryFourier.dualFintype
variable {R W : Type*} [Fintype R] [DecidableEq R] [Fintype W] [DecidableEq W]
  [AddCommGroup W] [Module F₂ W]

lemma expect_prod {A : R → Type*} [∀ r, Fintype (A r)] (f : ∀ r, A r → ℝ) :
    (𝔼 x : ∀ r, A r, ∏ r, f r (x r)) = ∏ r, 𝔼 a, f r a := by
  simp only [Fintype.expect_eq_sum_div_card, Fintype.card_pi]
  rw [← Fintype.prod_sum, Nat.cast_prod, Finset.prod_div_distrib]

def rowDensity (a : ℝ) (b c : W) : ℝ :=
  (1-a)*(if c=b then (Fintype.card W : ℝ) else 0) + a

omit [Module F₂ W] in
lemma rowDensity_mean (a : ℝ) (b : W) : (𝔼 c, rowDensity a b c) = 1 := by
  rw [Fintype.expect_eq_sum_div_card]
  simp only [rowDensity, Finset.sum_add_distrib, ← Finset.mul_sum,
    Finset.sum_ite_eq', Finset.mem_univ, ite_true, Finset.sum_const,
    Finset.card_univ, nsmul_eq_mul]
  have hn : (Fintype.card W : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr Fintype.card_ne_zero
  field_simp
  ring

omit [AddCommGroup W] [Module F₂ W] in
lemma rowDensity_symmetric (a : ℝ) (b c : W) : rowDensity a b c = rowDensity a c b := by
  simp [rowDensity, eq_comm]

omit [Module F₂ W] in
lemma rowDensity_nonneg {a : ℝ} (ha : 0 ≤ a) (ha1 : a ≤ 1) (b c : W) :
    0 ≤ rowDensity a b c := by
  unfold rowDensity
  split_ifs <;> positivity

def density (a : ℝ) (B C : R → W) : ℝ := ∏ r, rowDensity a (B r) (C r)

omit [Module F₂ W] in
lemma density_mean (a : ℝ) (B : R → W) : (𝔼 C, density a B C) = 1 := by
  simp only [density, expect_prod, rowDensity_mean, Finset.prod_const_one]

omit [DecidableEq R] [AddCommGroup W] [Module F₂ W] in
lemma density_symmetric (a : ℝ) (B C : R → W) : density a B C = density a C B := by
  simp only [density, rowDensity_symmetric a]

omit [DecidableEq R] [Module F₂ W] in
lemma density_nonneg {a : ℝ} (ha : 0 ≤ a) (ha1 : a ≤ 1) (B C : R → W) :
    0 ≤ density a B C := Finset.prod_nonneg (fun _ _ => rowDensity_nonneg ha ha1 _ _)

def frequency (α : Module.Dual F₂ (R → W)) (r : R) : Module.Dual F₂ W :=
  α.comp (LinearMap.single F₂ (fun _ : R => W) r)

omit [Fintype W] [DecidableEq W] in
lemma dual_apply (α : Module.Dual F₂ (R → W)) (B : R → W) :
    α B = ∑ r, frequency α r (B r) := by
  change α B = ∑ r, α (Pi.single r (B r))
  rw [← map_sum]
  congr 1
  ext r
  simp

lemma sign_sum {S : Type*} (s : Finset S) (f : S → F₂) :
    sign (∑ i ∈ s, f i) = ∏ i ∈ s, sign (f i) := by
  classical
  induction s using Finset.induction_on with
  | empty => simp
  | insert i s hi ih => simp [hi, sign_add, ih]

omit [Fintype W] [DecidableEq W] in
lemma character_product (α : Module.Dual F₂ (R → W)) (B : R → W) :
    character α B = ∏ r, character (frequency α r) (B r) := by
  simp only [character, dual_apply, sign_sum]

def mask (α : Module.Dual F₂ (R → W)) : Finset R :=
  Finset.univ.filter (fun r => frequency α r ≠ 0)

def degree (α : Module.Dual F₂ (R → W)) : ℕ := (mask α).card

lemma row_character_eigen (a : ℝ) (b : W) (α : Module.Dual F₂ W) :
    (𝔼 c, rowDensity a b c * character α c) =
      (if α=0 then 1 else 1-a)*character α b := by
  unfold rowDensity
  simp only [add_mul, Finset.expect_add_distrib, mul_assoc, ← Finset.mul_expect]
  have hh : (𝔼 c, (if c=b then (Fintype.card W : ℝ) else 0) * character α c) =
      character α b := by
    rw [Fintype.expect_eq_sum_div_card]
    simp only [ite_mul, zero_mul, Finset.sum_ite_eq', Finset.mem_univ, ite_true]
    exact mul_div_cancel_left₀ _ (Nat.cast_ne_zero.mpr Fintype.card_ne_zero)
  rw [hh, character_mean]
  split_ifs with hα
  · subst α; simp
  · ring

def noise (a : ℝ) (f : (R → W) → ℝ) (B : R → W) : ℝ :=
  𝔼 C, density a B C * f C

lemma noise_character (a : ℝ) (α : Module.Dual F₂ (R → W)) (B : R → W) :
    noise a (character α) B = (1-a)^degree α*character α B := by
  simp only [noise, density, character_product]
  simp_rw [← Finset.prod_mul_distrib]
  rw [expect_prod (fun r c => rowDensity a (B r) c * character (frequency α r) c)]
  simp only [row_character_eigen, Finset.prod_mul_distrib]
  congr 1
  simp only [Finset.prod_ite, Finset.prod_const_one, one_mul, Finset.prod_const]
  rfl

lemma noise_expansion (a : ℝ) (f : (R → W) → ℝ) (B : R → W) :
    noise a f B = ∑ α, coefficient f α * (1-a)^degree α * character α B := by
  unfold noise
  simp_rw [← inversion f, Finset.mul_sum, Finset.expect_sum_comm]
  apply Finset.sum_congr rfl
  intro α _
  have he : (𝔼 C, density a B C * (coefficient f α * character α C)) =
      coefficient f α * noise a (character α) B := by
    unfold noise
    rw [Finset.mul_expect]
    apply Finset.expect_congr rfl
    intro C _
    ring
  rw [he, noise_character]
  ring

lemma correlation (a : ℝ) (f : (R → W) → ℝ) :
    (𝔼 B, f B * noise a f B) = ∑ α, (1-a)^degree α*(coefficient f α)^2 := by
  simp_rw [noise_expansion, Finset.mul_sum, Finset.expect_sum_comm]
  apply Finset.sum_congr rfl
  intro α _
  calc
    _ = ((1-a)^degree α*coefficient f α) * (𝔼 B, f B * character α B) := by
      rw [Finset.mul_expect]
      apply Finset.expect_congr rfl
      intro B _
      ring
    _ = _ := by rw [← coefficient]; ring

omit [Module F₂ W] in
lemma stationary (a : ℝ) (f : (R → W) → ℝ) : (𝔼 B, noise a f B) = 𝔼 B, f B := by
  unfold noise
  rw [Finset.expect_comm]
  apply Finset.expect_congr rfl
  intro C _
  simp_rw [density_symmetric a _ C, ← Finset.expect_mul, density_mean, one_mul]

lemma dirichlet (a : ℝ) (f : (R → W) → ℝ) :
    (𝔼 B, 𝔼 C, density a B C * (f B - f C)^2) =
      2 * ∑ α, (1-(1-a)^degree α)*(coefficient f α)^2 := by
  have he (B C : R → W) : density a B C*(f B-f C)^2 =
      (f B)^2*density a B C + density a B C*(f C)^2 - 2*f B*(density a B C*f C) := by ring
  simp_rw [he, Finset.expect_sub_distrib, Finset.expect_add_distrib,
    ← Finset.mul_expect, density_mean, mul_one]
  have ht : (𝔼 B, 2*f B*(𝔼 C, density a B C*f C)) =
      2*(𝔼 B, f B*noise a f B) := by
    simp only [noise, Finset.mul_expect, mul_assoc]
  rw [ht]
  change (𝔼 B, f B^2)+(𝔼 B, noise a (fun C => (f C)^2) B) -
    2*(𝔼 B, f B*noise a f B) = _
  rw [stationary, correlation, ← parseval]
  simp_rw [sub_mul, one_mul, Finset.sum_sub_distrib]
  ring

def project (D : ℕ) (f : (R → W) → ℝ) (B : R → W) : ℝ :=
  ∑ α ∈ Finset.univ.filter (fun α => degree α ≤ D), coefficient f α * character α B

omit [DecidableEq W] in
lemma coefficient_project (D : ℕ) (f : (R → W) → ℝ) (β : Module.Dual F₂ (R → W)) :
    coefficient (project D f) β = if degree β ≤ D then coefficient f β else 0 := by
  unfold coefficient project
  simp_rw [Finset.sum_mul, Finset.expect_sum_comm, mul_assoc, ← Finset.mul_expect,
    character_orthogonality]
  simp [Finset.mem_filter, coefficient]

omit [DecidableEq W] in
lemma coefficient_residual (D : ℕ) (f : (R → W) → ℝ) (β : Module.Dual F₂ (R → W)) :
    coefficient (fun B => f B-project D f B) β =
      if degree β ≤ D then 0 else coefficient f β := by
  have he : coefficient (fun B => f B-project D f B) β =
      coefficient f β - coefficient (project D f) β := by
    simp only [coefficient, sub_mul, Finset.expect_sub_distrib]
  rw [he, coefficient_project]
  split_ifs <;> ring

omit [DecidableEq W] in
lemma residual_energy (D : ℕ) (f : (R → W) → ℝ) :
    (𝔼 B, (f B-project D f B)^2) =
      ∑ α, if D < degree α then (coefficient f α)^2 else 0 := by
  rw [← parseval]
  apply Finset.sum_congr rfl
  intro α _
  rw [coefficient_residual]
  split_ifs <;> simp_all
  omega

lemma geometric_bernoulli {a : ℝ} (_ha : 0 ≤ a) (ha1 : a ≤ 1) (k : ℕ) :
    (1-a)^k*(1+(k:ℝ)*a) ≤ 1 := by
  induction k with
  | zero => simp
  | succ k ih =>
    have hp : 0 ≤ (1-a)^k := pow_nonneg (by linarith) _
    have hh : (1-a)*(1+((k:ℝ)+1)*a) ≤ 1+(k:ℝ)*a := by
      nlinarith [mul_nonneg (by positivity : (0:ℝ) ≤ (k:ℝ)+1) (sq_nonneg a)]
    calc
      _ = (1-a)^k*((1-a)*(1+((k:ℝ)+1)*a)) := by rw [pow_succ]; push_cast; ring
      _ ≤ (1-a)^k*(1+(k:ℝ)*a) := mul_le_mul_of_nonneg_left hh hp
      _ ≤ 1 := ih

lemma spectral_weight_ge_one {a : ℝ} (ha : 0 ≤ a) (ha1 : a ≤ 1)
    (k : ℕ) (hk : 1 ≤ (k:ℝ)*a) : 1 ≤ 2*(1-(1-a)^k) := by
  have hp := pow_nonneg (by linarith : 0 ≤ 1-a) k
  have hb := geometric_bernoulli ha ha1 k
  nlinarith [mul_nonneg hp (sub_nonneg.mpr hk)]

lemma row_tail_le {a : ℝ} (ha : 0 ≤ a) (ha1 : a ≤ 1) (D : ℕ)
    (hD : ∀ k : ℕ, D < k → 1 ≤ (k:ℝ)*a) (f : (R → W) → ℝ) :
    (𝔼 B, (f B-project D f B)^2) ≤
      𝔼 B, 𝔼 C, density a B C*(f B-f C)^2 := by
  rw [residual_energy, dirichlet, Finset.mul_sum]
  apply Finset.sum_le_sum
  intro α _
  by_cases hd : D < degree α
  · rw [ite_eq_left hd, ← mul_assoc]
    simpa using mul_le_mul_of_nonneg_right
      (spectral_weight_ge_one ha ha1 (degree α) (hD _ hd))
      (sq_nonneg (coefficient f α))
  · rw [ite_eq_right hd]
    have hp : (1-a)^degree α ≤ 1 := pow_le_one₀ (by linarith) (by linarith)
    positivity

end MinUncut.RowNoise

end

end OAI