| import OAI.Computability.FourierCircuit.PivotAlgebra |
|
|
| namespace OAI |
|
|
| section |
| namespace ExactFourier.Pivot |
| variable {α β γ : Type} [Fintype α] [Fintype β] [Fintype γ] |
| [DecidableEq α] [DecidableEq β] [DecidableEq γ] |
| |
| noncomputable def ofMatrix (K : Matrix (α⊕β) (α⊕β) ℂ) := |
| matrix K.toBlocks₁₁ K.toBlocks₁₂ K.toBlocks₂₁ K.toBlocks₂₂ |
|
|
| @[simp] theorem of_fromBlocks |
| {α : Type} {β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] (A : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (B : Matrix β α ℂ) (D : Matrix β β ℂ) : |
| ofMatrix (Matrix.fromBlocks A C B D)=matrix A C B D := rfl |
|
|
| noncomputable def reverseJoin (X : Matrix (α⊕β) (α⊕β) ℂ) |
| (Y : Matrix (γ⊕β) (γ⊕β) ℂ) : Matrix ((α⊕γ)⊕β) ((α⊕γ)⊕β) ℂ := |
| Matrix.reindex (Equiv.sumCongr (Equiv.sumComm γ α) (Equiv.refl β)) |
| (Equiv.sumCongr (Equiv.sumComm γ α) (Equiv.refl β)) (CellJoin.join Y X) |
|
|
| theorem reverseJoin_eq |
| {α : Type} {β : Type} {γ : Type} [Fintype α] [Fintype β] [Fintype γ] [DecidableEq α] [DecidableEq β] [DecidableEq γ] (X : Matrix (α⊕β) (α⊕β) ℂ) |
| (Y : Matrix (γ⊕β) (γ⊕β) ℂ) : |
| reverseJoin X Y=Matrix.fromBlocks |
| (Matrix.fromBlocks X.toBlocks₁₁ (X.toBlocks₁₂*Y.toBlocks₂₁) 0 Y.toBlocks₁₁) |
| (Matrix.fromRows (X.toBlocks₁₂*Y.toBlocks₂₂) Y.toBlocks₁₂) |
| (Matrix.fromCols X.toBlocks₂₁ (X.toBlocks₂₂*Y.toBlocks₂₁)) |
| (X.toBlocks₂₂*Y.toBlocks₂₂) := by |
| ext i j |
| rcases i with (i|i)|i <;> rcases j with (j|j)|j <;> rfl |
| |
| theorem of_join (X : Matrix (α⊕β) (α⊕β) ℂ) |
| (Y : Matrix (γ⊕β) (γ⊕β) ℂ) |
| (hD : IsUnit X.toBlocks₂₂) (hH : IsUnit Y.toBlocks₂₂) : |
| ofMatrix (CellJoin.join X Y)=reverseJoin (ofMatrix X) (ofMatrix Y) := by |
| have hd := (Matrix.isUnit_iff_isUnit_det _).mp hD |
| have hh := (Matrix.isUnit_iff_isUnit_det _).mp hH |
| rw [reverseJoin_eq] |
| simp only [ofMatrix,CellJoin.join,matrix,Matrix.toBlocks_fromBlocks₁₁, |
| Matrix.toBlocks_fromBlocks₁₂,Matrix.toBlocks_fromBlocks₂₁,Matrix.toBlocks_fromBlocks₂₂, |
| Matrix.mul_inv_rev,Matrix.fromRows_mul,Matrix.mul_fromCols] |
| have h1 : X.toBlocks₂₂ * X.toBlocks₂₂⁻¹=1 := Matrix.mul_nonsing_inv _ hd |
| have h2 : Y.toBlocks₂₂⁻¹ * Y.toBlocks₂₂=1 := Matrix.nonsing_inv_mul _ hh |
| have h3 (W : Matrix β α ℂ) : Y.toBlocks₂₂⁻¹*(Y.toBlocks₂₂*W)=W := |
| Matrix.nonsing_inv_mul_cancel_left _ _ hh |
| have h4 {τ : Type} (W : Matrix β τ ℂ) : X.toBlocks₂₂*(X.toBlocks₂₂⁻¹*W)=W := by |
| rw [← Matrix.mul_assoc,h1,Matrix.one_mul] |
| ext i j |
| rcases i with (i|i)|i <;> rcases j with (j|j)|j <;> |
| simp [Matrix.fromBlocks,Matrix.fromRows,Matrix.fromCols,Sum.elim, |
| Matrix.sub_apply,Matrix.neg_apply, |
| Matrix.mul_assoc,h3,h4, |
| Matrix.mul_neg,Matrix.neg_mul] |
| |
| end ExactFourier.Pivot |
| |
| end |
| |
| section |
| namespace ExactFourier.CellJoin |
| variable {α γ : Type} [Fintype α] [Fintype γ] [DecidableEq α] [DecidableEq γ] |
|
|
| theorem scalar_price (p : MatrixPrice) (X : Matrix (α⊕PUnit) (α⊕PUnit) ℂ) |
| (Y : Matrix (γ⊕PUnit) (γ⊕PUnit) ℂ) (hX : IsUnit X) (hY : IsUnit Y) : |
| p.value (join X Y)=p.value X+p.value Y := by |
| let e := Equiv.sumComm γ PUnit |
| let Y' := Matrix.reindex e e Y |
| have hu : IsUnit Y' := TensorTools.unit_reindex e Y hY |
| have he : Matrix.reindex (TensorTools.middleEquiv (ι := α) (κ := PUnit) (τ := γ)) |
| TensorTools.middleEquiv (OnePort.product X Y')=join X Y := by |
| rw [OnePort.product,Reindexed.mul,join_eq] |
| congr 1 |
| ext i j |
| rcases i with (i|i)|i <;> rcases j with (j|j)|j <;> |
| simp [OnePort.unionSecond,Y',e,TensorTools.middleEquiv,Matrix.reindex_apply, |
| Matrix.fromBlocks,Sum.elim,Matrix.one_apply] |
| rw [← he,p.reindex _ _ (OnePort.product_isUnit X Y' hX hu),OnePort.price p X Y' hX hu, |
| p.reindex e Y hY] |
| |
| end ExactFourier.CellJoin |
| |
| end |
| |
| section |
| namespace ExactFourier.Pivot |
| variable {α β γ : Type} [Fintype α] [Fintype β] [Fintype γ] |
| [DecidableEq α] [DecidableEq β] [DecidableEq γ] |
|
|
| theorem of_unit (K : Matrix (α⊕β) (α⊕β) ℂ) |
| (hA : IsUnit K.toBlocks₁₁) (hD : IsUnit K.toBlocks₂₂) : IsUnit (ofMatrix K) := |
| unit _ _ _ _ hA hD |
|
|
| theorem of_reindex_data |
| {α : Type} {β : Type} {γ : Type} [Fintype α] [Fintype β] [Fintype γ] [DecidableEq α] [DecidableEq β] [DecidableEq γ] (e : α≃γ) (K : Matrix (α⊕β) (α⊕β) ℂ) : |
| ofMatrix (Matrix.reindex (Equiv.sumCongr e (Equiv.refl β)) |
| (Equiv.sumCongr e (Equiv.refl β)) K)= |
| Matrix.reindex (Equiv.sumCongr e (Equiv.refl β)) |
| (Equiv.sumCongr e (Equiv.refl β)) (ofMatrix K) := by |
| ext i j |
| cases i <;> cases j <;> rfl |
| |
| @[simp] theorem of_one : ofMatrix (1 : Matrix (α⊕β) (α⊕β) ℂ)=1 := by |
| have he : (1 : Matrix (α⊕β) (α⊕β) ℂ)=Matrix.fromBlocks 1 0 0 1 := by |
| ext i j; cases i <;> cases j <;> simp [Matrix.one_apply,Matrix.fromBlocks] |
| rw [he,of_fromBlocks] |
| simp [matrix] |
| |
| theorem run_block_units (K : Matrix (α⊕β) (α⊕β) ℂ) |
| (hA : IsUnit K.toBlocks₁₁) (hD : IsUnit K.toBlocks₂₂) (t : ℕ) : |
| IsUnit (CellStream.run K t).toBlocks₁₁ ∧ IsUnit (CellStream.run K t).toBlocks₂₂ := by |
| induction t with |
| | zero => |
| have h1 : (CellStream.run K 0).toBlocks₁₁=1 := by ext i; exact Fin.elim0 i.1 |
| have h2 : (CellStream.run K 0).toBlocks₂₂=1 := by ext i j; simp [CellStream.run,Matrix.toBlocks₂₂,Matrix.one_apply] |
| rw [h1,h2]; exact ⟨isUnit_one,isUnit_one⟩ |
| | succ t ih => |
| have h1 : (CellStream.run K (t+1)).toBlocks₁₁= |
| Matrix.reindex (timeSplit t α).symm (timeSplit t α).symm |
| (CellJoin.join K (CellStream.run K t)).toBlocks₁₁ := rfl |
| have h2 : (CellStream.run K (t+1)).toBlocks₂₂= |
| (CellStream.run K t).toBlocks₂₂*K.toBlocks₂₂ := rfl |
| rw [h1,h2] |
| exact ⟨TensorTools.unit_reindex _ _ (Matrix.isUnit_fromBlocks_zero₁₂.mpr ⟨hA,ih.1⟩),ih.2.mul hD⟩ |
|
|
| theorem reverseJoin_scalar_price (p : MatrixPrice) (X : Matrix (α⊕PUnit) (α⊕PUnit) ℂ) |
| (Y : Matrix (γ⊕PUnit) (γ⊕PUnit) ℂ) (hX : IsUnit X) (hY : IsUnit Y) : |
| p.value (reverseJoin X Y)=p.value X+p.value Y := by |
| rw [reverseJoin,p.reindex _ _ (CellJoin.unit Y X hY hX),CellJoin.scalar_price p Y X hY hX,add_comm] |
|
|
| theorem run_scalar_price (p : MatrixPrice) (K : Matrix (α⊕PUnit) (α⊕PUnit) ℂ) |
| (hK : IsUnit K) (t : ℕ) : p.value (CellStream.run K t)=(t : ℝ)*p.value K := by |
| induction t with |
| | zero => simp [CellStream.run,p.one] |
| | succ t ih => |
| rw [CellStream.run,p.reindex _ _ (CellJoin.unit K _ hK (CellStream.unit K hK t)), |
| CellJoin.scalar_price p K _ hK (CellStream.unit K hK t),ih] |
| push_cast; ring |
| |
| theorem run_pivot_price (p : MatrixPrice) (K : Matrix (α⊕PUnit) (α⊕PUnit) ℂ) |
| (hA : IsUnit K.toBlocks₁₁) (hD : IsUnit K.toBlocks₂₂) (t : ℕ) : |
| p.value (ofMatrix (CellStream.run K t))=(t : ℝ)*p.value (ofMatrix K) := by |
| induction t with |
| | zero => simp [CellStream.run,p.one] |
| | succ t ih => |
| have hb := run_block_units K hA hD t |
| have hJ : IsUnit (ofMatrix (CellJoin.join K (CellStream.run K t))) := |
| of_unit _ (Matrix.isUnit_fromBlocks_zero₁₂.mpr ⟨hA,hb.1⟩) (hb.2.mul hD) |
| rw [CellStream.run,of_reindex_data,p.reindex _ _ hJ,of_join K _ hD hb.2, |
| reverseJoin_scalar_price p _ _ (of_unit K hA hD) (of_unit _ hb.1 hb.2),ih] |
| push_cast; ring |
| |
| end ExactFourier.Pivot |
| |
| namespace ExactFourier.MatrixPrice |
| variable {α : Type} [Fintype α] [DecidableEq α] |
|
|
| theorem scalar_pivot_le (p : MatrixPrice) (A : Matrix α α ℂ) |
| (C : Matrix α PUnit ℂ) (B : Matrix PUnit α ℂ) (D : Matrix PUnit PUnit ℂ) |
| (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) := by |
| let K := Matrix.fromBlocks A C B D |
| have h (t : ℕ) : (t : ℝ)*(p.value (Pivot.matrix A C B D)-p.value K)≤4 := by |
| have hb := Pivot.run_block_units K hA hD t |
| have H := p.pivot_bound (CellStream.run K t).toBlocks₁₁ |
| (CellStream.run K t).toBlocks₁₂ (CellStream.run K t).toBlocks₂₁ |
| (CellStream.run K t).toBlocks₂₂ hb.1 hb.2 |
| (by rw [Matrix.fromBlocks_toBlocks]; exact CellStream.unit K hK t) |
| rw [Matrix.fromBlocks_toBlocks] at H |
| change p.value (Pivot.ofMatrix (CellStream.run K t)) ≤ _ at H |
| rw [Pivot.run_pivot_price p K hA hD t,Pivot.run_scalar_price p K hK t] at H |
| simp only [Fintype.card_punit,Nat.cast_one,mul_one] at H |
| change (t:ℝ)*p.value (Pivot.matrix A C B D)≤(t:ℝ)*p.value K+4 at H |
| linarith |
| by_contra hh |
| have hd : 0<p.value (Pivot.matrix A C B D)-p.value K := sub_pos.mpr (lt_of_not_ge hh) |
| obtain ⟨t,ht⟩ := exists_nat_gt (4/(p.value (Pivot.matrix A C B D)-p.value K)) |
| have ht' := (div_lt_iff₀ hd).mp ht |
| linarith [h t] |
|
|
| /-- Exact scalar pivot invariance, 07-pivots:175--240. The proof uses finite |
| single-port chains; its constant four is amortized without any continuity law. -/ |
| theorem scalar_pivot (p : MatrixPrice) (A : Matrix α α ℂ) |
| (C : Matrix α PUnit ℂ) (B : Matrix PUnit α ℂ) (D : Matrix PUnit PUnit ℂ) |
| (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) := by |
| apply le_antisymm (p.scalar_pivot_le A C B D hA hD hK) |
| have hh := p.scalar_pivot_le (A-C*D⁻¹*B) (C*D⁻¹) (-D⁻¹*B) D⁻¹ |
| (Pivot.schur_unit A C B D hD hK) (Matrix.isUnit_nonsing_inv_iff.mpr hD) |
| (Pivot.unit A C B D hA hD) |
| rwa [Pivot.involutive A C B D hD] at hh |
|
|
| end ExactFourier.MatrixPrice |
|
|
| end |
|
|
| section |
| namespace ExactFourier |
| namespace BasisExchange |
| variable {α : Type} [Fintype α] [DecidableEq α] |
|
|
| noncomputable def mix (U V : Matrix (α⊕PUnit) (α⊕PUnit) ℂ) : |
| Matrix (α⊕PUnit) (α⊕PUnit) ℂ := |
| Matrix.fromBlocks U.toBlocks₁₁ U.toBlocks₁₂ V.toBlocks₂₁ V.toBlocks₂₂ |
|
|
| theorem mix_mul |
| {α : Type} [Fintype α] [DecidableEq α] (U V W : Matrix (α⊕PUnit) (α⊕PUnit) ℂ) : |
| mix U V*W=mix (U*W) (V*W) := by |
| ext i j |
| cases i <;> cases j <;> |
| simp [mix,Matrix.fromBlocks,Matrix.toBlocks₁₁,Matrix.toBlocks₁₂, |
| Matrix.toBlocks₂₁,Matrix.toBlocks₂₂,Matrix.mul_apply,Fintype.sum_sum_type,Sum.elim] |
| |
| theorem mix_one_left |
| {α : Type} [Fintype α] [DecidableEq α] (T : Matrix (α⊕PUnit) (α⊕PUnit) ℂ) : |
| mix 1 T=Matrix.fromBlocks 1 0 T.toBlocks₂₁ T.toBlocks₂₂ := by |
| ext i j; cases i <;> cases j <;> simp [mix,Matrix.fromBlocks,Matrix.toBlocks₁₁, |
| Matrix.toBlocks₁₂,Matrix.toBlocks₂₁,Matrix.toBlocks₂₂,Matrix.one_apply] |
| |
| theorem mix_one_right |
| {α : Type} [Fintype α] [DecidableEq α] (T : Matrix (α⊕PUnit) (α⊕PUnit) ℂ) : |
| mix T 1=Matrix.fromBlocks T.toBlocks₁₁ T.toBlocks₁₂ 0 1 := by |
| ext i j; cases i <;> cases j <;> simp [mix,Matrix.fromBlocks,Matrix.toBlocks₁₁, |
| Matrix.toBlocks₁₂,Matrix.toBlocks₂₁,Matrix.toBlocks₂₂] |
| |
| theorem price_split (p : MatrixPrice) (U V : Matrix (α⊕PUnit) (α⊕PUnit) ℂ) |
| (hU : IsUnit U) (hV : IsUnit V) (hU' : IsUnit (mix U V)) (hV' : IsUnit (mix V U)) : |
| p.value (mix V U*(mix U V)⁻¹)=p.value (V*U⁻¹) := by |
| let T := V*U⁻¹ |
| have hi := Matrix.isUnit_nonsing_inv_iff.mpr hU |
| have hT : IsUnit T := hV.mul hi |
| have hUinv := Matrix.mul_nonsing_inv U ((Matrix.isUnit_iff_isUnit_det _).mp hU) |
| have hrel : T*U=V := Matrix.nonsing_inv_mul_cancel_right _ _ ((Matrix.isUnit_iff_isUnit_det _).mp hU) |
| have hL : mix U V*U⁻¹=mix 1 T := by rw [mix_mul,hUinv] |
| have hR : mix V U*U⁻¹=mix T 1 := by rw [mix_mul,hUinv] |
| have huL : IsUnit (mix 1 T) := by rw [← hL]; exact hU'.mul hi |
| have huR : IsUnit (mix T 1) := by rw [← hR]; exact hV'.mul hi |
| rw [mix_one_left] at huL |
| rw [mix_one_right] at huR |
| have hD := (Matrix.isUnit_fromBlocks_zero₁₂.mp huL).2 |
| have hA := (Matrix.isUnit_fromBlocks_zero₂₁.mp huR).1 |
| have hP : Pivot.ofMatrix T*(mix U V)=mix V U := by |
| have hl : mix U V=mix 1 T*U := by rw [mix_mul,Matrix.one_mul,hrel] |
| have hr : mix V U=mix T 1*U := by rw [mix_mul,Matrix.one_mul,hrel] |
| rw [hl,hr,← Matrix.mul_assoc,mix_one_left,mix_one_right] |
| rw [Pivot.ofMatrix,Pivot.solve _ _ _ _ hD] |
| have he : mix V U*(mix U V)⁻¹=Pivot.ofMatrix T := by |
| rw [← hP,Matrix.mul_nonsing_inv_cancel_right _ _ ((Matrix.isUnit_iff_isUnit_det _).mp hU')] |
| rw [he] |
| exact p.scalar_pivot T.toBlocks₁₁ T.toBlocks₁₂ T.toBlocks₂₁ T.toBlocks₂₂ hA hD |
| (by rwa [Matrix.fromBlocks_toBlocks]) |>.trans (by rw [Matrix.fromBlocks_toBlocks]) |
|
|
| variable {ι : Type} [Fintype ι] [DecidableEq ι] |
|
|
| def isolate (i : ι) : ι≃{j : ι // j≠i}⊕PUnit where |
| toFun j := if h : j=i then Sum.inr PUnit.unit else Sum.inl ⟨j,h⟩ |
| invFun := Sum.elim Subtype.val (fun _ => i) |
| left_inv j := by by_cases h : j=i <;> simp [h] |
| right_inv j := by rcases j with ⟨j,h⟩|⟨⟩ <;> simp [*] |
| |
| theorem update_isolate |
| {ι : Type} [Fintype ι] [DecidableEq ι] (U V : Matrix ι ι ℂ) (i : ι) : |
| Matrix.reindex (isolate i) (isolate i) (U.updateRow i (V i))= |
| mix (Matrix.reindex (isolate i) (isolate i) U) (Matrix.reindex (isolate i) (isolate i) V) := by |
| ext a b |
| rcases a with ⟨a,ha⟩|⟨⟩ <;> rcases b with ⟨b,hb⟩|⟨⟩ <;> |
| simp_all [Matrix.reindex_apply,isolate,mix,Matrix.fromBlocks,Matrix.toBlocks₁₁, |
| Matrix.toBlocks₁₂,Matrix.toBlocks₂₁,Matrix.toBlocks₂₂,Matrix.updateRow_apply] |
| |
| /-- Exchange any corresponding members of two bases, assuming exactly that |
| both original and both exchanged lists are bases. -/ |
| theorem price (p : MatrixPrice) (U V : Matrix ι ι ℂ) (i : ι) |
| (hU : IsUnit U) (hV : IsUnit V) |
| (hU' : IsUnit (U.updateRow i (V i))) (hV' : IsUnit (V.updateRow i (U i))) : |
| p.value (V.updateRow i (U i)*(U.updateRow i (V i))⁻¹)=p.value (V*U⁻¹) := by |
| let e := isolate i |
| have h := price_split p (Matrix.reindex e e U) (Matrix.reindex e e V) |
| (TensorTools.unit_reindex _ _ hU) (TensorTools.unit_reindex _ _ hV) |
| (by rw [← update_isolate]; exact TensorTools.unit_reindex _ _ hU') |
| (by rw [← update_isolate]; exact TensorTools.unit_reindex _ _ hV') |
| rw [← update_isolate,← update_isolate,Matrix.inv_reindex,← Reindexed.mul, |
| Matrix.inv_reindex,← Reindexed.mul] at h |
| rw [p.reindex _ _ (hV'.mul (Matrix.isUnit_nonsing_inv_iff.mpr hU')), |
| p.reindex _ _ (hV.mul (Matrix.isUnit_nonsing_inv_iff.mpr hU))] at h |
| exact h |
| |
| end BasisExchange |
| end ExactFourier |
| |
| end |
| |
| section |
| namespace ExactFourier.DensePair |
| open scoped Matrix |
| |
| def J (l : ℂ) : Matrix (Fin 4) (Fin 4) ℂ := |
| !![0,1,0,0;0,0,1,0;0,0,0,1;l,0,0,0] |
| def X (l : ℂ) : Matrix (Fin 4) (Fin 4) ℂ := |
| !![1,1,0,0;0,1,1,0;0,0,1,1;l,0,0,1] |
| def Xb (l : ℂ) : Matrix (Fin 4) (Fin 4) ℂ := |
| !![1,1,0,0;0,1,0,0;0,0,1,1;l,0,0,1] |
| def Xd : Matrix (Fin 4) (Fin 4) ℂ := |
| !![1,1,0,0;0,1,1,0;0,0,1,1;0,0,0,1] |
| def Y1 : Matrix (Fin 4) (Fin 4) ℂ := |
| !![1,0,0,0;0,1,1,0;0,0,1,0;0,0,0,1] |
| def Y2 : Matrix (Fin 4) (Fin 4) ℂ := |
| !![1,1,1,0;0,1,1,0;0,0,1,0;0,0,0,1] |
| def Y3 : Matrix (Fin 4) (Fin 4) ℂ := |
| !![1,1,1,0;0,1,0,0;0,0,1,0;0,0,0,1] |
| def Y4 (l : ℂ) : Matrix (Fin 4) (Fin 4) ℂ := |
| !![1,1,1,0;0,1,0,0;0,0,1,0;l,0,0,1] |
| def Y5 (l : ℂ) : Matrix (Fin 4) (Fin 4) ℂ := |
| !![1,1,1,0;0,1,0,0;l,0,1,1;l,0,0,1] |
| def Y6 (l : ℂ) : Matrix (Fin 4) (Fin 4) ℂ := |
| !![1,1,1,0;0,1,0,0;l,0,1,1;0,0,0,1] |
| |
| def cycle : Equiv.Perm (Fin 4) where |
| toFun := ![3,0,1,2] |
| invFun := ![1,2,3,0] |
| left_inv i := by fin_cases i <;> rfl |
| right_inv i := by fin_cases i <;> rfl |
| |
| theorem J_monomial (l : ℂ) (hl : l≠0) : MonomialMatrix (J l) := by |
| refine ⟨cycle,![l,1,1,1],?_,?_⟩ |
| · intro i; fin_cases i <;> simp [hl] |
| · intro i j; fin_cases i <;> fin_cases j <;> simp [J,cycle] |
| |
| theorem X_eq (l : ℂ) : X l=1+J l := by |
| ext i j; fin_cases i <;> fin_cases j <;> simp [X,J] |
| |
| theorem det_J (l : ℂ) : (J l).det=-l := by |
| rw [Matrix.det_succ_row_zero] |
| norm_num [J,Fin.sum_univ_succ,Matrix.det_fin_three,Matrix.submatrix_apply,Fin.succAbove, |
| Matrix.cons_val_two,Matrix.cons_val_three,Matrix.vecHead,Matrix.vecTail, |
| show (2 : Fin 3) ≠ 0 by decide, |
| show (1 : Fin 3) < 2 by decide, show ¬(2 : Fin 3) ≤ 1 by decide, |
| show (1 : Fin 4) < 2 by decide, show ¬(2 : Fin 4) ≤ 1 by decide] |
|
|
| theorem det_X (l : ℂ) : (X l).det=1-l := by |
| rw [Matrix.det_succ_row_zero] |
| norm_num [X,Fin.sum_univ_succ,Matrix.det_fin_three,Matrix.submatrix_apply,Fin.succAbove, |
| Matrix.cons_val_two,Matrix.cons_val_three,Matrix.vecHead,Matrix.vecTail, |
| show (2 : Fin 3) ≠ 0 by decide, |
| show (1 : Fin 3) < 2 by decide, show ¬(2 : Fin 3) ≤ 1 by decide, |
| show (1 : Fin 4) < 2 by decide, show ¬(2 : Fin 4) ≤ 1 by decide] ; ring |
| |
| theorem det_Xb (l : ℂ) : (Xb l).det=1 := by |
| rw [Matrix.det_succ_row_zero] |
| norm_num [Xb,Fin.sum_univ_succ,Matrix.det_fin_three,Matrix.submatrix_apply,Fin.succAbove, |
| Matrix.cons_val_two,Matrix.cons_val_three,Matrix.vecHead,Matrix.vecTail, |
| show (2 : Fin 3) ≠ 0 by decide, |
| show (1 : Fin 3) < 2 by decide, show ¬(2 : Fin 3) ≤ 1 by decide, |
| show (1 : Fin 4) < 2 by decide, show ¬(2 : Fin 4) ≤ 1 by decide] |
|
|
| theorem det_Xd : Xd.det=1 := by |
| rw [Matrix.det_succ_row_zero] |
| norm_num [Xd,Fin.sum_univ_succ,Matrix.det_fin_three,Matrix.submatrix_apply,Fin.succAbove, |
| Matrix.cons_val_two,Matrix.cons_val_three,Matrix.vecHead,Matrix.vecTail, |
| show (2 : Fin 3) ≠ 0 by decide, |
| show (1 : Fin 3) < 2 by decide, show ¬(2 : Fin 3) ≤ 1 by decide, |
| show (1 : Fin 4) < 2 by decide, show ¬(2 : Fin 4) ≤ 1 by decide] |
|
|
| theorem det_Y1 : Y1.det=1 := by |
| rw [Matrix.det_succ_row_zero] |
| norm_num [Y1,Fin.sum_univ_succ,Matrix.det_fin_three,Matrix.submatrix_apply,Fin.succAbove, |
| Matrix.cons_val_two,Matrix.cons_val_three,Matrix.vecHead,Matrix.vecTail, |
| show (2 : Fin 3) ≠ 0 by decide, |
| show (1 : Fin 3) < 2 by decide, show ¬(2 : Fin 3) ≤ 1 by decide, |
| show (1 : Fin 4) < 2 by decide, show ¬(2 : Fin 4) ≤ 1 by decide] |
|
|
| theorem det_Y2 : Y2.det=1 := by |
| rw [Matrix.det_succ_row_zero] |
| norm_num [Y2,Fin.sum_univ_succ,Matrix.det_fin_three,Matrix.submatrix_apply,Fin.succAbove, |
| Matrix.cons_val_two,Matrix.cons_val_three,Matrix.vecHead,Matrix.vecTail, |
| show (2 : Fin 3) ≠ 0 by decide, |
| show (1 : Fin 3) < 2 by decide, show ¬(2 : Fin 3) ≤ 1 by decide, |
| show (1 : Fin 4) < 2 by decide, show ¬(2 : Fin 4) ≤ 1 by decide] |
|
|
| theorem det_Y3 : Y3.det=1 := by |
| rw [Matrix.det_succ_row_zero] |
| norm_num [Y3,Fin.sum_univ_succ,Matrix.det_fin_three,Matrix.submatrix_apply,Fin.succAbove, |
| Matrix.cons_val_two,Matrix.cons_val_three,Matrix.vecHead,Matrix.vecTail, |
| show (2 : Fin 3) ≠ 0 by decide, |
| show (1 : Fin 3) < 2 by decide, show ¬(2 : Fin 3) ≤ 1 by decide, |
| show (1 : Fin 4) < 2 by decide, show ¬(2 : Fin 4) ≤ 1 by decide] |
|
|
| theorem det_Y4 (l : ℂ) : (Y4 l).det=1 := by |
| rw [Matrix.det_succ_row_zero] |
| norm_num [Y4,Fin.sum_univ_succ,Matrix.det_fin_three,Matrix.submatrix_apply,Fin.succAbove, |
| Matrix.cons_val_two,Matrix.cons_val_three,Matrix.vecHead,Matrix.vecTail, |
| show (2 : Fin 3) ≠ 0 by decide, |
| show (1 : Fin 3) < 2 by decide, show ¬(2 : Fin 3) ≤ 1 by decide, |
| show (1 : Fin 4) < 2 by decide, show ¬(2 : Fin 4) ≤ 1 by decide] |
|
|
| theorem det_Y5 (l : ℂ) : (Y5 l).det=1 := by |
| rw [Matrix.det_succ_row_zero] |
| norm_num [Y5,Fin.sum_univ_succ,Matrix.det_fin_three,Matrix.submatrix_apply,Fin.succAbove, |
| Matrix.cons_val_two,Matrix.cons_val_three,Matrix.vecHead,Matrix.vecTail, |
| show (2 : Fin 3) ≠ 0 by decide, |
| show (1 : Fin 3) < 2 by decide, show ¬(2 : Fin 3) ≤ 1 by decide, |
| show (1 : Fin 4) < 2 by decide, show ¬(2 : Fin 4) ≤ 1 by decide] |
|
|
| theorem det_Y6 (l : ℂ) : (Y6 l).det=1-l := by |
| rw [Matrix.det_succ_row_zero] |
| norm_num [Y6,Fin.sum_univ_succ,Matrix.det_fin_three,Matrix.submatrix_apply,Fin.succAbove, |
| Matrix.cons_val_two,Matrix.cons_val_three,Matrix.vecHead,Matrix.vecTail, |
| show (2 : Fin 3) ≠ 0 by decide, |
| show (1 : Fin 3) < 2 by decide, show ¬(2 : Fin 3) ≤ 1 by decide, |
| show (1 : Fin 4) < 2 by decide, show ¬(2 : Fin 4) ≤ 1 by decide] ; ring |
| |
| theorem exchange01 (l : ℂ) : |
| (1 : Matrix (Fin 4) (Fin 4) ℂ).updateRow 1 (X l 1)=Y1 ∧ |
| (X l).updateRow 1 ((1 : Matrix (Fin 4) (Fin 4) ℂ) 1)=Xb l := by |
| constructor <;> ext i j <;> fin_cases i <;> fin_cases j <;> |
| simp [Y1,X,Xb,Matrix.updateRow_apply] |
| |
| theorem exchange23 (l : ℂ) : Y2.updateRow 1 (Xb l 1)=Y3 ∧ |
| (Xb l).updateRow 1 (Y2 1)=X l := by |
| constructor <;> ext i j <;> fin_cases i <;> fin_cases j <;> |
| simp [Y2,Y3,X,Xb,Matrix.updateRow_apply] |
| |
| theorem exchange34 (l : ℂ) : Y3.updateRow 3 (X l 3)=Y4 l ∧ |
| (X l).updateRow 3 (Y3 3)=Xd := by |
| constructor <;> ext i j <;> fin_cases i <;> fin_cases j <;> |
| simp [Y3,Y4,X,Xd,Matrix.updateRow_apply] |
| |
| theorem exchange56 (l : ℂ) : (Y5 l).updateRow 3 (Xd 3)=Y6 l ∧ |
| Xd.updateRow 3 (Y5 l 3)=X l := by |
| constructor <;> ext i j <;> fin_cases i <;> fin_cases j <;> |
| simp [Y5,Y6,X,Xd,Matrix.updateRow_apply] |
| |
| theorem shear12 : Y2=Matrix.transvection 0 1 1*Y1 := by |
| ext i j; fin_cases i <;> fin_cases j <;> |
| simp [Y1,Y2,Matrix.mul_apply,Fin.sum_univ_succ,Matrix.transvection,Matrix.single,Matrix.one_apply] |
| |
| theorem shear45 (l : ℂ) : Y5 l=Matrix.transvection 2 3 1*Y4 l := by |
| ext i j; fin_cases i <;> fin_cases j <;> |
| simp [Y4,Y5,Matrix.mul_apply,Fin.sum_univ_succ,Matrix.transvection,Matrix.single,Matrix.one_apply] |
| |
| end ExactFourier.DensePair |
| |
| end |
| |
| end OAI |
| |
