lean/OAI/Computability/FourierCircuit/MatrixRelabel.lean

import OAI.Computability.FourierCircuit.PairFamilies

namespace OAI

section
namespace ExactFourier
variable {α β γ δ : Type} [Fintype α] [Fintype β] [Fintype γ] [Fintype δ]
theorem reindex_mulVec
    {α : Type} {β : Type} {γ : Type} {δ : Type} [Fintype α] [Fintype β] [Fintype γ] [Fintype δ] (e : β≃δ) (f : α≃γ) (M : Matrix β α ℂ) (x : γ→ℂ) :
 (Matrix.reindex e f M).mulVec x=(M.mulVec (x∘f))∘e.symm := by
 funext i
 simp only [Matrix.mulVec,dotProduct,Matrix.reindex_apply,Matrix.submatrix_apply,Function.comp_apply]
 exact (f.sum_comp (fun j=>M (e.symm i) (f.symm j)*x j)).symm.trans (by simp)
end ExactFourier

end

section
noncomputable section
namespace ExactFourier.RadixTwo

def dft (n : ℕ) (ω : ℂ) : Matrix (Fin n) (Fin n) ℂ := fun i j=>ω^(i.val*j.val)

 def butterfly (n : ℕ) (ω : ℂ) : Matrix (Fin n⊕Fin n) (Fin n⊕Fin n) ℂ :=
 Matrix.fromBlocks 1 (Matrix.diagonal (fun i=>ω^i.val)) 1 (-Matrix.diagonal (fun i=>ω^i.val))

theorem butterfly_layer (n : ℕ) (ω : ℂ) (hω : ω≠0) : Layered (butterfly n ω) 1 := by
 let M := fun i : Fin n=>(!![1,ω^i.val;1,-ω^i.val] : Matrix (Fin 2) (Fin 2) ℂ)
 have hm : ∀ i,IsUnit (M i) := by
  intro i
  apply (Matrix.isUnit_iff_isUnit_det _).mpr
  apply isUnit_iff_ne_zero.mpr
  rw [Matrix.det_fin_two]
  change 1 * (-ω^i.val) - ω^i.val * 1 ≠ 0
  have hh := pow_ne_zero i.val hω
  intro he; apply hh; linear_combination -1/2 * he
 have h := (Layered.blockDiagonal M 1 (fun i=>Layered.pair (M i) (hm i))).reindex (twoProdEquiv (Fin n))
 have he : Matrix.reindex (twoProdEquiv (Fin n)) (twoProdEquiv (Fin n)) (Matrix.blockDiagonal M)=butterfly n ω := by
  ext i j
  cases i <;> cases j <;>
   simp [twoProdEquiv,Matrix.reindex_apply,Matrix.blockDiagonal,M,butterfly,Matrix.one_apply,Matrix.diagonal_apply]
 rw [he] at h
 exact h

def paritySumEquiv (n : ℕ) : (Fin n⊕Fin n)≃Fin (n+n) :=
 ((twoProdEquiv (Fin n)).symm.trans (Equiv.prodComm _ _)).trans (parityEquiv n)

@[simp] theorem paritySumEquiv_inl (n : ℕ) (i : Fin n) : paritySumEquiv n (.inl i)=evenIndex n i := by
 apply Fin.ext; simp [paritySumEquiv,twoProdEquiv,parityEquiv,evenIndex]
@[simp] theorem paritySumEquiv_inr (n : ℕ) (i : Fin n) : paritySumEquiv n (.inr i)=oddIndex n i := by
 apply Fin.ext; simp [paritySumEquiv,twoProdEquiv,parityEquiv,oddIndex]

