| import OAI.Computability.FourierCircuit.MatrixRelabel |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Layered |
| variable {α β γ σ : Type} [Fintype α] [Fintype β] [Fintype γ] [Fintype σ] |
| [DecidableEq α] [DecidableEq β] [DecidableEq γ] [DecidableEq σ] |
| |
| theorem stable_rect_add {G H : Matrix α β ℂ} {d e : ℕ} |
| (hG : Layered (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix σ σ ℂ)) d) |
| (hH : Layered (Matrix.fromBlocks (rectangularShear H) 0 0 (1 : Matrix σ σ ℂ)) e) : |
| Layered (Matrix.fromBlocks (rectangularShear (G+H)) 0 0 (1 : Matrix σ σ ℂ)) (d+e) := by |
| have h := hG.mul hH |
| simpa [Matrix.fromBlocks_multiply,rectangularShear_mul] using h |
|
|
| theorem stable_rect_transpose {G : Matrix α β ℂ} {d : ℕ} |
| (hG : Layered (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix σ σ ℂ)) d) : |
| Layered (Matrix.fromBlocks (rectangularShear G.transpose) 0 0 (1 : Matrix σ σ ℂ)) d := by |
| have h := hG.transpose.reindex ((Equiv.sumComm α β).sumCongr (Equiv.refl σ)) |
| have he : Matrix.reindex ((Equiv.sumComm α β).sumCongr (Equiv.refl σ)) |
| ((Equiv.sumComm α β).sumCongr (Equiv.refl σ)) |
| (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix σ σ ℂ)).transpose= |
| Matrix.fromBlocks (rectangularShear G.transpose) 0 0 (1 : Matrix σ σ ℂ) := by |
| ext i j |
| rcases i with (i|i)|i <;> rcases j with (j|j)|j <;> |
| simp [rectangularShear,Matrix.reindex_apply,Matrix.one_apply,eq_comm] |
| rw [he] at h |
| exact h |
| |
| def splitRowsLeft : ((α⊕γ)⊕(β⊕σ))≃(((α⊕β)⊕γ)⊕σ) where |
| toFun := fun x=>match x with |
| | .inl (.inl a)=>.inl (.inl (.inl a)) |
| | .inl (.inr c)=>.inl (.inr c) |
| | .inr (.inl b)=>.inl (.inl (.inr b)) |
| | .inr (.inr s)=>.inr s |
| invFun := fun x=>match x with |
| | .inl (.inl (.inl a))=>.inl (.inl a) |
| | .inl (.inl (.inr b))=>.inr (.inl b) |
| | .inl (.inr c)=>.inl (.inr c) |
| | .inr s=>.inr (.inr s) |
| left_inv := by rintro ((a|c)|(b|s)) <;> rfl |
| right_inv := by rintro (((a|b)|c)|s) <;> rfl |
| |
| def splitRowsRight : ((β⊕γ)⊕(α⊕σ))≃(((α⊕β)⊕γ)⊕σ) := |
| (splitRowsLeft (α := β) (β := α) (γ := γ) (σ := σ)).trans |
| (((Equiv.sumComm β α).sumCongr (Equiv.refl γ)).sumCongr (Equiv.refl σ)) |
|
|
| theorem split_rows_left_matrix |
| {α : Type} {β : Type} {γ : Type} {σ : Type} [Fintype α] [Fintype β] [Fintype γ] [Fintype σ] [DecidableEq α] [DecidableEq β] [DecidableEq γ] [DecidableEq σ] (G : Matrix α γ ℂ) : |
| Matrix.reindex (splitRowsLeft (β := β) (σ := σ)) (splitRowsLeft (β := β) (σ := σ)) |
| (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix (β⊕σ) (β⊕σ) ℂ))= |
| Matrix.fromBlocks (rectangularShear (Matrix.fromRows G (0 : Matrix β γ ℂ))) 0 0 (1 : Matrix σ σ ℂ) := by |
| ext i j |
| rcases i with ((i|i)|i)|i <;> rcases j with ((j|j)|j)|j <;> |
| simp [rectangularShear,Matrix.reindex_apply,Matrix.one_apply,splitRowsLeft] |
| |
| theorem split_rows_right_matrix |
| {α : Type} {β : Type} {γ : Type} {σ : Type} [Fintype α] [Fintype β] [Fintype γ] [Fintype σ] [DecidableEq α] [DecidableEq β] [DecidableEq γ] [DecidableEq σ] (H : Matrix β γ ℂ) : |
| Matrix.reindex (splitRowsRight (α := α) (σ := σ)) (splitRowsRight (α := α) (σ := σ)) |
| (Matrix.fromBlocks (rectangularShear H) 0 0 (1 : Matrix (α⊕σ) (α⊕σ) ℂ))= |
| Matrix.fromBlocks (rectangularShear (Matrix.fromRows (0 : Matrix α γ ℂ) H)) 0 0 (1 : Matrix σ σ ℂ) := by |
| ext i j |
| rcases i with ((i|i)|i)|i <;> rcases j with ((j|j)|j)|j <;> |
| simp [rectangularShear,Matrix.reindex_apply,Matrix.one_apply,splitRowsLeft,splitRowsRight] |
| |
| theorem stable_rect_split_rows {G : Matrix α γ ℂ} {H : Matrix β γ ℂ} {d e : ℕ} |
| (hG : Layered (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix (β⊕σ) (β⊕σ) ℂ)) d) |
| (hH : Layered (Matrix.fromBlocks (rectangularShear H) 0 0 (1 : Matrix (α⊕σ) (α⊕σ) ℂ)) e) : |
| Layered (Matrix.fromBlocks (rectangularShear (Matrix.fromRows G H)) 0 0 (1 : Matrix σ σ ℂ)) (d+e) := by |
| have h1 := hG.reindex (splitRowsLeft (β := β) (σ := σ)) |
| have h2 := hH.reindex (splitRowsRight (α := α) (σ := σ)) |
| rw [split_rows_left_matrix] at h1 |
| rw [split_rows_right_matrix] at h2 |
| have h := h1.stable_rect_add h2 |
| have he : Matrix.fromRows G (0 : Matrix β γ ℂ)+Matrix.fromRows (0 : Matrix α γ ℂ) H= |
| Matrix.fromRows G H := by ext i j; cases i <;> simp |
| rw [he] at h |
| exact h |
| end ExactFourier.Layered |
| |
| end |
| end |
| |
| section |
| noncomputable section |
| namespace ExactFourier.Layered |
| variable {α β σ τ α' β' σ' : Type} [Fintype α] [Fintype β] [Fintype σ] [Fintype τ] |
| [Fintype α'] [Fintype β'] [Fintype σ'] |
| [DecidableEq α] [DecidableEq β] [DecidableEq σ] [DecidableEq τ] |
| [DecidableEq α'] [DecidableEq β'] [DecidableEq σ'] |
|
|
| theorem stable_reindex {G : Matrix α β ℂ} {d : ℕ} |
| (h : Layered (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix σ σ ℂ)) d) |
| (e : α≃α') (f : β≃β') (g : σ≃σ') : |
| Layered (Matrix.fromBlocks (rectangularShear (Matrix.reindex e f G)) 0 0 (1 : Matrix σ' σ' ℂ)) d := by |
| have hh := h.reindex ((e.sumCongr f).sumCongr g) |
| have he : Matrix.reindex ((e.sumCongr f).sumCongr g) ((e.sumCongr f).sumCongr g) |
| (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix σ σ ℂ))= |
| Matrix.fromBlocks (rectangularShear (Matrix.reindex e f G)) 0 0 (1 : Matrix σ' σ' ℂ) := by |
| ext i j |
| rcases i with (i|i)|i <;> rcases j with (j|j)|j <;> |
| simp [rectangularShear,Matrix.reindex_apply,Matrix.one_apply] |
| rw [he] at hh |
| exact hh |
| |
| theorem stable_extra {G : Matrix α β ℂ} {d : ℕ} |
| (h : Layered (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix σ σ ℂ)) d) : |
| Layered (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix (σ⊕τ) (σ⊕τ) ℂ)) d := by |
| have hh := (h.sum (identity.weaken (Nat.zero_le d))).reindex (Equiv.sumAssoc (α⊕β) σ τ) |
| have he : Matrix.reindex (Equiv.sumAssoc (α⊕β) σ τ) (Equiv.sumAssoc (α⊕β) σ τ) |
| (Matrix.fromBlocks (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix σ σ ℂ)) 0 0 |
| (1 : Matrix τ τ ℂ))=Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix (σ⊕τ) (σ⊕τ) ℂ) := by |
| ext i j |
| rcases i with i|i|i <;> rcases j with j|j|j <;> |
| simp [Matrix.reindex_apply,Matrix.one_apply] |
| rw [he] at hh |
| exact hh |
| |
| theorem stable_scratch_mono {G : Matrix α β ℂ} {d s t : ℕ} |
| (h : Layered (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix (Fin s) (Fin s) ℂ)) d) |
| (hst : s≤t) : |
| Layered (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix (Fin t) (Fin t) ℂ)) d := by |
| have hh := (h.stable_extra (τ := Fin (t-s))).stable_reindex (Equiv.refl α) (Equiv.refl β) |
| (finSumFinEquiv.trans (finCongr (Nat.add_sub_of_le hst))) |
| simpa using hh |
|
|
| theorem stable_zero {G : Matrix α β ℂ} {d : ℕ} |
| (h : Layered (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix (Fin 0) (Fin 0) ℂ)) d) : |
| Layered (rectangularShear G) d := by |
| have hh := h.reindex (Equiv.sumEmpty (α⊕β) (Fin 0)) |
| have he : Matrix.reindex (Equiv.sumEmpty (α⊕β) (Fin 0)) (Equiv.sumEmpty (α⊕β) (Fin 0)) |
| (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix (Fin 0) (Fin 0) ℂ))=rectangularShear G := by |
| ext i j; rfl |
| rw [he] at hh |
| exact hh |
| |
| theorem stable_empty_rows (G : Matrix (Fin 0) β ℂ) (d : ℕ) : |
| Layered (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix σ σ ℂ)) d := by |
| have he : Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix σ σ ℂ)=1 := by |
| ext i j |
| rcases i with (i|i)|i <;> rcases j with (j|j)|j <;> |
| simp [rectangularShear,Matrix.one_apply] ; exact Fin.elim0 ‹Fin 0› |
| rw [he] |
| exact identity.weaken (Nat.zero_le d) |
| |
| theorem stable_empty_cols (G : Matrix α (Fin 0) ℂ) (d : ℕ) : |
| Layered (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix σ σ ℂ)) d := by |
| exact (stable_empty_rows G.transpose d (σ := σ)).stable_rect_transpose |
|
|
| theorem stable_rows_nat {a b e s d f : ℕ} (M : ℕ→ℕ→ℂ) |
| (hG : Layered (Matrix.fromBlocks (rectangularShear (fun i : Fin a=>fun j : Fin e=>M i.val j.val)) |
| 0 0 (1 : Matrix (Fin (b+s)) (Fin (b+s)) ℂ)) d) |
| (hH : Layered (Matrix.fromBlocks (rectangularShear (fun i : Fin b=>fun j : Fin e=>M (a+i.val) j.val)) |
| 0 0 (1 : Matrix (Fin (a+s)) (Fin (a+s)) ℂ)) f) : |
| Layered (Matrix.fromBlocks (rectangularShear (fun i : Fin (a+b)=>fun j : Fin e=>M i.val j.val)) |
| 0 0 (1 : Matrix (Fin s) (Fin s) ℂ)) (d+f) := by |
| have h1 := hG.stable_reindex (Equiv.refl _) (Equiv.refl _) finSumFinEquiv.symm |
| have h2 := hH.stable_reindex (Equiv.refl _) (Equiv.refl _) finSumFinEquiv.symm |
| change Layered (Matrix.fromBlocks (rectangularShear (fun i : Fin a=>fun j : Fin e=>M i.val j.val)) |
| 0 0 (1 : Matrix (Fin b⊕Fin s) (Fin b⊕Fin s) ℂ)) d at h1 |
| change Layered (Matrix.fromBlocks (rectangularShear (fun i : Fin b=>fun j : Fin e=>M (a+i.val) j.val)) |
| 0 0 (1 : Matrix (Fin a⊕Fin s) (Fin a⊕Fin s) ℂ)) f at h2 |
| have hh := (h1.stable_rect_split_rows h2).stable_reindex finSumFinEquiv (Equiv.refl _) (Equiv.refl _) |
| have he : Matrix.reindex finSumFinEquiv (Equiv.refl (Fin e)) |
| (Matrix.fromRows (fun i : Fin a=>fun j : Fin e=>M i.val j.val) |
| (fun i : Fin b=>fun j : Fin e=>M (a+i.val) j.val))= |
| (fun i : Fin (a+b)=>fun j : Fin e=>M i.val j.val) := by |
| ext i j |
| obtain ⟨i,rfl⟩ := finSumFinEquiv.surjective i |
| cases i <;> simp [Matrix.reindex_apply,Matrix.fromRows] |
| rw [he] at hh |
| exact hh |
| end ExactFourier.Layered |
| |
| end |
| end |
| |
| section |
| noncomputable section |
| namespace ExactFourier |
| variable {α β γ : Type} [Fintype α] [Fintype β] [Fintype γ] |
| [DecidableEq α] [DecidableEq β] [DecidableEq γ] |
|
|
| def SumLayered (M : Matrix α α ℂ) (d c : ℕ) : Prop := |
| ∃ L : List (Matrix α α ℂ), L.length≤c ∧ L.sum=M ∧ ∀ N∈L,Layered N d |
|
|
| namespace SumLayered |
| theorem single {M : Matrix α α ℂ} {d : ℕ} (h : Layered M d) : SumLayered M d 1 := by |
| exact ⟨[M],by simp,by simp,by simpa⟩ |
| theorem weaken {M : Matrix α α ℂ} {d e c f : ℕ} (h : SumLayered M d c) |
| (hde : d≤e) (hcf : c≤f) : SumLayered M e f := by |
| obtain ⟨L,hL,he,hd⟩ := h |
| exact ⟨L,hL.trans hcf,he,fun N hn=>(hd N hn).weaken hde⟩ |
| theorem add {M N : Matrix α α ℂ} {d c e : ℕ} (hM : SumLayered M d c) (hN : SumLayered N d e) : |
| SumLayered (M+N) d (c+e) := by |
| obtain ⟨L,hL,rfl,hd⟩ := hM |
| obtain ⟨K,hK,rfl,he⟩ := hN |
| refine ⟨L++K, ?_,by simp,?_⟩ |
| · simpa only [List.length_append] using Nat.add_le_add hL hK |
| · intro M h; rcases List.mem_append.mp h with h|h |
| · exact hd M h |
| · exact he M h |
| theorem transpose {M : Matrix α α ℂ} {d c : ℕ} (hM : SumLayered M d c) : |
| SumLayered M.transpose d c := by |
| obtain ⟨L,hL,rfl,hd⟩ := hM |
| refine ⟨L.map Matrix.transpose,by simpa using hL,?_,?_⟩ |
| · clear hL hd |
| induction L with |
| | nil => simp |
| | cons A L ih => simp [ih,Matrix.transpose_add] |
| · intro M h; obtain ⟨N,hN,rfl⟩:=List.mem_map.mp h |
| exact (hd N hN).transpose |
| theorem mul {M N : Matrix α α ℂ} {d e c f : ℕ} (hM : SumLayered M d c) (hN : SumLayered N e f) : |
| SumLayered (M*N) (d+e) (c*f) := by |
| obtain ⟨L,hL,rfl,hd⟩ := hM |
| obtain ⟨K,hK,rfl,he⟩ := hN |
| let P := L.flatMap (fun A=>K.map (fun B=>A*B)) |
| have hlen : P.length=L.length*K.length := by |
| dsimp [P]; induction L with |
| | nil => simp |
| | cons A L ih => simp [Nat.add_mul,Nat.add_comm] |
| refine ⟨P,hlen.le.trans (Nat.mul_le_mul hL hK),?_,?_⟩ |
| · dsimp [P] |
| clear hL hd hlen P hK he |
| have hm (A : Matrix α α ℂ) : (K.map (fun B=>A*B)).sum=A*K.sum := by |
| induction K with |
| | nil => simp |
| | cons B K ih => simp_all [mul_add] |
| induction L with |
| | nil => simp |
| | cons A L ih => simp [ih,hm,add_mul] |
| · intro M h |
| obtain ⟨A,hA,h⟩:=List.mem_flatMap.mp h |
| obtain ⟨B,hB,rfl⟩:=List.mem_map.mp h |
| exact (hd A hA).mul (he B hB) |
|
|
| theorem diagonal (c : α→ℂ) : SumLayered (Matrix.diagonal c) 1 2 := by |
| classical |
| obtain ⟨lam,hlam⟩ := Infinite.exists_notMem_finset (insert 0 (Finset.univ.image c)) |
| simp only [Finset.mem_insert,not_or] at hlam |
| have h0 : lam≠0 := hlam.1 |
| have hc : ∀ i,c i-lam≠0 := by |
| intro i h; apply hlam.2 |
| exact Finset.mem_image.mpr ⟨i,Finset.mem_univ _,sub_eq_zero.mp h⟩ |
| let A := Matrix.diagonal (fun i=>c i-lam) |
| let B := Matrix.diagonal (fun _ : α=>lam) |
| have he : A+B=Matrix.diagonal c := by ext i j; by_cases h : i=j <;> simp [A,B,h] |
| rw [←he] |
| exact (single (Layered.mono A (MonomialMatrix.diagonal _ hc))).add |
| (single (Layered.mono B (MonomialMatrix.diagonal _ (fun _=>h0)))) |
| |
| theorem submatrix_stable {M : Matrix γ γ ℂ} {d c : ℕ} (hM : SumLayered M d c) |
| (e : α↪γ) (f : β↪γ) : |
| Layered (Matrix.fromBlocks (rectangularShear (M.submatrix e f)) 0 0 (1 : Matrix γ γ ℂ)) (c*(4*d+4)) := by |
| obtain ⟨L,hL,rfl,hd⟩:=hM |
| have hh : ∀ L : List (Matrix γ γ ℂ), (∀ M∈L,Layered M d) → |
| Layered (Matrix.fromBlocks (rectangularShear (L.sum.submatrix e f)) 0 0 (1 : Matrix γ γ ℂ)) (L.length*(4*d+4)) := by |
| intro L h |
| induction L with |
| | nil => |
| simpa [rectangularShear] using (Layered.identity (α := (α⊕β)⊕γ)) |
| | cons M L ih => |
| have hM := (h M (by simp)).rect_submatrix_stable e f |
| have hL := ih (fun N hn=>h N (by simp [hn])) |
| have ht := hM.mul hL |
| have he : Matrix.fromBlocks (rectangularShear (M.submatrix e f)) 0 0 (1 : Matrix γ γ ℂ) * |
| Matrix.fromBlocks (rectangularShear (L.sum.submatrix e f)) 0 0 (1 : Matrix γ γ ℂ)= |
| Matrix.fromBlocks (rectangularShear ((M+L.sum).submatrix e f)) 0 0 (1 : Matrix γ γ ℂ) := by |
| simp [Matrix.fromBlocks_multiply,rectangularShear_mul,Matrix.submatrix_add] |
| rw [he] at ht |
| simpa [Nat.add_mul,Nat.add_comm] using ht |
| exact (hh L hd).weaken (Nat.mul_le_mul_right _ hL) |
| end SumLayered |
| end ExactFourier |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.RadixTwo |
| open Polynomial |
| open scoped BigOperators |
|
|
| def convolutionMatrix (k : ℕ) (f : ℂ[X]) : Matrix (Fin (2^k)) (Fin (2^k)) ℂ := |
| let ω := zeta (2^k) |
| dft (2^k) ω⁻¹ * Matrix.diagonal (fun i=>((2^k : ℕ) : ℂ)⁻¹*f.eval (ω^i.val)) * dft (2^k) ω |
|
|
| theorem convolution_sumLayered (k : ℕ) (f : ℂ[X]) : SumLayered (convolutionMatrix k f) (4*k+1) 2 := by |
| have hω : IsPrimitiveRoot (zeta (2^k)) (2^k) := Complex.isPrimitiveRoot_exp _ (by positivity) |
| have h := ((SumLayered.single (dft_layers k _ hω.inv)).mul |
| (SumLayered.diagonal (fun i : Fin (2^k)=>((2^k : ℕ) : ℂ)⁻¹*f.eval ((zeta (2^k))^i.val)))).mul |
| (SumLayered.single (dft_layers k _ hω)) |
| simpa only [convolutionMatrix,show 2*k+1+2*k=4*k+1 by omega, Nat.one_mul,Nat.mul_one] using h |
|
|
| theorem convolution_mulVec (k : ℕ) (f : ℂ[X]) (x : Fin (2^k)→ℂ) |
| (hx : (f*Polynomial.ofFn (2^k) x).natDegree < 2^k) : |
| (convolutionMatrix k f).mulVec x =fun i=>(f*Polynomial.ofFn (2^k) x).coeff i.val := by |
| have hω : IsPrimitiveRoot (zeta (2^k)) (2^k) := Complex.isPrimitiveRoot_exp _ (by positivity) |
| have h := convolution_formula (by positivity : 0 < 2^k) _ hω f (Polynomial.ofFn (2^k) x) hx |
| change eval (2^k) (zeta (2^k))⁻¹ _ = _ at h |
| dsimp only [convolutionMatrix] |
| rw [←Matrix.mulVec_mulVec,←Matrix.mulVec_mulVec] |
| change eval (2^k) (zeta (2^k))⁻¹ _=_ |
| rw [←h] |
| congr 1 |
| funext i |
| rw [Matrix.mulVec_diagonal] |
| change _*eval (2^k) (zeta (2^k)) x i=_ |
| rw [eval_ofFn] |
|
|
| theorem ofFn_single {n : ℕ} (j : Fin n) : |
| Polynomial.ofFn n (Pi.single j (1 : ℂ))=Polynomial.monomial j.val 1 := by |
| ext i |
| by_cases hi : i < n |
| · rw [Polynomial.ofFn_coeff_eq_val_of_lt _ hi] |
| simp [Polynomial.coeff_monomial,Pi.single_apply,Fin.ext_iff,eq_comm] |
| · rw [Polynomial.ofFn_coeff_eq_zero_of_ge _ (by omega)] |
| have hn : j.val≠i := by have := j.isLt; omega |
| simp [Polynomial.coeff_monomial,hn] |
| |
| theorem convolution_entry (k : ℕ) (f : ℂ[X]) (i j : Fin (2^k)) |
| (hj : f.natDegree+j.val < 2^k) : |
| convolutionMatrix k f i j=if j.val ≤ i.val then f.coeff (i.val-j.val) else 0 := by |
| have hx : (f*Polynomial.ofFn (2^k) (Pi.single j (1 : ℂ))).natDegree < 2^k := by |
| rw [ofFn_single] |
| exact (Polynomial.natDegree_mul_le.trans (Nat.add_le_add_left (Polynomial.natDegree_monomial_le (1 : ℂ)) _)).trans_lt hj |
| have h := congrFun (convolution_mulVec k f (Pi.single j 1) hx) i |
| rw [Matrix.mulVec_single_one,ofFn_single] at h |
| change convolutionMatrix k f i j = _ at h |
| rw [h] |
| rw [Polynomial.monomial_one_right_eq_X_pow,Polynomial.coeff_mul_X_pow'] |
| end ExactFourier.RadixTwo |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier |
| open scoped BigOperators |
|
|
| def initialEmbedding {a n : ℕ} (h : a≤n) : Fin a↪Fin n := |
| ⟨fun i=>⟨i.val,lt_of_lt_of_le i.isLt h⟩,by intro i j he; exact Fin.ext (congrArg (fun x : Fin n=>x.val) he)⟩ |
|
|
| @[simp] theorem initialEmbedding_val {a n : ℕ} (h : a≤n) (i : Fin a) : |
| (initialEmbedding h i).val=i.val := rfl |
|
|
| theorem sum_initial {a n : ℕ} (h : a≤n) (f : Fin n→ℂ) : |
| (∑i : Fin n,if i.val<a then f i else 0)=∑i : Fin a,f (initialEmbedding h i) := by |
| classical |
| let e:=initialEmbedding h |
| have hi : Function.Injective e:=e.injective |
| have hr : ∀ j : Fin n,j∈Finset.univ.image e ↔ j.val<a := by |
| intro j |
| constructor |
| · intro hj; obtain ⟨i,_,rfl⟩:=Finset.mem_image.mp hj; exact i.isLt |
| · intro hj; exact Finset.mem_image.mpr ⟨⟨j.val,hj⟩,Finset.mem_univ _,rfl⟩ |
| rw [←Finset.sum_image (fun i _ j _ he=>hi he)] |
| rw [←Finset.sum_subset (Finset.subset_univ (Finset.univ.image e))] |
| · apply Finset.sum_congr rfl |
| intro j hj |
| rw [ite_eq_left ((hr j).mp hj)] |
| · intro j hj hn |
| rw [ite_eq_right (mt ((hr j).mpr) hn)] |
| |
| theorem compress_product {a b e n : ℕ} (ha : a≤n) (hb : b≤n) (he : e≤n) |
| (M N : Matrix (Fin n) (Fin n) ℂ) : |
| (M * Matrix.diagonal (fun i : Fin n=>if i.val<e then (1 : ℂ) else 0) * N).submatrix |
| (initialEmbedding ha) (initialEmbedding hb)= |
| (M.submatrix (initialEmbedding ha) (initialEmbedding he)) * |
| (N.submatrix (initialEmbedding he) (initialEmbedding hb)) := by |
| ext i j |
| rw [Matrix.submatrix_apply,Matrix.mul_apply] |
| simp only [Matrix.mul_diagonal] |
| have h := sum_initial he (fun l=>M (initialEmbedding ha i) l*N l (initialEmbedding hb j)) |
| simpa [Matrix.mul_apply,Matrix.submatrix_apply,ite_mul,mul_ite] using h |
| end ExactFourier |
|
|
| end |
| end |
|
|
| end OAI |
|
|
