lean/OAI/Combinatorics/EditDistance/PrimeCharacters.lean

import OAI.Combinatorics.EditDistance.FourierCharacters

namespace OAI

/-!
# Coprime roots and prime-product Fourier multipliers
-/

namespace EditFourier
open scoped BigOperators
open Finset

section CoprimeRoots
variable {J : Type*} [DecidableEq J]

omit [DecidableEq J] in

theorem prod_roots_pow (s : Finset J) (p : J → ℕ) (z : J → ℂ)
    (hz : ∀ j ∈ s, z j ^ p j = 1) (q : ℕ) (hq : ∀ j ∈ s, p j ∣ q) :
    (∏ j ∈ s, z j) ^ q = 1 := by
  rw [← prod_pow]
  apply prod_eq_one
  intro j hj
  obtain ⟨m, hm⟩ := hq j hj
  rw [hm, pow_mul, hz j hj, one_pow]

theorem coprime_roots_nontrivial (s : Finset J) (p : J → ℕ) (z : J → ℂ)
    (hcop : (s : Set J).Pairwise (fun i j => (p i).Coprime (p j)))
    (hz : ∀ j ∈ s, z j ^ p j = 1) (i : J) (hi : i ∈ s) (hne : z i ≠ 1) :
    (∏ j ∈ s, z j) ≠ 1 := by
  intro h
  let q := ∏ j ∈ s.erase i, p j
  have hq : ∀ j ∈ s.erase i, p j ∣ q := fun j hj => dvd_prod_of_mem p hj
  have hpow := prod_roots_pow (s.erase i) p z
    (fun j hj => hz j (mem_of_mem_erase hj)) q hq
  have hp : z i ^ q = 1 := by
    have hh := congrArg (fun a : ℂ => a ^ q) h
    rw [← mul_prod_erase s z hi, mul_pow, hpow, mul_one, one_pow] at hh
    exact hh
  have hc : (p i).Coprime q := Nat.Coprime.prod_right fun j hj =>
    hcop hi (mem_of_mem_erase hj) (ne_of_mem_erase hj).symm
  exact hne ((pow_eq_one_iff_of_coprime hc).mp ⟨hz i hi, hp⟩)

theorem coprime_root_separation (s : Finset J) (p : J → ℕ) (z : J → ℂ)
    (hpos : ∀ j ∈ s, 0 < p j)
    (hcop : (s : Set J).Pairwise (fun i j => (p i).Coprime (p j)))
    (hz : ∀ j ∈ s, z j ^ p j = 1) (hnorm : ∀ j ∈ s, ‖z j‖ = 1)
    (i : J) (hi : i ∈ s) (hne : z i ≠ 1) :
    2 ≤ ((∏ j ∈ s, p j : ℕ) : ℝ) * ‖(∏ j ∈ s, z j) - 1‖ := by
  apply root_separation
  · rw [norm_prod]
    exact prod_eq_one hnorm
  · exact coprime_roots_nontrivial s p z hcop hz i hi hne
  · exact prod_pos hpos
  · apply prod_roots_pow s p z hz
    exact fun j hj => dvd_prod_of_mem p hj

end CoprimeRoots
end EditFourier

namespace EditFourier
open scoped BigOperators
open Finset

lemma norm_sub_one_sq_of_norm_one (z : ℂ) (hz : ‖z‖ = 1) :
    ‖z - 1‖ ^ 2 = 2 - 2 * z.re := by
  have hh : z.re * z.re + z.im * z.im = 1 := by
    have h := congrArg (fun x : ℝ => x ^ 2) hz
    rw [← Complex.normSq_eq_norm_sq, Complex.normSq_apply] at h
    simpa only [one_pow] using h
  simp only [← Complex.normSq_eq_norm_sq, Complex.normSq_apply,
    Complex.sub_re, Complex.one_re, Complex.sub_im, Complex.one_im, sub_zero]
  nlinarith

lemma character_multiplier_four {R : Type*} [AddCommGroup R] [Finite R]
    (ψ : AddChar R ℂ) (a : R) : ‖ψ a - 1‖ ^ 2 ≤ 4 := by
  have hb : ‖ψ a - 1‖ ≤ 2 := by
    calc
      _ ≤ ‖ψ a‖ + ‖(1 : ℂ)‖ := norm_sub_le _ _
      _ = 2 := by rw [ψ.norm_apply, norm_one]; norm_num
  nlinarith [norm_nonneg (ψ a - 1)]

lemma average_character_multiplier {R : Type*} [CommRing R] [Fintype R] [DecidableEq R]
    (ψ : AddChar R ℂ) (hψ : ψ.IsPrimitive) (a : R) :
    (∑ x : R, ‖ψ (a * x) - 1‖ ^ 2) / (Fintype.card R : ℝ) =
      if a = 0 then 0 else 2 := by
  by_cases ha : a = 0
  · simp [ha]
  have hs : ∑ x : R, ψ (a * x) = 0 := by
    simpa only [ha, ite_false, Nat.cast_zero, mul_comm] using AddChar.sum_mulShift a hψ
  have hr : ∑ x : R, (ψ (a * x)).re = 0 := by rw [← Complex.re_sum, hs]; rfl
  simp_rw [norm_sub_one_sq_of_norm_one _ (ψ.norm_apply _)]
  rw [sum_sub_distrib, ← mul_sum, hr, mul_zero, sub_zero]
  simp only [sum_const, card_univ, nsmul_eq_mul, ha, ite_false]
  field_simp