theorem dft_step (n : ℕ) (ω : ℂ) (hω : ω^n = -1) : dft (n+n) ω=
 Matrix.reindex finSumFinEquiv (paritySumEquiv n)
 (butterfly n ω*Matrix.fromBlocks (dft n (ω^2)) 0 0 (dft n (ω^2))) := by
 apply Matrix.mulVec_injective
 funext x
 rw [reindex_mulVec]
 have he := eval_split n ω hω x
 change eval (n+n) ω x=_
 rw [he]
 rw [← Matrix.mulVec_mulVec]
 funext i
 obtain ⟨i,rfl⟩ := finSumFinEquiv.surjective i
 cases i with
 | inl j =>
  simp only [finSumFinEquiv_apply_left, Fin.addCases_left, Function.comp_apply,
    finSumFinEquiv_symm_apply_castAdd]
  simp [butterfly,dft,eval,evalAt,Matrix.mulVec,dotProduct,Matrix.one_apply,Matrix.diagonal_apply]
 | inr j =>
  simp only [finSumFinEquiv_apply_right, Fin.addCases_right, Function.comp_apply,
    finSumFinEquiv_symm_apply_natAdd]
  simp [butterfly,dft,eval,evalAt,Matrix.mulVec,dotProduct,Matrix.one_apply,Matrix.diagonal_apply, sub_eq_add_neg]

theorem dft_layers (k : ℕ) (ω : ℂ) (hω : IsPrimitiveRoot ω (2^k)) :
 Layered (dft (2^k) ω) (2*k) := by
 induction k generalizing ω with
 | zero =>
  change Layered (dft 1 ω) 0
  have he : dft 1 ω=(1 : Matrix (Fin 1) (Fin 1) ℂ) := by
   ext i j; fin_cases i; fin_cases j
   simp [dft]
  rw [he]
  exact Layered.identity
 | succ k ih =>
  have hs : IsPrimitiveRoot (ω^2) (2^k) :=
   IsPrimitiveRoot.pow (pow_pos (by decide) _) hω (by rw [pow_succ]; omega)
  have hh : ω^(2^k) = -1 :=
   (IsPrimitiveRoot.pow (pow_pos (by decide) _) hω (by rw [pow_succ])).eq_neg_one_of_two_right
  have hF := (ih (ω^2) hs).sum (ih (ω^2) hs)
  have hB := butterfly_layer (2^k) ω (hω.ne_zero (by positivity))
  have h := (hB.mul hF).two_reindex finSumFinEquiv (paritySumEquiv (2^k))
  rw [← dft_step (2^k) ω hh] at h
  have he : 2^(k+1)=2^k+2^k := by rw [pow_succ]; omega
  rw [he]
  simpa only [show 1+2*k+1=2*(k+1) by omega] using h
end ExactFourier.RadixTwo

end
end

section
noncomputable section
namespace ExactFourier.NewtonFourier
open scoped BigOperators
open Polynomial

def newton (ω : ℂ) (k : ℕ) : ℂ[X] := ∏ j∈Finset.range k,(X-C (ω^j))
def H (ω : ℂ) (i : ℕ) : ℂ := ∏ j∈Finset.range i,(1-ω^(j+1))
def scale (ω : ℂ) (k : ℕ) : ℂ := ∏ j∈Finset.range k,(-ω^j)
def N (n : ℕ) (ω : ℂ) : Matrix (Fin n) (Fin n) ℂ := fun i k=>(newton ω k.val).eval (ω^i.val)
def P (n : ℕ) (ω : ℂ) : Matrix (Fin n) (Fin n) ℂ := fun i k=>(newton ω k.val).coeff i.val

@[simp] theorem newton_zero (ω : ℂ) : newton ω 0=1 := by simp [newton]
theorem newton_succ (ω : ℂ) (k : ℕ) : newton ω (k+1)=newton ω k*(X-C (ω^k)) := by
 simp [newton,Finset.prod_range_succ]
@[simp] theorem H_zero (ω : ℂ) : H ω 0=1 := by simp [H]
theorem H_succ (ω : ℂ) (i : ℕ) : H ω (i+1)=H ω i*(1-ω^(i+1)) := by simp [H,Finset.prod_range_succ]
@[simp] theorem scale_zero (ω : ℂ) : scale ω 0=1 := by simp [scale]
theorem scale_succ (ω : ℂ) (k : ℕ) : scale ω (k+1)=scale ω k*(-ω^k) := by simp [scale,Finset.prod_range_succ]

theorem newton_monic (ω : ℂ) (k : ℕ) : (newton ω k).Monic := monic_prod_X_sub_C _ _
@[simp] theorem newton_natDegree (ω : ℂ) (k : ℕ) : (newton ω k).natDegree=k := by
 induction k with
 | zero => simp
 | succ k ih => rw [newton_succ,natDegree_mul (newton_monic ω k).ne_zero (monic_X_sub_C _).ne_zero,ih,natDegree_X_sub_C]

