| import OAI.Computability.FourierCircuit.SymmetricLaplacian |
|
|
| namespace OAI |
|
|
| section |
| namespace ExactFourier |
| open scoped BigOperators |
| variable {α : Type} [Fintype α] [DecidableEq α] |
|
|
| noncomputable def diagonalBlocks {t : ℕ} (A : Fin t → Matrix α α ℂ) : |
| Matrix (Fin t × α) (Fin t × α) ℂ := |
| fun i j => if i.1=j.1 then A i.1 i.2 j.2 else 0 |
|
|
| namespace MatrixPrice |
|
|
| theorem diagonal_blocks (p : MatrixPrice) (t : ℕ) (A : Fin t → Matrix α α ℂ) |
| (hA : ∀ i, IsUnit (A i)) : |
| IsUnit (diagonalBlocks A) ∧ p.value (diagonalBlocks A)=∑ i, p.value (A i) := by |
| have hu := (p.blocks_lower t (diagonalBlocks A) A hA |
| (by intros; simp [diagonalBlocks]) |
| (by intro i j a b hij; simp [diagonalBlocks,ne_of_lt hij])).1 |
| refine ⟨hu,?_⟩ |
| induction t with |
| | zero => |
| have he : diagonalBlocks A=1 := by ext i j; exact Fin.elim0 i.1 |
| rw [he,p.one]; simp |
| | succ t ih => |
| have hD : IsUnit (diagonalBlocks (fun i : Fin t => A i.succ)) := |
| (p.blocks_lower t _ _ (fun i => hA i.succ) |
| (by intros; simp [diagonalBlocks]) |
| (by intro i j a b hij; simp [diagonalBlocks,ne_of_lt hij])).1 |
| have he : Matrix.reindex (timeSplit t α) (timeSplit t α) (diagonalBlocks A)= |
| Matrix.fromBlocks (A 0) 0 0 (diagonalBlocks (fun i : Fin t => A i.succ)) := by |
| ext i j |
| rcases i with a|⟨i,a⟩ <;> rcases j with b|⟨j,b⟩ <;> |
| simp [Matrix.reindex_apply,Matrix.submatrix_apply,timeSplit,diagonalBlocks, |
| Ne.symm (Fin.succ_ne_zero _)] |
| rw [← p.reindex (timeSplit t α) _ hu,he,p.directSum _ _ (hA 0) hD, |
| ih _ (fun i => hA i.succ) hD,Fin.sum_univ_succ] |
|
|
| end MatrixPrice |
| end ExactFourier |
|
|
| end |
|
|
| section |
| namespace ExactFourier.RootEvaluation |
| open Polynomial |
| open scoped BigOperators Kronecker |
| noncomputable def fourier (t : ℕ) (ω : ℂ) : Matrix (Fin t) (Fin t) ℂ := |
| fun i j => ω^(i.val*j.val) |
|
|
| @[simp] theorem fourier_mulVec (t : ℕ) (ω : ℂ) (x : Fin t → ℂ) : |
| (fourier t ω).mulVec x=RadixTwo.eval t ω x := rfl |
|
|
| theorem fourier_unit (t : ℕ) (ht : 0<t) (ω : ℂ) (hω : IsPrimitiveRoot ω t) : |
| IsUnit (fourier t ω) := by |
| apply Matrix.mulVec_injective_iff_isUnit.mp |
| intro x y h |
| rw [fourier_mulVec,fourier_mulVec] at h |
| have hh := congrArg (RadixTwo.eval t ω⁻¹) h |
| rw [RadixTwo.eval_inverse ht ω hω,RadixTwo.eval_inverse ht ω hω] at hh |
| funext i |
| exact mul_left_cancel₀ (by exact_mod_cast Nat.ne_of_gt ht : (t:ℂ)≠0) (congrFun hh i) |
|
|
| theorem fourier_price (p : MatrixPrice) (j : ℕ) (ω : ℂ) |
| (hω : IsPrimitiveRoot ω (2^j)) : |
| p.value (fourier (2^j) ω) ≤ (26/Real.log 2)*(2^j:ℝ)*Real.log (2*2^j) := by |
| obtain ⟨C,hC,hE⟩ := RadixTwo.exists_fft_dag j ω hω |
| have hu := fourier_unit (2^j) (by positivity) ω hω |
| have hprice := (p.le_shear _ hu).trans (p.rectangularShear_bound C _ hE) |
| have hsize : (C.size:ℝ)≤3*(j:ℝ)*2^j := by exact_mod_cast hC |
| have hlog : Real.log (2*2^j) = ((j:ℝ)+1)*Real.log 2 := by |
| rw [← pow_succ',Real.log_pow] |
| push_cast; ring |
| rw [hlog] |
| have hlog0 : Real.log 2≠0 := ne_of_gt (Real.log_pos (by norm_num)) |
| have he : (26/Real.log 2)*(2^j:ℝ)*(((j:ℝ)+1)*Real.log 2)=26*2^j*((j:ℝ)+1) := by field_simp |
| rw [he] |
| push_cast at hprice |
| nlinarith [pow_pos (by norm_num : (0:ℝ)<2) j] |
| |
| noncomputable def matrix (t : ℕ) (ω a : ℂ) : Matrix (Fin t) (Fin t) ℂ := |
| fun i j => (a*ω^i.val)^j.val |
| |
| theorem matrix_eq (t : ℕ) (ω a : ℂ) : |
| matrix t ω a=fourier t ω*Matrix.diagonal (fun j : Fin t => a^j.val) := by |
| ext i j |
| simp [matrix,fourier,Matrix.mul_diagonal,mul_pow,pow_mul,mul_comm] |
| |
| theorem matrix_unit (t : ℕ) (ht : 0<t) (ω a : ℂ) |
| (hω : IsPrimitiveRoot ω t) (ha : a≠0) : IsUnit (matrix t ω a) := by |
| rw [matrix_eq] |
| exact (fourier_unit t ht ω hω).mul |
| (Matrix.isUnit_diagonal.mpr (Pi.isUnit_iff.mpr (fun j => isUnit_iff_ne_zero.mpr (pow_ne_zero _ ha)))) |
| |
| theorem matrix_price (p : MatrixPrice) (j : ℕ) (ω a : ℂ) |
| (hω : IsPrimitiveRoot ω (2^j)) (ha : a≠0) : |
| p.value (matrix (2^j) ω a)≤(26/Real.log 2)*(2^j:ℝ)*Real.log (2*2^j) := by |
| rw [matrix_eq,← one_mul (fourier (2^j) ω),p.monomial _ _ _ |
| (fourier_unit _ (by positivity) ω hω) MonomialMatrix.one |
| (MonomialMatrix.diagonal _ (fun i => pow_ne_zero _ ha))] |
| exact fourier_price p j ω hω |
| |
| end ExactFourier.RootEvaluation |
| |
| end |
| |
| section |
| namespace ExactFourier.RootEvaluation |
| open Polynomial |
| open scoped Kronecker BigOperators |
| |
| theorem coefficient_sum (t : ℕ) (ω a : ℂ) (f : Polynomial ℂ) |
| (hf : f.natDegree<t) (i : Fin t) : |
| f.eval (a*ω^i.val)=∑ j : Fin t, matrix t ω a i j*f.coeff j.val := by |
| conv_lhs => rw [f.as_sum_range_C_mul_X_pow' hf] |
| simp only [eval_finsetSum,eval_mul,eval_C,eval_pow,eval_X] |
| rw [← Fin.sum_univ_eq_sum_range] |
| apply Finset.sum_congr rfl |
| intro j _ |
| simp only [matrix,mul_comm] |
|
|
| theorem eval_remainder (ℓ f : Polynomial ℂ) (s : ℂ) (hs : ℓ.eval s=0) : |
| (f%ₘℓ).eval s=f.eval s := by |
| rw [modByMonic_eq_sub_mul_div,eval_sub,eval_mul,hs,zero_mul,sub_zero] |
|
|
| variable {α : Type} [Fintype α] [DecidableEq α] |
|
|
| theorem intertwine (t : ℕ) (ht : 0<t) (ω a : ℂ) (ℓ : Polynomial ℂ) |
| (hℓ : ℓ.Monic) (hℓt : ℓ.natDegree=t) (hs : ∀ i : Fin t,ℓ.eval (a*ω^i.val)=0) |
| (G : Matrix α α (Polynomial ℂ)) : |
| (matrix t ω a ⊗ₖ (1 : Matrix α α ℂ))*Boundary.modulusMatrix t ℓ G = |
| diagonalBlocks (fun i : Fin t => G.map (eval (a*ω^i.val)))* |
| (matrix t ω a ⊗ₖ (1 : Matrix α α ℂ)) := by |
| ext ⟨ai,aj⟩ ⟨bi,bj⟩ |
| simp only [Matrix.mul_apply,Fintype.sum_prod_type,Matrix.kronecker_apply,Matrix.one_apply, |
| diagonalBlocks,ite_mul,mul_ite,mul_one,mul_zero,zero_mul] |
| simp only [Finset.sum_ite_eq,Finset.mem_univ,ite_true] |
| have hne : ℓ≠1 := by |
| intro he |
| have hh := congrArg Polynomial.natDegree he |
| rw [hℓt] at hh |
| simp only [natDegree_one] at hh |
| omega |
| have hd := natDegree_modByMonic_lt (G aj bj*X^bi.val) hℓ hne |
| rw [hℓt] at hd |
| simp only [Boundary.modulusMatrix,Finset.sum_ite_irrel,Finset.sum_const_zero, |
| Finset.sum_ite_eq,Finset.sum_ite_eq',Finset.mem_univ,ite_true] |
| rw [← coefficient_sum t ω a _ hd ai,eval_remainder _ _ _ (hs ai)] |
| simp [eval_mul,eval_pow,eval_X,matrix,mul_comm] |
| |
| theorem root_modulus (t : ℕ) (ht : 0<t) (ω a : ℂ) (hω : IsPrimitiveRoot ω t) |
| (i : Fin t) : (X^t-C (a^t) : Polynomial ℂ).eval (a*ω^i.val)=0 := by |
| obtain ⟨size, rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt ht) |
| simp only [eval_sub,eval_pow,eval_X,eval_C,mul_pow,← pow_mul] |
| rw [Nat.mul_comm i.val size.succ,pow_mul,hω.pow_eq_one,one_pow,mul_one,sub_self] |
| |
| end ExactFourier.RootEvaluation |
| |
| end |
| |
| section |
| namespace ExactFourier.RootEvaluation |
| open Polynomial TensorAxis |
| open scoped Kronecker BigOperators |
| variable {α : Type} [Fintype α] [DecidableEq α] |
| |
| theorem modulus_upper (p : MatrixPrice) (j : ℕ) (ω a : ℂ) |
| (hω : IsPrimitiveRoot ω (2^j)) (ha : a≠0) |
| (G : Matrix α α (Polynomial ℂ)) |
| (hG : ∀ i : Fin (2^j),IsUnit (G.map (eval (a*ω^i.val)))) : |
| IsUnit (Boundary.modulusMatrix (2^j) (X^(2^j)-C (a^(2^j))) G) ∧ |
| p.value (Boundary.modulusMatrix (2^j) (X^(2^j)-C (a^(2^j))) G) ≤ |
| (∑ i : Fin (2^j),p.value (G.map (eval (a*ω^i.val))))+ |
| 2*(Fintype.card α:ℝ)*(26/Real.log 2)*(2^j:ℝ)*Real.log (2*2^j) := by |
| let t : ℕ := 2^j |
| have ht : 0<t := by dsimp [t]; positivity |
| let ℓ : Polynomial ℂ := X^t-C (a^t) |
| have hℓ : ℓ.Monic := monic_X_pow_sub_C _ (Nat.ne_of_gt ht) |
| have hℓt : ℓ.natDegree=t := natDegree_X_pow_sub_C |
| let P := matrix t ω a ⊗ₖ (1 : Matrix α α ℂ) |
| let W := Boundary.modulusMatrix t ℓ G |
| let D := diagonalBlocks (fun i : Fin t => G.map (eval (a*ω^i.val))) |
| have hP : IsUnit P := TensorTools.unit_tensor _ _ (matrix_unit t ht ω a hω ha) isUnit_one |
| obtain ⟨hDu,hDp⟩ := p.diagonal_blocks t _ hG |
| change IsUnit D at hDu |
| change p.value D=_ at hDp |
| have he : P*W=D*P := intertwine t ht ω a ℓ hℓ hℓt (root_modulus t ht ω a hω) G |
| have hW : IsUnit W := by |
| have hh : IsUnit (P*W) := by rw [he]; exact hDu.mul hP |
| have hd := (Matrix.isUnit_iff_isUnit_det _).mp hh |
| rw [Matrix.det_mul] at hd |
| exact (Matrix.isUnit_iff_isUnit_det _).mpr |
| (isUnit_iff_ne_zero.mpr (mul_ne_zero_iff.mp (isUnit_iff_ne_zero.mp hd)).2) |
| refine ⟨hW,?_⟩ |
| have hconj : P*W*P⁻¹=D := by |
| rw [he,Matrix.mul_assoc,Matrix.mul_nonsing_inv _ ((Matrix.isUnit_iff_isUnit_det _).mp hP),mul_one] |
| have hprice := p.le_conjugate P W hP hW |
| rw [hconj,hDp] at hprice |
| have hp : p.value P=(Fintype.card α:ℝ)*p.value (matrix t ω a) := by |
| rw [p.tensor _ _ (matrix_unit t ht ω a hω ha) isUnit_one,p.one,mul_zero,add_zero] |
| rw [hp] at hprice |
| have hv := matrix_price p j ω a hω ha |
| have hv' := mul_le_mul_of_nonneg_left hv (show (0:ℝ)≤Fintype.card α by positivity) |
| change p.value W≤_ |
| dsimp only [t] at hprice |
| nlinarith only [hprice,hv'] |
| |
| end ExactFourier.RootEvaluation |
| |
| end |
| |
| section |
| namespace ExactFourier.RootEvaluation |
| |
| theorem exists_dilation (t : ℕ) (ω : ℂ) (hω : ω≠0) (E : Finset ℂ) : |
| ∃ a : ℂ, a≠0 ∧ ∀ i : Fin t, a*ω^i.val ∉ E := by |
| classical |
| let F : Finset ℂ := insert 0 (Finset.univ.biUnion (fun i : Fin t => E.image (fun s => s/ω^i.val))) |
| obtain ⟨a,ha⟩ := F.exists_notMem |
| refine ⟨a,?_,?_⟩ |
| · intro he |
| apply ha |
| simp [F,he] |
| · intro i hi |
| apply ha |
| apply Finset.mem_insert_of_mem |
| apply Finset.mem_biUnion.mpr |
| refine ⟨i,Finset.mem_univ _,Finset.mem_image.mpr ⟨a*ω^i.val,hi,?_⟩⟩ |
| exact mul_div_cancel_right₀ _ (pow_ne_zero _ hω) |
| |
| end ExactFourier.RootEvaluation |
| |
| end |
| |
| section |
| namespace ExactFourier |
| open Filter Topology |
| |
| theorem exists_dyadic_between (b : ℕ) (hb : 0<b) : ∃ j : ℕ, b≤2^j ∧ 2^j≤2*b := by |
| refine ⟨Nat.log 2 b+1,(Nat.lt_pow_succ_log_self (by decide : 1<2) b).le,?_⟩ |
| have hh := Nat.pow_log_le_self 2 (Nat.ne_of_gt hb) |
| rw [pow_succ] |
| omega |
| |
| theorem fixed_price_of_dyadic_boundary (x y C : ℝ) (hC : 0≤C) |
| (h : ∀ k j : ℕ, 0<k → |
| (2^j:ℝ)*k*(x-y) ≤ C*((2^j:ℝ)*Real.log (2*2^j)+(k+1:ℝ)^6)) : x≤y := by |
| have he (m : ℕ) : x-y ≤ (2*C)*boundaryError m := by |
| let b : ℕ := (m+2)^8 |
| have hb : 0<b := by dsimp [b]; positivity |
| obtain ⟨j,hlo,hhi⟩ := exists_dyadic_between b hb |
| let T : ℕ := 2^j |
| have hTr : 0<(T:ℝ) := by exact_mod_cast (pow_pos (by decide : 0<2) j) |
| have hbr : (b:ℝ)=((m:ℝ)+2)^8 := by dsimp [b]; push_cast; rfl |
| have hk : 0<(m:ℝ)+1 := by positivity |
| have hb1 : (1:ℝ)≤b := by exact_mod_cast (hb : 1≤b) |
| have hloR : (b:ℝ)≤T := by exact_mod_cast hlo |
| have hhiR : (T:ℝ)≤2*b := by exact_mod_cast hhi |
| have hln : Real.log (2*(T:ℝ)) ≤ 2*Real.log (2*b) := by |
| have harg : 2*(T:ℝ)≤(2*(b:ℝ))^2 := by nlinarith |
| have hh := Real.log_le_log (by positivity : (0:ℝ)<2*T) harg |
| simpa only [Real.log_pow,Nat.cast_ofNat] using hh |
| have hln0 : 0≤Real.log (2*(b:ℝ)) := Real.log_nonneg (by linarith) |
| have hr : ((m:ℝ)+2)^6 / ((T:ℝ)*((m:ℝ)+1)) ≤ |
| ((m:ℝ)+2)^6 / ((b:ℝ)*((m:ℝ)+1)) := by |
| apply div_le_div_of_nonneg_left (by positivity) (by positivity) |
| exact mul_le_mul_of_nonneg_right hloR hk.le |
| have hlog : Real.log (2*(T:ℝ))/((m:ℝ)+1) ≤ |
| 2*Real.log (2*(b:ℝ))/((m:ℝ)+1) := by exact div_le_div_of_nonneg_right hln hk.le |
| have herr : Real.log (2*(T:ℝ))/((m:ℝ)+1)+ |
| ((m:ℝ)+2)^6/((T:ℝ)*((m:ℝ)+1)) ≤2*boundaryError m := by |
| have hfrac : 0≤((m:ℝ)+2)^6/((b:ℝ)*((m:ℝ)+1)) := by positivity |
| dsimp only [boundaryError] |
| rw [← hbr] |
| rw [mul_div_assoc] at hlog |
| nlinarith only [hr,hlog,hfrac] |
| have hh := h (m+1) j (by omega) |
| have hTR : (2^j:ℝ)=(T:ℝ) := by dsimp [T]; norm_cast |
| rw [hTR] at hh |
| push_cast at hh |
| have hnorm : x-y ≤ C*(Real.log (2*(T:ℝ))/((m:ℝ)+1)+ |
| ((m:ℝ)+2)^6/((T:ℝ)*((m:ℝ)+1))) := by |
| have hn : x-y ≤ (C*((T:ℝ)*Real.log (2*T)+((m:ℝ)+2)^6))/((T:ℝ)*((m:ℝ)+1)) := |
| (le_div_iff₀ (mul_pos hTr hk)).mpr (by nlinarith only [hh]) |
| convert hn using 1 ; field_simp |
| calc |
| x-y ≤ _ := hnorm |
| _ ≤ C*(2*boundaryError m) := mul_le_mul_of_nonneg_left herr hC |
| _ = (2*C)*boundaryError m := by ring |
| have hh := ge_of_tendsto (boundaryError_tendsto.const_mul (2*C)) (Filter.Eventually.of_forall he) |
| have : x-y≤0 := by simpa using hh |
| linarith |
| |
| end ExactFourier |
| |
| end |
| |
| section |
| namespace ExactFourier.MatrixPrice |
| open TensorAxis Polynomial CoefficientTime |
| open scoped BigOperators |
| variable {α : Type} [Fintype α] [DecidableEq α] |
| |
| theorem specialize_polynomial_zero (p : MatrixPrice) (G : Matrix α α (Polynomial ℂ)) |
| (hG0 : IsUnit (G.map (eval 0))) (E : Finset ℂ) (C0 : ℝ) |
| (hG : ∀ s : ℂ, s∉E → IsUnit (G.map (eval s)) ∧ p.value (G.map (eval s))≤C0) : |
| p.value (G.map (eval 0))≤C0 := by |
| classical |
| obtain ⟨s,hs⟩ := E.exists_notMem |
| have hC0 : 0≤C0 := (p.nonneg _ (hG s hs).1).trans (hG s hs).2 |
| by_cases hn : Fintype.card α=0 |
| · have : IsEmpty α := Fintype.card_eq_zero_iff.mp hn |
| have he : G.map (eval 0)=1 := by ext i; exact isEmptyElim i |
| rw [he,p.one] |
| exact hC0 |
| have hcoeff : (fun f : Polynomial ℂ => f.coeff 0)=evalRingHom 0 := by |
| funext f; exact coeff_zero_eq_eval_zero f |
| have hGu0 : IsUnit (G.map (fun f => f.coeff 0)) := by |
| rw [hcoeff,coe_evalRingHom]; exact hG0 |
| obtain ⟨CB,hCB,hboundary⟩ := Boundary.exists_boundary_bound p G hGu0 |
| let C : ℝ := CB+52/Real.log 2 |
| have hC : 0≤C := by dsimp [C]; positivity |
| apply fixed_price_of_dyadic_boundary (p.value (G.map (eval 0))) C0 |
| (C*Fintype.card α) (by positivity) |
| intro k j hk |
| let t : ℕ := 2^j |
| have ht : 0<t := by dsimp [t]; positivity |
| let ω := zeta t |
| have hω : IsPrimitiveRoot ω t := Complex.isPrimitiveRoot_exp _ (Nat.ne_of_gt ht) |
| obtain ⟨a,ha,had⟩ := RootEvaluation.exists_dilation t ω (hω.ne_zero (Nat.ne_of_gt ht)) E |
| let ℓ : Polynomial ℂ := X^t-Polynomial.C (a^t) |
| have hℓ : ℓ.Monic := monic_X_pow_sub_C _ (Nat.ne_of_gt ht) |
| have hℓt : ℓ.natDegree=t := natDegree_X_pow_sub_C |
| have hℓ0 : ℓ.coeff 0≠0 := by simp [ℓ,coeff_zero_eq_eval_zero,Nat.ne_of_gt ht,ha] |
| have hmap (s : ℂ) : (power G k).map (eval s)=power (G.map (eval s)) k := by |
| rw [← coe_evalRingHom] |
| exact map_power (evalRingHom s) G k |
| have hroots (i : Fin t) : IsUnit ((power G k).map (eval (a*ω^i.val))) := by |
| rw [hmap]; exact unit_power _ (hG _ (had i)).1 k |
| obtain ⟨hWu,hupper⟩ := RootEvaluation.modulus_upper p j ω a hω ha (power G k) hroots |
| have hblocks : (∑ i : Fin t,p.value ((power G k).map (eval (a*ω^i.val))))≤ |
| (t:ℝ)*Fintype.card (Fibers α k)*C0 := by |
| calc |
| _ ≤ ∑ i : Fin t,(Fintype.card (Fibers α k):ℝ)*C0 := by |
| apply Finset.sum_le_sum |
| intro i hi |
| rw [hmap,price_power p _ (hG _ (had i)).1] |
| exact mul_le_mul_of_nonneg_left (hG _ (had i)).2 (by positivity) |
| _ = _ := by simp; ring |
| have hb := hboundary k t hk ht ℓ hℓ hℓt hℓ0 hWu |
| have hconst : (Boundary.seriesMatrix (power G k)).map PowerSeries.constantCoeff= |
| power (G.map (eval 0)) k := by |
| have he : (Boundary.seriesMatrix (power G k)).map PowerSeries.constantCoeff= |
| (power G k).map (eval 0) := by ext i l; simp [coeff_zero_eq_eval_zero] |
| rw [he,hmap] |
| have hlow := p.trunc_lower_bound t (Boundary.seriesMatrix (power G k)) |
| (by rw [hconst]; exact unit_power _ hG0 k) |
| rw [hconst,price_power p _ hG0,← Boundary.timeMatrix_eq_trunc] at hlow |
| rw [card_space] at hupper |
| push_cast at hupper |
| have hN : 0<(Fintype.card α:ℝ)^k := pow_pos (by exact_mod_cast Nat.pos_of_ne_zero hn) k |
| have herror : (t:ℝ)*Fintype.card (Fibers α k)*(p.value (G.map (eval 0))-C0)≤ |
| C*(Fintype.card α:ℝ)^k*((t:ℝ)*Real.log (2*t)+(k+1:ℝ)^6) := by |
| have hb' := (abs_le.mp hb).1 |
| have hextra : 0≤(52/Real.log 2)*(Fintype.card α:ℝ)^k*(k+1:ℝ)^6 := by positivity |
| dsimp only [ℓ,t] at hb' hblocks hlow ⊢ |
| push_cast at hb' hblocks hlow ⊢ |
| dsimp only [C] |
| simp only [div_eq_mul_inv] at hupper hextra ⊢ |
| nlinarith only [hb',hupper,hlow,hblocks,hextra] |
| have hrel : (Fintype.card (Fibers α k):ℝ)*Fintype.card α=(k:ℝ)*(Fintype.card α:ℝ)^k := by |
| have hh := Triangular.calls_card_relation (β := α) k |
| change Fintype.card (Fibers α k)*Fintype.card α=k*Fintype.card (Space α k) at hh |
| rw [card_space] at hh |
| exact_mod_cast hh |
| have hm := mul_le_mul_of_nonneg_right herror (Nat.cast_nonneg (Fintype.card α) : (0:ℝ)≤_) |
| apply (mul_le_mul_iff_right₀ hN).mp |
| have ha := congrArg (fun v : ℝ => (t:ℝ)*v*(p.value (G.map (eval 0))-C0)) hrel |
| dsimp only [t] at hm ha |
| push_cast at hm ha |
| nlinarith only [hm,ha] |
| |
| end ExactFourier.MatrixPrice |
| |
| end |
| |
| end OAI |
| |
