| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! |
| # Finite Fourier inversion, Parseval, and character displacement |
| -/ |
|
|
| namespace EditFourier |
| open scoped BigOperators |
| open Finset |
|
|
| section FiniteRing |
| variable {R : Type*} [CommRing R] [Fintype R] [DecidableEq R] |
|
|
| noncomputable def transform (ψ : AddChar R ℂ) (F : R → ℂ) (k : R) : ℂ := |
| ∑ t : R, ψ (-(t * k)) * F t |
|
|
| theorem transform_twice (ψ : AddChar R ℂ) (hψ : ψ.IsPrimitive) (F : R → ℂ) : |
| transform ψ (transform ψ F) = fun j => (Fintype.card R : ℂ) * F (-j) := by |
| funext j |
| simp only [transform, mul_sum, ← mul_assoc, ← AddChar.map_add_eq_mul, ← neg_add, |
| mul_comm _ j, ← add_mul] |
| rw [sum_comm] |
| simp only [← sum_mul, ← neg_mul] |
| have h1 (t : R) : ∑ i, ψ (t * i) = if t = 0 then (Fintype.card R : ℂ) else 0 := by |
| simpa only [mul_comm, Nat.cast_ite, Nat.cast_zero] using AddChar.sum_mulShift t hψ |
| have h2 (x j : R) : -(j + x) = 0 ↔ x = -j := by |
| rw [neg_add, add_comm, add_eq_zero_iff_neg_eq, neg_neg] |
| simp only [h1, h2, ite_mul, zero_mul, sum_ite_eq', mem_univ, ite_true] |
|
|
| omit [DecidableEq R] in |
| theorem transform_sub (ψ : AddChar R ℂ) (F G : R → ℂ) : |
| transform ψ (F - G) = transform ψ F - transform ψ G := by |
| funext k |
| simp only [transform, Pi.sub_apply, mul_sub, sum_sub_distrib] |
|
|
| omit [DecidableEq R] in |
| theorem transform_shift (ψ : AddChar R ℂ) (F : R → ℂ) (l k : R) : |
| transform ψ (fun t => F (t + l)) k = ψ (l * k) * transform ψ F k := by |
| classical |
| calc |
| _ = ∑ t : R, ψ (-((t - l) * k)) * F t := by |
| apply Fintype.sum_equiv (Equiv.addRight l) |
| intro t |
| simp |
| _ = ψ (l * k) * transform ψ F k := by |
| rw [transform, mul_sum] |
| apply sum_congr rfl |
| intro t _ |
| rw [sub_mul, neg_sub, sub_eq_add_neg, AddChar.map_add_eq_mul] |
| ring |
|
|
| omit [DecidableEq R] in |
| theorem transform_pairing (ψ : AddChar R ℂ) (F G : R → ℂ) : |
| ∑ k, transform ψ F k * G k = ∑ t, F t * transform ψ G t := by |
| simp only [transform, sum_mul, mul_sum] |
| rw [sum_comm] |
| apply sum_congr rfl |
| intro t _ |
| apply sum_congr rfl |
| intro k _ |
| rw [mul_comm k t] |
| ring |
|
|
| omit [DecidableEq R] in |
| theorem transform_conj (ψ : AddChar R ℂ) (F : R → ℂ) (k : R) : |
| transform ψ (fun t => (starRingEnd ℂ) (F t)) k = |
| (starRingEnd ℂ) (transform ψ F (-k)) := by |
| simp only [transform, map_sum, map_mul] |
| apply sum_congr rfl |
| intro t _ |
| rw [← AddChar.map_neg_eq_conj] |
| congr 2 |
| ring |
|
|
| theorem parseval (ψ : AddChar R ℂ) (hψ : ψ.IsPrimitive) (F : R → ℂ) : |
| ∑ k, ‖transform ψ F k‖ ^ 2 = (Fintype.card R : ℝ) * ∑ t, ‖F t‖ ^ 2 := by |
| simp only [← Complex.normSq_eq_norm_sq] |
| apply Complex.ofReal_injective |
| push_cast |
| simp only [← Complex.mul_conj] |
| rw [transform_pairing] |
| simp only [transform_conj, transform_twice ψ hψ F, neg_neg, map_mul, |
| map_natCast, Finset.mul_sum] |
| apply sum_congr rfl |
| intro t _ |
| ring |
|
|
| theorem displacement (ψ : AddChar R ℂ) (hψ : ψ.IsPrimitive) (F : R → ℂ) (l : R) : |
| (Fintype.card R : ℝ) * ∑ t, ‖F (t + l) - F t‖ ^ 2 = |
| ∑ k, ‖transform ψ F k‖ ^ 2 * ‖ψ (l * k) - 1‖ ^ 2 := by |
| rw [← parseval ψ hψ (fun t => F (t + l) - F t)] |
| have ht : transform ψ (fun t => F (t + l) - F t) = |
| fun k => (ψ (l * k) - 1) * transform ψ F k := by |
| rw [show (fun t => F (t + l) - F t) = (fun t => F (t + l)) - F from rfl, |
| transform_sub] |
| funext k |
| simp only [Pi.sub_apply, transform_shift] |
| ring |
| rw [ht] |
| apply sum_congr rfl |
| intro k _ |
| rw [norm_mul, mul_pow, mul_comm] |
|
|
| noncomputable def fourier (ψ : AddChar R ℂ) (F : R → ℂ) (k : R) : ℂ := |
| transform ψ F k / (Fintype.card R : ℂ) |
|
|
| theorem displacement_normalized (ψ : AddChar R ℂ) (hψ : ψ.IsPrimitive) |
| (F : R → ℂ) (l : R) : |
| (∑ t, ‖F (t + l) - F t‖ ^ 2) / (Fintype.card R : ℝ) = |
| ∑ k, ‖fourier ψ F k‖ ^ 2 * ‖ψ (l * k) - 1‖ ^ 2 := by |
| have hn : (Fintype.card R : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr Fintype.card_ne_zero |
| simp only [fourier, norm_div, Complex.norm_natCast, div_pow, div_mul_eq_mul_div, |
| ← sum_div] |
| apply (eq_div_iff (pow_ne_zero 2 hn)).mpr |
| rw [← displacement ψ hψ F l] |
| field_simp |
|
|
| end FiniteRing |
|
|
| section ProductCharacter |
| variable {J : Type*} [Fintype J] [DecidableEq J] |
| variable {A : J → Type*} [∀ j, CommRing (A j)] |
|
|
| noncomputable def productCharacter (ψ : ∀ j, AddChar (A j) ℂ) : |
| AddChar (∀ j, A j) ℂ where |
| toFun x := ∏ j, ψ j (x j) |
| map_zero_eq_one' := by simp |
| map_add_eq_mul' x y := by simp [AddChar.map_add_eq_mul, prod_mul_distrib] |
|
|
| theorem productCharacter_single (ψ : ∀ j, AddChar (A j) ℂ) |
| (a : ∀ j, A j) (j : J) (x : A j) : |
| (productCharacter ψ) (a * Pi.single j x) = ψ j (a j * x) := by |
| change ∏ i, ψ i (a i * Pi.single j x i) = _ |
| rw [prod_eq_single j] |
| · simp |
| · intro i _ hi |
| simp [Pi.single_eq_of_ne hi] |
| · simp |
|
|
| theorem productCharacter_primitive (ψ : ∀ j, AddChar (A j) ℂ) |
| (hψ : ∀ j, (ψ j).IsPrimitive) : (productCharacter ψ).IsPrimitive := by |
| intro a ha h |
| apply ha |
| funext j |
| by_contra hj |
| apply hψ j hj |
| ext x |
| have hx := DFunLike.congr_fun h (Pi.single j x) |
| simpa only [AddChar.mulShift_apply, productCharacter_single, AddChar.one_apply] using hx |
|
|
| noncomputable def torusCharacter (p : J → ℕ) [∀ j, NeZero (p j)] : |
| AddChar (∀ j, ZMod (p j)) ℂ := |
| productCharacter (fun j => ZMod.stdAddChar (N := p j)) |
|
|
| theorem torusCharacter_primitive (p : J → ℕ) [∀ j, NeZero (p j)] : |
| (torusCharacter p).IsPrimitive := |
| productCharacter_primitive _ (fun j => ZMod.isPrimitive_stdAddChar (p j)) |
|
|
| end ProductCharacter |
| end EditFourier |
|
|
| namespace EditFourier |
| open scoped BigOperators |
| open Finset |
|
|
| theorem norm_pow_sub_one_le (z : ℂ) (hz : ‖z‖ = 1) (n : ℕ) : |
| ‖z ^ n - 1‖ ≤ (n : ℝ) * ‖z - 1‖ := by |
| induction n with |
| | zero => simp |
| | succ n ih => |
| calc |
| ‖z ^ (n + 1) - 1‖ = ‖z * (z ^ n - 1) + (z - 1)‖ := by |
| congr 1 |
| rw [pow_succ'] |
| ring |
| _ ≤ ‖z * (z ^ n - 1)‖ + ‖z - 1‖ := norm_add_le _ _ |
| _ = ‖z ^ n - 1‖ + ‖z - 1‖ := by rw [norm_mul, hz, one_mul] |
| _ ≤ (n : ℝ) * ‖z - 1‖ + ‖z - 1‖ := add_le_add ih le_rfl |
| _ = ((n + 1 : ℕ) : ℝ) * ‖z - 1‖ := by push_cast; ring |
|
|
| theorem root_separation (z : ℂ) (hz : ‖z‖ = 1) (hne : z ≠ 1) |
| (q : ℕ) (hq : 0 < q) (hpow : z ^ q = 1) : |
| 2 ≤ (q : ℝ) * ‖z - 1‖ := by |
| have hs : ∑ i ∈ range q, z ^ i = 0 := by |
| apply eq_zero_of_ne_zero_of_mul_left_eq_zero (sub_ne_zero.mpr hne.symm) |
| rw [mul_neg_geom_sum, hpow, sub_self] |
| have heq : (q : ℝ) = ‖∑ i ∈ range q, (1 - z ^ i)‖ := by |
| simp [sum_sub_distrib, hs] |
| have hbound : (q : ℝ) ≤ (∑ i ∈ range q, (i : ℝ)) * ‖z - 1‖ := by |
| rw [heq] |
| calc |
| _ ≤ ∑ i ∈ range q, ‖1 - z ^ i‖ := norm_sum_le _ _ |
| _ ≤ ∑ i ∈ range q, (i : ℝ) * ‖z - 1‖ := by |
| apply sum_le_sum |
| intro i _ |
| rw [norm_sub_rev] |
| exact norm_pow_sub_one_le z hz i |
| _ = _ := by rw [sum_mul] |
| have hid : (∑ i ∈ range q, (i : ℝ)) * 2 = (q : ℝ) * ((q : ℝ) - 1) := by |
| have ht := congrArg (fun a : ℕ => (a : ℝ)) (sum_range_id_mul_two q) |
| push_cast [Nat.cast_sub (Nat.succ_le_of_lt hq)] at ht |
| exact ht |
| have hnn := norm_nonneg (z - 1) |
| have hm := congrArg (fun x : ℝ => x * ‖z - 1‖) hid |
| have hp : (0 : ℝ) < q := Nat.cast_pos.mpr hq |
| have hh : (q : ℝ) * 2 ≤ (q : ℝ) * ((q : ℝ) * ‖z - 1‖) := by |
| nlinarith |
| exact (mul_le_mul_iff_right₀ hp).mp hh |
|
|
| end EditFourier |
|
|
| end OAI |
|
|