theorem newton_eval_zero (ω : ℂ) (i k : ℕ) (h : i < k) : (newton ω k).eval (ω^i)=0 := by
 simp only [newton,Polynomial.eval_prod,Polynomial.eval_sub,Polynomial.eval_X,Polynomial.eval_C]
 exact Finset.prod_eq_zero (Finset.mem_range.mpr h) (sub_self _)

theorem eval_factor (ω : ℂ) (i k : ℕ) (hki : k ≤ i) :
 (newton ω k).eval (ω^i)*H ω (i-k)=scale ω k*H ω i := by
 induction k with
 | zero => simp
 | succ k ih =>
  have hik : k ≤ i := by omega
  have hs : i-k=(i-(k+1))+1 := by omega
  have hpow : ω^i=ω^k*ω^(i-k) := by rw [← pow_add,Nat.add_sub_of_le hik]
  have hh := ih hik
  rw [hs,H_succ] at hh
  rw [newton_succ,Polynomial.eval_mul,Polynomial.eval_sub,Polynomial.eval_X,Polynomial.eval_C,scale_succ]
  rw [hpow,hs]
  rw [hpow,hs] at hh
  linear_combination (-ω^k)*hh

theorem H_ne_zero {ω : ℂ} {n : ℕ} (hω : IsPrimitiveRoot ω n) {i : ℕ} (hi : i < n) : H ω i ≠ 0 := by
 apply Finset.prod_ne_zero_iff.mpr
 intro j hj
 apply sub_ne_zero.mpr
 exact (hω.pow_ne_one_of_pos_of_lt (by omega : j+1 ≠ 0) (by have := Finset.mem_range.mp hj; omega)).symm

theorem scale_ne_zero {ω : ℂ} (hω : ω ≠ 0) (k : ℕ) : scale ω k ≠ 0 := by
 apply Finset.prod_ne_zero_iff.mpr
 intro j hj
 exact neg_ne_zero.mpr (pow_ne_zero j hω)

theorem N_lower (n : ℕ) (ω : ℂ) : (N n ω).IsLowerTriangular := by
 intro i j hij
 exact newton_eval_zero ω i.val j.val hij

theorem P_upper (n : ℕ) (ω : ℂ) : (P n ω).IsUpperTriangular := by
 intro i j hij
 exact coeff_eq_zero_of_natDegree_lt (by simpa using hij)

theorem dft_mul_P (n : ℕ) (ω : ℂ) : RadixTwo.dft n ω * P n ω=N n ω := by
 have hh := Matrix.eval_matrixOfPolynomials_eq_vandermonde_mul_matrixOfPolynomials
  (fun i : Fin n=>ω^i.val) (fun k : Fin n=>newton ω k.val) (fun k=>by simp)
 have he : Matrix.vandermonde (fun i : Fin n=>ω^i.val)=RadixTwo.dft n ω := by
  ext i j; simp [Matrix.vandermonde,RadixTwo.dft,pow_mul]
 rw [he] at hh
 exact hh.symm
end ExactFourier.NewtonFourier

end
end

section
noncomputable section
namespace ExactFourier.Layered
variable {α β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β]

theorem inverse {M : Matrix α α ℂ} {d : ℕ} (h : Layered M d) : Layered M⁻¹ d := by
 induction h with
 | identity => simpa using (Layered.identity (α := _))
 | mono M hM => exact Layered.mono _ hM.inverse
 | pair M hM => exact Layered.pair _ (Matrix.isUnit_nonsing_inv_iff.mpr hM)
 | mul hM hN ihM ihN =>
  rw [Matrix.mul_inv_rev]
  simpa only [Nat.add_comm] using ihN.mul ihM
 | reindex f hM ih =>
  rw [MatrixSymmetry.inverse_reindex f _ hM.unit]
  exact ih.reindex f
 | sum hM hN ihM ihN =>
  rw [MatrixSymmetry.inverse_sum _ _ hM.unit hN.unit]
  exact ihM.sum ihN
 | weaken h hde ih => exact ih.weaken hde

theorem conjugate {M N : Matrix α α ℂ} {d e : ℕ} (hM : Layered M d) (hN : Layered N e) :
 Layered (M*N*M⁻¹) (2*d+e) := by
 simpa only [show d+e+d=2*d+e by omega] using (hM.mul hN).mul hM.inverse
