import Mathlib

namespace OAI

/-! Finite Fourier orthogonality and row-column operator duality. -/

noncomputable section
open scoped BigOperators
open Module Complex UniqueFactorizationMonoid
attribute [local instance] Classical.propDecidable

namespace CubicFirstMoment.SieveFourier
variable {R : Type*} [CommRing R] [Fintype R]

lemma finite_fourier_parseval (ψ : AddChar R ℂ) (hψ : ψ.IsPrimitive) (f : R → ℂ) :
    (∑ a : R, ‖∑ x : R, f x * ψ (a*x)‖^2) =
      (Fintype.card R : ℝ) * ∑ x : R, ‖f x‖^2 := by
  classical
  have hcomplex :
      (∑ a : R, (∑ x : R, f x * ψ (a*x)) * star (∑ x : R, f x * ψ (a*x))) =
        (Fintype.card R : ℂ) * ∑ x : R, f x * star (f x) := by
    simp_rw [star_sum, Finset.sum_mul_sum]
    rw [Finset.sum_comm]
    apply Eq.trans (Finset.sum_congr rfl fun x _ => Finset.sum_comm)
    have he (x y a : R) :
        f x * ψ (a*x) * star (f y * ψ (a*y)) =
          (f x * star (f y)) * ψ (a*(x-y)) := by
      rw [star_mul]
      have hc : star (ψ (a*y)) = ψ (-(a*y)) := by
        exact (ψ.map_neg_eq_conj (a*y)).symm
      rw [hc]
      rw [show f x * ψ (a*x) * (ψ (-(a*y)) * star (f y)) =
        (f x * star (f y)) * (ψ (a*x) * ψ (-(a*y))) by ring]
      rw [← ψ.map_add_eq_mul]
      congr 2
      ring
    simp_rw [he, ← Finset.mul_sum, AddChar.sum_mulShift _ hψ]
    simp only [sub_eq_zero, Nat.cast_ite, Nat.cast_zero, mul_ite, mul_zero]
    simp [Finset.mul_sum, mul_comm]
  simp only [Complex.star_def, Complex.mul_conj, ← Complex.ofReal_sum,
    ← Complex.ofReal_natCast, ← Complex.ofReal_mul] at hcomplex
  have hre := congrArg Complex.re hcomplex
  simpa only [map_sum, Complex.mul_conj, Complex.ofReal_re, Complex.re_sum,
    Complex.mul_re, Complex.natCast_re, Complex.natCast_im, zero_mul, sub_zero,
    Complex.normSq_eq_norm_sq] using hre