lemma std_character_pow (p : ℕ) [NeZero p] (a : ZMod p) :
    (ZMod.stdAddChar a) ^ p = 1 := by
  rw [← AddChar.map_nsmul_eq_pow, nsmul_eq_mul]
  simp

end EditFourier

namespace EditFourier
open scoped BigOperators
open Finset

section PrimeProduct
variable {J : Type*} [Fintype J] [DecidableEq J]
variable (p : J → ℕ) [∀ j, NeZero (p j)]

theorem multiplier_comparison
    (hcop : Pairwise (fun i j => (p i).Coprime (p j)))
    (B : ℝ) (hB : 1 ≤ B) (hpB : ∀ j, (p j : ℝ) ≤ B)
    (h : ℕ) (hh : 0 < h) (lam : ∀ j, ZMod (p j)) (i : J) (u : ZMod (p i)) :
    ‖ZMod.stdAddChar (lam i * u) - 1‖ ^ 2 ≤
      B ^ (2 * h) * ‖torusCharacter p lam - 1‖ ^ 2 +
        (2 / (h : ℝ)) * ∑ j, (if lam j = 0 then (0 : ℝ) else 2) := by
  have hSim : 0 ≤ B ^ (2 * h) * ‖torusCharacter p lam - 1‖ ^ 2 := by positivity
  have hCoord : 0 ≤ (2 / (h : ℝ)) * ∑ j, (if lam j = 0 then (0 : ℝ) else 2) := by
    apply mul_nonneg (by positivity)
    apply sum_nonneg
    intro j _
    split_ifs <;> norm_num
  by_cases hi : lam i = 0
  · simpa only [hi, zero_mul, AddChar.map_zero_eq_one, sub_self, norm_zero, zero_pow
      (by omega : 2 ≠ 0)] using add_nonneg hSim hCoord
  have hleft := character_multiplier_four (ZMod.stdAddChar (N := p i)) (lam i * u)
  let s : Finset J := univ.filter (fun j => lam j ≠ 0)
  have his : i ∈ s := by simp [s, hi]
  by_cases hs : s.card < h
  · have hroot := coprime_root_separation s p (fun j => ZMod.stdAddChar (lam j))
      (fun j _ => NeZero.pos (p j))
      (fun _ _ _ _ hij => hcop hij)
      (fun j _ => std_character_pow (p j) (lam j))
      (fun j _ => (ZMod.stdAddChar (N := p j)).norm_apply (lam j)) i his
      (by
        intro heq
        apply hi
        exact ZMod.injective_stdAddChar (heq.trans (AddChar.map_zero_eq_one _).symm))
    have heq : (∏ j ∈ s, ZMod.stdAddChar (lam j)) = torusCharacter p lam := by
      change (∏ j ∈ s, ZMod.stdAddChar (lam j)) = ∏ j, ZMod.stdAddChar (lam j)
      apply prod_subset (filter_subset _ _)
      intro j _ hj
      have hjz : lam j = 0 := by simpa [s] using hj
      simp [hjz]
    rw [heq] at hroot
    have hprod : ((∏ j ∈ s, p j : ℕ) : ℝ) ≤ B ^ h := by
      calc
        _ = ∏ j ∈ s, (p j : ℝ) := by norm_cast
        _ ≤ ∏ _j ∈ s, B := prod_le_prod₀ (fun _ _ => Nat.cast_nonneg _) (fun j _ => hpB j)
        _ = B ^ s.card := by rw [prod_const]
        _ ≤ B ^ h := pow_le_pow_right₀ hB hs.le
    have htwo : 2 ≤ B ^ h * ‖torusCharacter p lam - 1‖ :=
      hroot.trans (mul_le_mul_of_nonneg_right hprod (norm_nonneg _))
    have hfour : 4 ≤ B ^ (2 * h) * ‖torusCharacter p lam - 1‖ ^ 2 := by
      have hsq : 4 ≤ (B ^ h * ‖torusCharacter p lam - 1‖) ^ 2 := by nlinarith
      simpa only [mul_pow, ← pow_mul, Nat.mul_comm h 2] using hsq
    linarith
  · have hcard : (h : ℝ) ≤ s.card := by exact_mod_cast Nat.le_of_not_gt hs
    have hsum : (∑ j, (if lam j = 0 then (0 : ℝ) else 2)) = (s.card : ℝ) * 2 := by
      calc
        _ = ∑ _j ∈ s, (2 : ℝ) := by simp only [s, sum_filter, ite_not]
        _ = _ := by simp
    rw [hsum]
    have hfour : 4 ≤ 2 / (h : ℝ) * ((s.card : ℝ) * 2) := by
      rw [div_mul_eq_mul_div, le_div_iff₀ (Nat.cast_pos.mpr hh)]
      linarith
    linarith

end PrimeProduct
end EditFourier

end OAI