end ExactFourier.Layered

end
end

section
noncomputable section
namespace ExactFourier.Layered
variable {α β γ : Type} [Fintype α] [Fintype β] [Fintype γ]
 [DecidableEq α] [DecidableEq β] [DecidableEq γ]

theorem rect_diagonal (c : α→ℂ) : Layered (rectangularShear (Matrix.diagonal c)) 1 := by
 let M := fun i : α=>(!![1,c i;0,1] : Matrix (Fin 2) (Fin 2) ℂ)
 have hm : ∀ i,IsUnit (M i) := by
  intro i
  apply (Matrix.isUnit_iff_isUnit_det _).mpr
  change IsUnit ((!![1,c i;0,1] : Matrix (Fin 2) (Fin 2) ℂ).det)
  simp
 have h := (blockDiagonal M 1 (fun i=>Layered.pair (M i) (hm i))).reindex (twoProdEquiv α)
 have he : Matrix.reindex (twoProdEquiv α) (twoProdEquiv α) (Matrix.blockDiagonal M)=
  rectangularShear (Matrix.diagonal c) := by
  ext i j
  cases i <;> cases j <;>
   simp [twoProdEquiv,Matrix.reindex_apply,Matrix.blockDiagonal,M,rectangularShear,Matrix.one_apply,Matrix.diagonal_apply]
 rw [he] at h
 exact h

theorem rect_add {G H : Matrix α β ℂ} {d e : ℕ}
 (hG : Layered (rectangularShear G) d) (hH : Layered (rectangularShear H) e) :
 Layered (rectangularShear (G+H)) (d+e) := by
 rw [← rectangularShear_mul]
 exact hG.mul hH

theorem rect_neg {G : Matrix α β ℂ} {d : ℕ}
 (hG : Layered (rectangularShear G) d) : Layered (rectangularShear (-G)) d := by
 rw [← rectangularShear_inv]
 exact hG.inverse

theorem rect_mul_left {M : Matrix α α ℂ} {G : Matrix α β ℂ} {d e : ℕ}
 (hM : Layered M d) (hG : Layered (rectangularShear G) e) :
 Layered (rectangularShear (M*G)) (2*d+e) := by
 have h := (hM.sum (identity.weaken (Nat.zero_le d))).conjugate hG
 have he : Matrix.fromBlocks M 0 0 (1 : Matrix β β ℂ) * rectangularShear G *
  (Matrix.fromBlocks M 0 0 (1 : Matrix β β ℂ))⁻¹=rectangularShear (M*G) := by
  rw [MatrixSymmetry.inverse_sum _ _ hM.unit isUnit_one]
  simp [rectangularShear,Matrix.fromBlocks_multiply,Matrix.mul_nonsing_inv _ (Matrix.isUnit_iff_isUnit_det _ |>.mp hM.unit)]
 rw [he] at h
 exact h

theorem rect_mul_right {M : Matrix β β ℂ} {G : Matrix α β ℂ} {d e : ℕ}
 (hM : Layered M d) (hG : Layered (rectangularShear G) e) :
 Layered (rectangularShear (G*M)) (2*d+e) := by
 let := hM.unit.invertible
 have h := ((identity.weaken (Nat.zero_le d)).sum hM.inverse).conjugate hG
 have he : Matrix.fromBlocks (1 : Matrix α α ℂ) 0 0 M⁻¹ * rectangularShear G *
  (Matrix.fromBlocks (1 : Matrix α α ℂ) 0 0 M⁻¹)⁻¹=rectangularShear (G*M) := by
  rw [MatrixSymmetry.inverse_sum _ _ isUnit_one hM.inverse.unit,Matrix.inv_inv_of_invertible]
  simp [rectangularShear,Matrix.fromBlocks_multiply,Matrix.nonsing_inv_mul _ (Matrix.isUnit_iff_isUnit_det _ |>.mp hM.unit)]
 rw [he] at h
 exact h
end ExactFourier.Layered

end
end

section
noncomputable section
namespace ExactFourier.Layered
variable {α β γ : Type} [Fintype α] [Fintype β] [Fintype γ]
 [DecidableEq α] [DecidableEq β] [DecidableEq γ]