lemma saturated_gauss_nonunit (χ : MulChar R ℂ) (ψ : AddChar R ℂ)
    (hψ : ψ.IsPrimitive) (hG : ‖gaussSum χ ψ‖^2 = (Fintype.card R : ℝ))
    {a : R} (ha : ¬IsUnit a) : gaussSum χ (ψ.mulShift a) = 0 := by
  classical
  let d : R → ℝ := fun b => ‖gaussSum χ (ψ.mulShift b)‖^2 -
    (Fintype.card R : ℝ) * ‖χ b‖^2
  have hd (b : R) : 0 ≤ d b := by
    by_cases hb : IsUnit b
    · have he := gaussSum_mulShift_eq χ ψ hb.unit
      rw [hb.unit_spec] at he
      have hn : ‖χ⁻¹ b‖ = 1 := by
        simpa only [MulChar.coe_equivToUnitHom, hb.unit_spec] using Complex.norm_eq_one_of_mem_rootsOfUnity
          (MulChar.apply_mem_rootsOfUnity (χ := χ⁻¹) hb.unit)
      have hn' : ‖χ b‖ = 1 := by
        simpa only [MulChar.coe_equivToUnitHom, hb.unit_spec] using Complex.norm_eq_one_of_mem_rootsOfUnity
          (MulChar.apply_mem_rootsOfUnity (χ := χ) hb.unit)
      simp [d, he, hn, hn', hG]
    · simp [d, MulChar.map_nonunit _ hb]
  have hs : ∑ b : R, d b = 0 := by
    simp only [d, Finset.sum_sub_distrib, ← Finset.mul_sum]
    have hp := finite_fourier_parseval ψ hψ χ
    simpa only [gaussSum, AddChar.mulShift_apply, sub_eq_zero] using hp
  have hz : d a = 0 := (Finset.sum_eq_zero_iff_of_nonneg (fun b _ => hd b)).mp hs a
    (Finset.mem_univ a)
  simpa [d, MulChar.map_nonunit _ ha] using hz

lemma saturated_gauss_mulShift (χ : MulChar R ℂ) (ψ : AddChar R ℂ)
    (hψ : ψ.IsPrimitive) (hG : ‖gaussSum χ ψ‖^2 = (Fintype.card R : ℝ)) (a : R) :
    gaussSum χ (ψ.mulShift a) = χ⁻¹ a * gaussSum χ ψ := by
  by_cases ha : IsUnit a
  · simpa [ha.unit_spec] using gaussSum_mulShift_eq χ ψ ha.unit
  · rw [saturated_gauss_nonunit χ ψ hψ hG ha, MulChar.map_nonunit _ ha, zero_mul]

end CubicFirstMoment.SieveFourier

namespace CubicFirstMoment
namespace SieveOperator

def Bound {ι θ : Type*} (H : Finset ι) (S : Finset θ) (χ : ι → θ → ℂ) (K : ℝ) : Prop :=
  ∀ u : θ → ℂ, ∑ h ∈ H, ‖∑ a ∈ S, u a * χ h a‖^2 ≤ K * ∑ a ∈ S, ‖u a‖^2

lemma sum_mul_norm_sq {ι : Type*} (s : Finset ι) (f g : ι → ℂ) :
    ‖∑ i ∈ s, f i * g i‖^2 ≤ (∑ i ∈ s, ‖f i‖^2) * ∑ i ∈ s, ‖g i‖^2 := by
  calc
    _ ≤ (∑ i ∈ s, ‖f i‖*‖g i‖)^2 := by
      apply pow_le_pow_left₀ (_root_.norm_nonneg _)
      simpa only [norm_mul] using norm_sum_le s (fun i => f i*g i)
    _ ≤ _ := Finset.sum_mul_sq_le_sq_mul_sq s _ _

 
lemma Bound.transpose {ι θ : Type*} {H : Finset ι} {S : Finset θ}
    {χ : ι → θ → ℂ} {K : ℝ} (hK : 0 ≤ K) (h : Bound H S χ K) :
    Bound S H (fun a b => χ b a) K := by
  intro u
  let v : θ → ℂ := fun a => ∑ b ∈ H, u b * χ b a
  let E : ℝ := ∑ a ∈ S, ‖v a‖^2
  have hE : 0 ≤ E := Finset.sum_nonneg fun _ _ => sq_nonneg _
  have he : (E : ℂ) = ∑ b ∈ H, u b * ∑ a ∈ S, star (v a) * χ b a := by
    change ((∑ a ∈ S, ‖v a‖^2 : ℝ) : ℂ) = _
    push_cast
    have hn (a : θ) : (‖v a‖ : ℂ)^2 = v a * star (v a) := by
      rw [Complex.star_def, Complex.mul_conj, Complex.normSq_eq_norm_sq, Complex.ofReal_pow]
    simp_rw [hn]
    dsimp only [v] at *
    simp only [Finset.mul_sum, Finset.sum_mul]
    rw [Finset.sum_comm]
    apply Finset.sum_congr rfl
    intro b hb
    apply Finset.sum_congr rfl
    intro a ha
    ring
  have hc := sum_mul_norm_sq H u (fun b => ∑ a ∈ S, star (v a) * χ b a)
  have hop := h (fun a => star (v a))
  simp only [norm_star] at hop
  have hc' : E^2 ≤ (∑ b ∈ H, ‖u b‖^2) * (K * E) := by
    rw [← he, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg hE] at hc
    exact hc.trans (mul_le_mul_of_nonneg_left hop (Finset.sum_nonneg fun _ _ => sq_nonneg _))
  change E ≤ K * ∑ b ∈ H, ‖u b‖^2
  by_cases hE0 : E = 0
  · rw [hE0]
    exact mul_nonneg hK (Finset.sum_nonneg fun _ _ => sq_nonneg _)
  · apply (mul_le_mul_iff_right₀ (lt_of_le_of_ne hE (Ne.symm hE0))).mp
    calc
      E*E = E^2 := by ring
      _ ≤ (∑ b ∈ H, ‖u b‖^2) * (K*E) := hc'
      _ = E*(K*∑ b ∈ H, ‖u b‖^2) := by ring

end SieveOperator
end CubicFirstMoment
end

end OAI