| import OAI.Computability.FourierCircuit.PolynomialClearing |
|
|
| namespace OAI |
|
|
| section |
| namespace ExactFourier.Pivot |
| variable {α β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] |
|
|
| noncomputable def matrix (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) : Matrix (α⊕β) (α⊕β) ℂ := |
| Matrix.fromBlocks (A-C*D⁻¹*B) (C*D⁻¹) (-D⁻¹*B) D⁻¹ |
|
|
| theorem factor (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) : |
| matrix A C B D=Matrix.fromBlocks A C 0 (1 : Matrix β β ℂ)* |
| Matrix.fromBlocks (1 : Matrix α α ℂ) 0 (-D⁻¹*B) D⁻¹ := by |
| simp [matrix,Matrix.fromBlocks_multiply,Matrix.mul_assoc,sub_eq_add_neg] |
|
|
| theorem unit (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) (hA : IsUnit A) (hD : IsUnit D) : |
| IsUnit (matrix A C B D) := by |
| rw [factor] |
| exact (Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨hA,isUnit_one⟩).mul |
| (Matrix.isUnit_fromBlocks_zero₁₂.mpr ⟨isUnit_one,Matrix.isUnit_nonsing_inv_iff.mpr hD⟩) |
|
|
| theorem solve (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) (hD : IsUnit D) : |
| matrix A C B D*Matrix.fromBlocks (1 : Matrix α α ℂ) 0 B D= |
| Matrix.fromBlocks A C 0 (1 : Matrix β β ℂ) := by |
| have hi := Matrix.nonsing_inv_mul D ((Matrix.isUnit_iff_isUnit_det _).mp hD) |
| simp [matrix,Matrix.fromBlocks_multiply,Matrix.mul_assoc,hi] |
|
|
| theorem involutive |
| {α : Type} {β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) (hD : IsUnit D) : |
| matrix (A-C*D⁻¹*B) (C*D⁻¹) (-D⁻¹*B) D⁻¹=Matrix.fromBlocks A C B D := by |
| have hi := Matrix.nonsing_inv_mul D ((Matrix.isUnit_iff_isUnit_det _).mp hD) |
| have hj := Matrix.mul_nonsing_inv D ((Matrix.isUnit_iff_isUnit_det _).mp hD) |
| have hii := Matrix.nonsing_inv_nonsing_inv D ((Matrix.isUnit_iff_isUnit_det _).mp hD) |
| simp [matrix,hii,Matrix.mul_assoc,hi] |
| rw [← Matrix.mul_assoc,hj,Matrix.one_mul] |
|
|
| theorem schur_unit (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) (hD : IsUnit D) |
| (hK : IsUnit (Matrix.fromBlocks A C B D)) : IsUnit (A-C*D⁻¹*B) := by |
| let := hD.invertible |
| simpa only [Matrix.invOf_eq_nonsing_inv] using |
| (Matrix.isUnit_fromBlocks_iff_of_invertible₂₂ (A := A) (B := C) (C := B)).mp hK |
|
|
| end ExactFourier.Pivot |
|
|
| end |
|
|
| section |
| namespace ExactFourier.MatrixPrice |
|
|
| theorem pair_le_two_of_entry (p : MatrixPrice) (A : Matrix (Fin 2) (Fin 2) ℂ) |
| (hA : IsUnit A) (ha : A 0 0≠0) : p.value A≤2 := by |
| let L := Matrix.transvection (1 : Fin 2) 0 (A 1 0/A 0 0) |
| let U := Matrix.transvection (0 : Fin 2) 1 (A 0 1/A 0 0) |
| let d : Fin 2 → ℂ := ![A 0 0,A.det/A 0 0] |
| have hdet : A.det≠0 := isUnit_iff_ne_zero.mp ((Matrix.isUnit_iff_isUnit_det _).mp hA) |
| have hd : ∀ i,d i≠0 := by intro i; fin_cases i <;> simp [d,ha,hdet] |
| have hL : IsUnit L := transvection_isUnit _ _ (by decide) _ |
| have hU : IsUnit U := transvection_isUnit _ _ (by decide) _ |
| have hD : IsUnit (Matrix.diagonal d) := Matrix.isUnit_diagonal.mpr |
| (Pi.isUnit_iff.mpr (fun i => isUnit_iff_ne_zero.mpr (hd i))) |
| have he : A=L*(Matrix.diagonal d*U) := by |
| ext i j |
| fin_cases i <;> fin_cases j <;> |
| simp [L,U,d,Matrix.mul_apply,Fin.sum_univ_two,Matrix.diagonal_apply, |
| Matrix.transvection,Matrix.single,Matrix.one_apply,Matrix.det_fin_two] <;> |
| field_simp ; ring |
| have hp := p.mul_le L (Matrix.diagonal d*U) hL (hD.mul hU) |
| have hm := p.monomial U (Matrix.diagonal d) 1 hU (MonomialMatrix.diagonal d hd) MonomialMatrix.one |
| rw [mul_one] at hm |
| rw [← he,hm] at hp |
| have hl := p.transvection_le_one (1 : Fin 2) 0 (by decide) (A 1 0/A 0 0) |
| have hu := p.transvection_le_one (0 : Fin 2) 1 (by decide) (A 0 1/A 0 0) |
| change p.value L≤1 at hl |
| change p.value U≤1 at hu |
| linarith |
|
|
| theorem pair_le_two (p : MatrixPrice) (A : Matrix (Fin 2) (Fin 2) ℂ) |
| (hA : IsUnit A) : p.value A≤2 := by |
| by_cases ha : A 0 0≠0 |
| · exact p.pair_le_two_of_entry A hA ha |
| · have ha0 : A 0 0=0 := not_ne_iff.mp ha |
| have hc : A 1 0≠0 := by |
| intro hc |
| have hd := isUnit_iff_ne_zero.mp ((Matrix.isUnit_iff_isUnit_det _).mp hA) |
| apply hd |
| simp [Matrix.det_fin_two,ha0,hc] |
| let e : Equiv.Perm (Fin 2) := Equiv.swap 0 1 |
| have hB : IsUnit (A.submatrix e (Equiv.refl _)) := |
| (Matrix.isUnit_submatrix_equiv e (Equiv.refl _)).mpr hA |
| have hp := p.pair_le_two_of_entry (A.submatrix e (Equiv.refl _)) hB |
| (by simpa [e,Matrix.submatrix_apply] using hc) |
| rwa [p.submatrix_equiv A hA e (Equiv.refl _)] at hp |
|
|
| end ExactFourier.MatrixPrice |
|
|
| end |
|
|
| section |
| namespace ExactFourier |
| open scoped Kronecker |
| variable {β : Type} [Fintype β] [DecidableEq β] |
|
|
| def twoProdEquiv (β : Type) : Fin 2×β ≃ β⊕β where |
| toFun := fun x => if x.1=0 then Sum.inl x.2 else Sum.inr x.2 |
| invFun := Sum.elim (fun b => (0,b)) (fun b => (1,b)) |
| left_inv := by rintro ⟨i,b⟩; fin_cases i <;> simp |
| right_inv := by intro b; cases b <;> simp |
|
|
| noncomputable def pairLayer (A : Matrix (Fin 2) (Fin 2) ℂ) : Matrix (β⊕β) (β⊕β) ℂ := |
| Matrix.reindex (twoProdEquiv β) (twoProdEquiv β) (A ⊗ₖ (1 : Matrix β β ℂ)) |
|
|
| theorem pairLayer_eq |
| {β : Type} [Fintype β] [DecidableEq β] (A : Matrix (Fin 2) (Fin 2) ℂ) : |
| pairLayer (β := β) A=Matrix.fromBlocks (A 0 0•1) (A 0 1•1) (A 1 0•1) (A 1 1•1) := by |
| ext i j |
| cases i <;> cases j <;> rfl |
|
|
| theorem pairLayer_unit (A : Matrix (Fin 2) (Fin 2) ℂ) (hA : IsUnit A) : |
| IsUnit (pairLayer (β := β) A) := |
| TensorTools.unit_reindex _ _ (TensorTools.unit_tensor _ _ hA isUnit_one) |
|
|
| namespace MatrixPrice |
| theorem pair_layer (p : MatrixPrice) (A : Matrix (Fin 2) (Fin 2) ℂ) (hA : IsUnit A) : |
| p.value (pairLayer (β := β) A)≤2*Fintype.card β := by |
| rw [pairLayer,p.reindex _ _ (TensorTools.unit_tensor _ _ hA isUnit_one), |
| p.tensor _ _ hA isUnit_one,p.one,mul_zero,add_zero] |
| have h := mul_le_mul_of_nonneg_left (p.pair_le_two A hA) (Nat.cast_nonneg (Fintype.card β) : (0:ℝ)≤_) |
| nlinarith only [h] |
| end MatrixPrice |
| end ExactFourier |
|
|
| end |
|
|
| section |
| namespace ExactFourier |
| open Polynomial |
| variable {α : Type} [Fintype α] [DecidableEq α] |
|
|
| theorem exists_invertible_evaluation (G : Matrix α α (Polynomial ℂ)) (z0 : ℂ) |
| (hG : IsUnit (G.map (eval z0))) (E : Finset ℂ) : |
| ∃ s : ℂ,s∉E ∧ IsUnit (G.map (eval s)) := by |
| classical |
| have hd : G.det≠0 := by |
| intro he |
| have hdu := isUnit_iff_ne_zero.mp ((Matrix.isUnit_iff_isUnit_det _).mp hG) |
| apply hdu |
| have hh := RingHom.map_det (evalRingHom z0) G |
| rw [he,map_zero] at hh |
| exact hh.symm |
| obtain ⟨s,hs⟩ := (E∪G.det.roots.toFinset).exists_notMem |
| refine ⟨s,fun h => hs (Finset.mem_union_left _ h),?_⟩ |
| apply (Matrix.isUnit_iff_isUnit_det _).mpr |
| apply isUnit_iff_ne_zero.mpr |
| intro he |
| apply hs |
| apply Finset.mem_union_right |
| apply Multiset.mem_toFinset.mpr |
| apply (Polynomial.mem_roots hd).mpr |
| have hh := RingHom.map_det (evalRingHom s) G |
| exact hh.trans he |
|
|
| end ExactFourier |
|
|
| end |
|
|
| section |
| namespace ExactFourier.Pivot |
| variable {α β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] |
|
|
| noncomputable def side (L : Matrix (Fin 2) (Fin 2) ℂ) : Matrix ((α⊕β)⊕β) ((α⊕β)⊕β) ℂ := |
| Matrix.reindex (Equiv.sumAssoc α β β).symm (Equiv.sumAssoc α β β).symm |
| (Matrix.fromBlocks (1 : Matrix α α ℂ) 0 0 (pairLayer (β := β) L)) |
|
|
| theorem side_eq |
| {α : Type} {β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] (L : Matrix (Fin 2) (Fin 2) ℂ) : |
| side (α := α) (β := β) L= |
| Matrix.fromBlocks (Matrix.fromBlocks (1 : Matrix α α ℂ) 0 0 (L 0 0•1)) |
| (Matrix.fromRows 0 (L 0 1•1)) (Matrix.fromCols 0 (L 1 0•1)) (L 1 1•1) := by |
| rw [side,pairLayer_eq] |
| ext i j |
| rcases i with (i|i)|i <;> rcases j with (j|j)|j <;> rfl |
|
|
| theorem side_unit (L : Matrix (Fin 2) (Fin 2) ℂ) (hL : IsUnit L) : |
| IsUnit (side (α := α) (β := β) L) := |
| TensorTools.unit_reindex _ _ (Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨isUnit_one,pairLayer_unit L hL⟩) |
|
|
| theorem side_price (p : MatrixPrice) (L : Matrix (Fin 2) (Fin 2) ℂ) (hL : IsUnit L) : |
| p.value (side (α := α) (β := β) L)≤2*Fintype.card β := by |
| rw [side,p.reindex _ _ (Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨isUnit_one,pairLayer_unit L hL⟩), |
| p.directSum _ _ isUnit_one (pairLayer_unit L hL),p.one,zero_add] |
| exact p.pair_layer L hL |
|
|
| noncomputable def middle (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) : Matrix ((α⊕β)⊕β) ((α⊕β)⊕β) ℂ := |
| Matrix.reindex TensorTools.middleEquiv TensorTools.middleEquiv |
| (Matrix.fromBlocks (Matrix.fromBlocks A C B D) 0 0 (1 : Matrix β β ℂ)) |
|
|
| theorem middle_eq |
| {α : Type} {β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) : |
| middle A C B D=Matrix.fromBlocks (Matrix.fromBlocks A 0 0 (1 : Matrix β β ℂ)) |
| (Matrix.fromRows C 0) (Matrix.fromCols B 0) D := by |
| ext i j |
| rcases i with (i|i)|i <;> rcases j with (j|j)|j <;> rfl |
|
|
| def P (b : ℂ) : Matrix (Fin 2) (Fin 2) ℂ := !![b,1;1,1] |
| def Q (b : ℂ) : Matrix (Fin 2) (Fin 2) ℂ := !![1,1-b;1,-b] |
|
|
| theorem P_unit (b : ℂ) (hb : b≠1) : IsUnit (P b) := by |
| rw [Matrix.isUnit_iff_isUnit_det,isUnit_iff_ne_zero] |
| simpa [P,Matrix.det_fin_two] using sub_ne_zero.mpr hb |
|
|
| theorem Q_unit (b : ℂ) : IsUnit (Q b) := by |
| rw [Matrix.isUnit_iff_isUnit_det,isUnit_iff_ne_zero] |
| have he : (Q b).det=(-1 : ℂ) := by simp [Q,Matrix.det_fin_two]; ring |
| rw [he]; exact neg_ne_zero.mpr one_ne_zero |
|
|
| noncomputable def data (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) (b : ℂ) := |
| Matrix.fromBlocks A C ((1-b)•B) (b•1+(1-b)•D) |
| noncomputable def co (C : Matrix α β ℂ) (D : Matrix β β ℂ) (b : ℂ) := |
| Matrix.fromRows C (1+(1-b)•D) |
| noncomputable def bo (B : Matrix β α ℂ) (D : Matrix β β ℂ) (b : ℂ) := |
| Matrix.fromCols ((-b)•B) (b•(1-D)) |
| noncomputable def state (D : Matrix β β ℂ) (b : ℂ) := 1-b•D |
| noncomputable def cell (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) (b : ℂ) := |
| Matrix.fromBlocks (data A C B D b) (co C D b) (bo B D b) (state D b) |
|
|
| theorem cell_eq (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) (b : ℂ) : |
| cell A C B D b=side (Q b)*middle A C B D*side (P b) := by |
| rw [side_eq,side_eq,middle_eq] |
| simp only [cell,data,co,bo,state,P,Q, Matrix.fromBlocks_multiply,Matrix.fromCols_mul_fromRows, |
| Matrix.fromRows_mul,Matrix.mul_fromCols,Matrix.fromCols_mul_fromBlocks, |
| Matrix.fromBlocks_mul_fromRows, Matrix.add_mul,Matrix.smul_mul,Matrix.mul_smul, |
| Matrix.one_mul,Matrix.mul_one,Matrix.zero_mul,Matrix.mul_zero, |
| add_zero,zero_add] |
| ext i j |
| rcases i with (i|i)|i <;> rcases j with (j|j)|j <;> |
| simp [Matrix.fromBlocks,Matrix.fromRows,Matrix.fromCols,Sum.elim,sub_smul,smul_sub, |
| Matrix.add_apply,Matrix.smul_apply,Matrix.sub_apply,Matrix.neg_apply] <;> ring |
|
|
| end ExactFourier.Pivot |
|
|
| end |
|
|
| section |
| namespace ExactFourier.Pivot |
| open Polynomial |
| variable {α β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] |
|
|
| theorem cell_unit (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) (b : ℂ) (hb : b≠1) |
| (hK : IsUnit (Matrix.fromBlocks A C B D)) : IsUnit (cell A C B D b) := by |
| rw [cell_eq] |
| exact ((side_unit _ (Q_unit b)).mul (TensorTools.unit_reindex _ _ |
| (Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨hK,isUnit_one⟩))).mul (side_unit _ (P_unit b hb)) |
|
|
| theorem cell_price (p : MatrixPrice) (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) (b : ℂ) (hb : b≠1) |
| (hK : IsUnit (Matrix.fromBlocks A C B D)) : |
| p.value (cell A C B D b)≤p.value (Matrix.fromBlocks A C B D)+4*Fintype.card β := by |
| have hm : IsUnit (middle A C B D) := TensorTools.unit_reindex _ _ |
| (Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨hK,isUnit_one⟩) |
| have hq : IsUnit (side (α := α) (β := β) (Q b)) := side_unit _ (Q_unit b) |
| have hp : IsUnit (side (α := α) (β := β) (P b)) := side_unit _ (P_unit b hb) |
| have h1 := p.mul_le _ _ (hq.mul hm) hp |
| have h2 := p.mul_le _ _ hq hm |
| have h3 := side_price (α := α) (β := β) p (Q b) (Q_unit b) |
| have h4 := side_price (α := α) (β := β) p (P b) (P_unit b hb) |
| have he : p.value (middle A C B D)=p.value (Matrix.fromBlocks A C B D) := by |
| rw [middle,p.reindex _ _ (Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨hK,isUnit_one⟩),p.identity_pad _ hK] |
| rw [← cell_eq] at h1 |
| rw [he] at h2 |
| linarith |
|
|
| theorem choose_data (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) |
| (hK : IsUnit (Matrix.fromBlocks A C B D)) : |
| ∃ b : ℂ,b≠0 ∧ b≠1 ∧ IsUnit (data A C B D b) := by |
| classical |
| let K := Matrix.fromBlocks A C B D |
| let J := Matrix.fromBlocks (0 : Matrix α α ℂ) (0 : Matrix α β ℂ) (-B) (1-D) |
| let G : Matrix (α⊕β) (α⊕β) (Polynomial ℂ) := fun i j => Polynomial.C (K i j)+X*Polynomial.C (J i j) |
| have he (b : ℂ) : G.map (eval b)=data A C B D b := by |
| ext i j |
| change eval b (G i j)=data A C B D b i j |
| cases i <;> cases j <;> simp [G,K,J,data,Matrix.fromBlocks,Sum.elim,sub_smul] <;> ring |
| have h0 : IsUnit (G.map (eval 0)) := by |
| rw [he]; simpa [data] using hK |
| obtain ⟨b,hb,hu⟩ := exists_invertible_evaluation G 0 h0 {0,1} |
| have hb' : b≠0 ∧ b≠1 := by simpa using hb |
| exact ⟨b,hb'.1,hb'.2,by rwa [he] at hu⟩ |
|
|
| theorem denominator |
| {β : Type} [Fintype β] [DecidableEq β] (D : Matrix β β ℂ) (b : ℂ) : 1-(1 : ℂ)•state D b=b•D := by |
| simp [state] |
|
|
| theorem cell_feedback |
| {α : Type} {β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) (b : ℂ) (hb : b≠0) (hD : IsUnit D) : |
| CellPoly.feedback (data A C B D b) (co C D b) (bo B D b) (state D b) 1= |
| matrix A C B D := by |
| have hi := Matrix.nonsing_inv_mul D ((Matrix.isUnit_iff_isUnit_det _).mp hD) |
| have hj := Matrix.mul_nonsing_inv D ((Matrix.isUnit_iff_isUnit_det _).mp hD) |
| have hinv : (b•D)⁻¹=b⁻¹•D⁻¹ := by |
| apply Matrix.inv_eq_left_inv |
| simp [smul_smul,hi,hb] |
| have hCD : C*D⁻¹*D=C := by rw [Matrix.mul_assoc,hi,Matrix.mul_one] |
| rw [CellPoly.feedback,denominator,hinv] |
| simp only [data,co,bo,matrix,Matrix.fromRows_mul, |
| Matrix.mul_smul,Matrix.smul_mul, |
| smul_smul,Matrix.add_mul,Matrix.one_mul] |
| ext i j |
| cases i <;> cases j <;> |
| simp [Matrix.fromBlocks,Matrix.add_apply,Matrix.smul_apply,Matrix.sub_apply, |
| smul_sub,sub_smul,Matrix.mul_sub,Matrix.mul_one, hj,hi,hCD,Matrix.one_mul] <;> field_simp <;> ring |
|
|
| end ExactFourier.Pivot |
|
|
| namespace ExactFourier.MatrixPrice |
| variable {α β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] |
|
|
| theorem pivot_bound (p : MatrixPrice) (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) (hA : IsUnit A) (hD : IsUnit D) |
| (hK : IsUnit (Matrix.fromBlocks A C B D)) : |
| p.value (Pivot.matrix A C B D)≤p.value (Matrix.fromBlocks A C B D)+4*Fintype.card β := by |
| obtain ⟨b,hb0,hb1,hM⟩ := Pivot.choose_data A C B D hK |
| have hden : IsUnit (1-(1 : ℂ)•Pivot.state D b) := by |
| rw [Pivot.denominator]; exact scalar_unit _ hD _ hb0 |
| have hH : IsUnit (CellPoly.feedback (Pivot.data A C B D b) (Pivot.co C D b) |
| (Pivot.bo B D b) (Pivot.state D b) 1) := by |
| rw [Pivot.cell_feedback A C B D b hb0 hD]; exact Pivot.unit A C B D hA hD |
| have hf := p.feedback (Pivot.data A C B D b) (Pivot.co C D b) |
| (Pivot.bo B D b) (Pivot.state D b) 1 hM (Pivot.cell_unit A C B D b hb1 hK) hden hH |
| rw [Pivot.cell_feedback A C B D b hb0 hD] at hf |
| exact hf.trans (Pivot.cell_price p A C B D b hb1 hK) |
|
|
| end ExactFourier.MatrixPrice |
|
|
| end |
|
|
| end OAI |
|
|