def swapLast : ((α⊕γ)⊕β)≃(α⊕(β⊕γ)) :=
 (Equiv.sumAssoc α γ β).trans (Equiv.sumCongr (Equiv.refl α) (Equiv.sumComm γ β))

theorem rect_first
    {α : Type} {β : Type} {γ : Type} [Fintype α] [Fintype β] [Fintype γ] [DecidableEq α] [DecidableEq β] [DecidableEq γ] (G : Matrix α β ℂ) :
 Matrix.reindex (Equiv.sumAssoc α β γ) (Equiv.sumAssoc α β γ)
  (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix γ γ ℂ)) =
 rectangularShear (Matrix.fromCols G (0 : 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]

theorem rect_last
    {α : Type} {β : Type} {γ : Type} [Fintype α] [Fintype β] [Fintype γ] [DecidableEq α] [DecidableEq β] [DecidableEq γ] (G : Matrix α γ ℂ) :
 Matrix.reindex (swapLast (α := α) (β := β) (γ := γ)) (swapLast (α := α) (β := β) (γ := γ))
  (Matrix.fromBlocks (rectangularShear G) 0 0 (1 : Matrix β β ℂ)) =
 rectangularShear (Matrix.fromCols (0 : Matrix α β ℂ) G) := by
 ext i j
 rcases i with i|(i|i) <;> rcases j with j|(j|j) <;>
  simp [rectangularShear,Matrix.reindex_apply,Matrix.one_apply,swapLast]

theorem commutator_identity (G : Matrix α β ℂ) (H : Matrix β γ ℂ) :
 rectangularShear (Matrix.fromCols G (0 : Matrix α γ ℂ)) *
 Matrix.fromBlocks (1 : Matrix α α ℂ) 0 0 (rectangularShear H) *
 rectangularShear (Matrix.fromCols (-G) (0 : Matrix α γ ℂ)) *
 Matrix.fromBlocks (1 : Matrix α α ℂ) 0 0 (rectangularShear (-H)) =
 rectangularShear (Matrix.fromCols (0 : Matrix α β ℂ) (G*H)) := by
 simp only [rectangularShear,Matrix.fromBlocks_multiply,Matrix.mul_one,Matrix.one_mul,
  Matrix.mul_zero,Matrix.zero_mul,add_zero,zero_add]
 ext i j
 rcases i with i|(i|i) <;> rcases j with j|(j|j) <;>
  simp [Matrix.mul_apply,Fintype.sum_sum_type,Matrix.one_apply,Finset.sum_add_distrib,
    Finset.sum_neg_distrib,add_mul]

theorem rect_product_stable {G : Matrix α β ℂ} {H : Matrix β γ ℂ} {d e : ℕ}
 (hG : Layered (rectangularShear G) d) (hH : Layered (rectangularShear H) e) :
 Layered (Matrix.fromBlocks (rectangularShear (G*H)) 0 0 (1 : Matrix β β ℂ)) (2*(d+e)) := by
 have hu := (hG.sum (identity.weaken (Nat.zero_le d))).reindex (Equiv.sumAssoc α β γ)
 rw [rect_first] at hu
 have hun := (hG.rect_neg.sum (identity.weaken (Nat.zero_le d))).reindex (Equiv.sumAssoc α β γ)
 rw [rect_first] at hun
 have hv := (identity.weaken (Nat.zero_le e) (α := α)).sum hH
 have hvn := (identity.weaken (Nat.zero_le e) (α := α)).sum hH.rect_neg
 have ht := ((hu.mul hv).mul hun).mul hvn
 rw [commutator_identity,←rect_last] at ht
 have hs := ht.reindex (swapLast (α := α) (β := β) (γ := γ)).symm
 simpa only [reindex_inverse,
  show d+e+d+e=2*(d+e) by omega] using hs
end ExactFourier.Layered

end
end

section
noncomputable section
namespace ExactFourier.Layered
variable {α β γ : Type} [Fintype α] [Fintype β] [Fintype γ]
 [DecidableEq α] [DecidableEq β] [DecidableEq γ]

theorem rect_transpose {G : Matrix α β ℂ} {d : ℕ}
 (hG : Layered (rectangularShear G) d) : Layered (rectangularShear G.transpose) d := by
 have h := hG.transpose.reindex (Equiv.sumComm α β)
 have he : Matrix.reindex (Equiv.sumComm α β) (Equiv.sumComm α β)
  (rectangularShear G).transpose=rectangularShear G.transpose := by
  ext i j
  cases i <;> cases j <;> simp [rectangularShear,Matrix.reindex_apply,Matrix.one_apply,eq_comm]
 rw [he] at h
 exact h

theorem embedded_injection (e : β↪α) :
 Embedded.matrix (e.sumMap (Function.Embedding.refl β))
 (rectangularShear (1 : Matrix β β ℂ)) =
 rectangularShear ((1 : Matrix α α ℂ).submatrix id e) := by
 classical
 let f := e.sumMap (Function.Embedding.refl β)
 have ho (i : α) (hi : i∉Set.range e) : (Sum.inl i : α⊕β)∉Set.range f := by
  rintro ⟨a,h⟩; cases a with
  | inl a => exact hi ⟨a,Sum.inl.inj h⟩
  | inr a => cases h
 ext i j
 rcases i with i|i <;> rcases j with j|j
 · by_cases hi : i∈Set.range e
   · obtain ⟨i,rfl⟩ := hi
     by_cases hj : j∈Set.range e
     · obtain ⟨j,rfl⟩ := hj
       change Embedded.matrix f _ (f (.inl i)) (f (.inl j))=_
       rw [Embedded.matrix_on]
       simp [rectangularShear,Matrix.one_apply,e.injective.eq_iff]
     · rw [Embedded.matrix_off_col f _ _ _ (ho j hj)]
       simp [rectangularShear,Matrix.one_apply]
   · rw [Embedded.matrix_off_row f _ _ _ (ho i hi)]
     simp [rectangularShear,Matrix.one_apply]
 · by_cases hi : i∈Set.range e
   · obtain ⟨i,rfl⟩ := hi
     change Embedded.matrix f _ (f (.inl i)) (f (.inr j))=_
     rw [Embedded.matrix_on]
     simp [rectangularShear,Matrix.one_apply,e.injective.eq_iff]
   · rw [Embedded.matrix_off_row f _ _ _ (ho i hi)]
     have hn : i≠e j := fun h=>hi ⟨j,h.symm⟩
     simp [rectangularShear,hn]
 · by_cases hj : j∈Set.range e
   · obtain ⟨j,rfl⟩ := hj
     change Embedded.matrix f _ (f (.inr i)) (f (.inl j))=_
     rw [Embedded.matrix_on]
     simp [rectangularShear]
   · rw [Embedded.matrix_off_col f _ _ _ (ho j hj)]
     simp [rectangularShear]
 · change Embedded.matrix f _ (f (.inr i)) (f (.inr j))=_
   rw [Embedded.matrix_on]
   simp [rectangularShear]

theorem rect_injection (e : β↪α) : Layered (rectangularShear ((1 : Matrix α α ℂ).submatrix id e)) 1 := by
 rw [← embedded_injection e]
 have h := rect_diagonal (fun _ : β=>(1 : ℂ))
 rw [Matrix.diagonal_one] at h
 exact h.embed _

theorem rect_projection (e : β↪α) : Layered (rectangularShear ((1 : Matrix α α ℂ).submatrix e id)) 1 := by
 simpa [Matrix.transpose_submatrix] using (rect_injection e).rect_transpose

theorem rect_submatrix_stable {M : Matrix γ γ ℂ} {d : ℕ}
 (hM : Layered M d) (e : α↪γ) (f : β↪γ) :
 Layered (Matrix.fromBlocks (rectangularShear (M.submatrix e f)) 0 0 (1 : Matrix γ γ ℂ)) (4*d+4) := by
 have hG := hM.rect_mul_right (rect_projection e)
 have h := hG.rect_product_stable (rect_injection f)
 have he : ((1 : Matrix γ γ ℂ).submatrix e id * M) * (1 : Matrix γ γ ℂ).submatrix id f=M.submatrix e f := by
  ext i j
  simp [Matrix.mul_apply,Matrix.one_apply]
 rw [he] at h
 simpa only [show 2*(2*d+1+1)=4*d+4 by omega] using h
end ExactFourier.Layered

end
end

end OAI