| import OAI.Computability.FourierTransform.Goal |
|
|
| namespace OAI |
|
|
| /- Elementary finite Fourier formulas. |
| Values beyond a given length are irrelevant. Using natural ranges eases index arithmetic. -/ |
| namespace PowerSaving |
| open Complex Matrix Finset |
| noncomputable section |
|
|
| abbrev Line := ℕ → ℂ |
|
|
| namespace Spectral |
|
|
| def freq (n : ℕ) (u : ℂ) (x : Line) : Line := |
| fun i => ∑ j ∈ range n, u ^ (i*j) * x j |
|
|
| def winds (n : ℕ) (u : ℂ) : Matrix (Fin n) (Fin n) ℂ := |
| fun i j => u ^ (i.val*j.val) |
|
|
| def front (n : ℕ) (x : Line) : Vec n := fun i => x i.val |
|
|
| lemma front_freq (n : ℕ) (u : ℂ) (x : Line) : |
| front n (freq n u x) = winds n u *ᵥ front n x := by |
| funext i |
| exact (Fin.sum_univ_eq_sum_range (fun j => u^(i.val*j)*x j) n).symm |
|
|
| lemma root_primitive (n : ℕ) (hn : 0 < n) : IsPrimitiveRoot (root n) n := |
| Complex.isPrimitiveRoot_exp n (by omega) |
|
|
| lemma root_four : root 4 = I := by |
| unfold root ExactFourier.zeta |
| convert! Complex.exp_pi_div_two_mul_I using 2 |
| push_cast |
| ring |
|
|
| lemma root_mul_pow (m n : ℕ) (hm : 0 < m) (hn : 0 < n) : |
| (root (m*n))^m = root n := by |
| unfold root ExactFourier.zeta |
| rw [← exp_nat_mul] |
| have hm' : (m:ℂ) ≠ 0 := Nat.cast_ne_zero.mpr (by omega) |
| have hn' : (n:ℂ) ≠ 0 := Nat.cast_ne_zero.mpr (by omega) |
| congr 1 |
| push_cast |
| field_simp |
|
|
| lemma root_factor {n m : ℕ} (hn : 0<n) (hm : m ∣ n) : |
| (root n)^(n/m)=root m := by |
| have h := Nat.div_mul_cancel hm |
| have h1 : m ≠ 0 := by |
| intro g; simp [g] at h; omega |
| have h2 : n/m ≠ 0 := by |
| intro g; simp [g] at h; omega |
| exact ((congrArg (fun a : ℕ => root a ^ (n/m)) h).symm).trans |
| (root_mul_pow (n/m) m (Nat.pos_of_ne_zero h2) (Nat.pos_of_ne_zero h1)) |
|
|
| lemma power_mod {u : ℂ} {n : ℕ} (hu : u^n=1) (i : ℕ) : |
| u^(i%n)=u^i := by |
| have h := congrArg (fun a : ℕ => u^a) (Nat.mod_add_div i n) |
| simpa [pow_add, pow_mul, hu] using h |
|
|
| lemma norm_of_root {n : ℕ} {u : ℂ} (hn : 0<n) (hu : u^n=1) : |
| ‖u‖=1 := |
| (pow_left_inj₀ (norm_nonneg _) (by norm_num) (by omega : n ≠ 0)).mp (by rw [← norm_pow, |
| hu, norm_one, one_pow]) |
|
|
| lemma conj_of_root {n : ℕ} {u : ℂ} (hn : 0<n) (hu : u^n=1) : |
| (starRingEnd ℂ) u = u⁻¹ := by |
| have h := norm_of_root hn hu |
| have g : normSq u = 1 := by rw [← Complex.sq_norm, h, one_pow] |
| exact (inv_eq_of_mul_eq_one_right (by rw [Complex.mul_conj,g,Complex.ofReal_one])).symm |
|
|
| lemma freq_congr {n : ℕ} {x y : Line} (h : ∀ i < n, x i=y i) (u : ℂ) : |
| freq n u x = freq n u y := by |
| funext j |
| exact sum_congr rfl fun i hi => by rw [h i (mem_range.mp hi)] |
|
|
| lemma freq_add (n : ℕ) (u : ℂ) (x y : Line) : |
| freq n u (x+y) = freq n u x + freq n u y := by |
| ext i; simp [freq, mul_add, sum_add_distrib] |
|
|
| lemma freq_scale (n : ℕ) (u a : ℂ) (x : Line) : |
| freq n u (fun j => a*x j) = fun i => a*freq n u x i := by |
| ext i; simp [freq, mul_left_comm, mul_sum] |
|
|
| lemma freq_period {n : ℕ} {u : ℂ} (hu : u^n=1) (x : Line) (i : ℕ) : |
| freq n u x (n+i) = freq n u x i := by |
| simp only [freq, add_mul,pow_add,pow_mul,hu,one_pow,one_mul] |
|
|
| |
| lemma orth {n : ℕ} {u : ℂ} (hu : IsPrimitiveRoot u n) (i j : ℕ) |
| (hi : i<n) (hj : j<n) : |
| (∑ l ∈ range n, u⁻¹ ^ (i*l) * u ^ (l*j)) = |
| if i=j then (n:ℂ) else 0 := by |
| have hz : u ≠ 0 := hu.ne_zero (by omega) |
| have form (l : ℕ) : |
| u⁻¹ ^ (i*l) * u ^ (l*j)=(u^j/u^i)^l := by |
| rw [Nat.mul_comm l j] |
| simp only [pow_mul, div_pow, inv_pow] |
| ring |
| simp_rw [form] |
| by_cases h : i=j |
| · simp [h, hz] |
| · rw [ite_eq_right h, geom_sum_eq] |
| · have a (j : ℕ) : (u^j)^n=1 := by rw [← pow_mul, Nat.mul_comm,pow_mul,hu.pow_eq_one,one_pow] |
| rw [div_pow,a,a] |
| norm_num |
| · intro hh |
| exact h (hu.pow_inj hi hj ((div_eq_one_iff_eq (pow_ne_zero _ hz)).mp hh).symm) |
|
|
| lemma freq_back {n : ℕ} {u : ℂ} (hu : IsPrimitiveRoot u n) (x : Line) |
| (i : ℕ) (hi : i<n) : |
| freq n u⁻¹ (freq n u x) i = n * x i := by |
| simp only [freq,mul_sum] |
| rw [sum_comm] |
| simp only [← mul_assoc,← sum_mul] |
| refine Eq.trans (b := ∑ j ∈ range n, (if i=j then (n:ℂ) else 0) * x j) ?_ ?_ |
| · exact sum_congr rfl fun j hj => by rw [orth hu i j hi (mem_range.mp hj)] |
| · simp [ite_mul, hi] |
|
|
| lemma freq_inv {n : ℕ} {u : ℂ} (hu : IsPrimitiveRoot u n) (x : Line) |
| (i : ℕ) (hi : i<n) : |
| (n:ℂ)⁻¹ * freq n u⁻¹ (freq n u x) i = x i := by |
| rw [freq_back hu x i hi, ← mul_assoc, inv_mul_cancel₀,one_mul] |
| exact Nat.cast_ne_zero.mpr (by omega) |
|
|
| |
| def predAt (n i j : ℕ) := if j ≤ i then i-j else i+n-j |
|
|
| lemma pred_lt {n i j : ℕ} (hi : i<n) (hj : j<n) : |
| predAt n i j < n := by unfold predAt; split <;> omega |
|
|
| lemma sum_pred (f : ℕ → ℂ) (n j : ℕ) (hj : j<n) : |
| ∑ i ∈ range n, f (predAt n i j) = ∑ i ∈ range n, f i := by |
| refine sum_bij (fun a _ => predAt n a j) ?_ ?_ ?_ (fun _ _ => rfl) |
| · intro a ha; exact mem_range.mpr (pred_lt (mem_range.mp ha) hj) |
| · simp only [mem_range]; intro a ha b hb h |
| unfold predAt at h |
| split_ifs at h <;> omega |
| · simp only [mem_range]; intro i hi |
| by_cases h : i+j<n |
| · refine ⟨i+j,h,?_⟩ |
| unfold predAt; split <;> omega |
| · refine ⟨i+j-n,by omega,?_⟩ |
| unfold predAt; split <;> omega |
|
|
| lemma pow_pred {n : ℕ} {u : ℂ} (hu : u^n=1) {i j : ℕ} (hj : j<n) (k : ℕ) : |
| u^(k*i)=u^(k*(predAt n i j))*u^(k*j) := by |
| rw [← pow_add,← mul_add] |
| unfold predAt; split |
| case isTrue h => rw [Nat.sub_add_cancel h] |
| case isFalse h => |
| rw [Nat.sub_add_cancel (by omega),mul_add,pow_add,Nat.mul_comm k n, pow_mul u n, hu, one_pow,mul_one] |
|
|
| def cyclic (n : ℕ) (h x : Line) : Line := |
| fun i => ∑ j ∈ range n, h (predAt n i j) * x j |
|
|
| lemma freq_cyclic {n : ℕ} {u : ℂ} (hu : u^n=1) (h x : Line) (k : ℕ) : |
| freq n u (cyclic n h x) k = freq n u h k * freq n u x k := by |
| have form (j : ℕ) (hj : j ∈ range n) : |
| ∑ i ∈ range n, u^(k*i)*(h (predAt n i j) * x j) = freq n u h k * (u^(k*j)*x j) := by |
| unfold freq |
| rw [← sum_pred (fun i => u^(k*i)*h i) n j (mem_range.mp hj),sum_mul] |
| refine sum_congr rfl ?_ |
| intro i hi |
| rw [pow_pred hu (mem_range.mp hj) k] |
| ring |
| unfold freq |
| simp only [cyclic,mul_sum] |
| rw [sum_comm] |
| exact sum_congr rfl form |
|
|
| |
| lemma sum_eo (n : ℕ) (f : ℕ→ℂ) : |
| ∑ i ∈ range (n+n), f i = |
| ∑ i ∈ range n, f (2*i) + ∑ i ∈ range n, f (2*i+1) := by |
| induction n with |
| | zero => simp |
| | succ n ih => |
| rw [show n+1+(n+1)=n+n+1+1 by omega] |
| rw [sum_range_succ, sum_range_succ, ih, sum_range_succ, sum_range_succ] |
| rw [show n+n=2*n by omega]; ring |
|
|
| lemma freq_eo (n : ℕ) (u : ℂ) (i : ℕ) (x : Line) : |
| freq (n+n) u x i = |
| freq n (u^2) (fun j => x (2*j)) i + |
| u^i * freq n (u^2) (fun j => x (2*j+1)) i := by |
| simp only [freq,sum_eo,mul_sum] |
| have A (j : ℕ) : i*(2*j)=2*(i*j) := by ring |
| simp_rw [mul_add,A,pow_add,mul_one,← pow_mul] |
| simp [mul_comm, mul_assoc,mul_left_comm] |
|
|
| lemma even_prim {n : ℕ} {u : ℂ} (hu : IsPrimitiveRoot u (n+n)) : |
| IsPrimitiveRoot (u^2) n := by |
| have h := hu.pow_of_dvd (p:=2) (by omega) (by exact ⟨n,by omega⟩) |
| rwa [show (n+n)/2=n by omega] at h |
|
|
| lemma half_power {n : ℕ} {u : ℂ} (hn : 0<n) (hu : IsPrimitiveRoot u (n+n)) : |
| u^n = -1 := by |
| have h : (u^n)^2=(1:ℂ)^2 := by rw [pow_two,← pow_add, hu.pow_eq_one, one_pow] |
| exact (sq_eq_sq_iff_eq_or_eq_neg.mp h).resolve_left (hu.pow_ne_one_of_pos_of_lt |
| (by omega) (by omega)) |
|
|
| lemma freq_eo' {n : ℕ} {u : ℂ} (hn : 0<n) (hu : IsPrimitiveRoot u (n+n)) |
| (i : ℕ) (x : Line) : |
| freq (n+n) u x (n+i) = |
| freq n (u^2) (fun j => x (2*j)) i - |
| u^i * freq n (u^2) (fun j => x (2*j+1)) i := by |
| rw [freq_eo, freq_period (even_prim hu).pow_eq_one, |
| freq_period (even_prim hu).pow_eq_one, pow_add, half_power hn hu] |
| ring |
|
|
| end Spectral |
| end |
| end PowerSaving |
|
|
| end OAI |
|
|
