| import OAI.Computability.FourierCircuit.RationalClearing |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.SparseReflection |
| variable {α : Type} [Fintype α] [DecidableEq α] |
| |
| /-- Algebraic certificate for the real orthogonal reflection in the kernel, together |
| with its uniform sparse price. Both annihilator equations are retained. -/ |
| theorem spectral_price (p : MatrixPrice) (A : Matrix α α ℝ) (hA : A.IsSymm) |
| (d : α → ℂ) (L : List (PairTerm α)) |
| (hL : RealMatrix.complex A=Matrix.diagonal d+(L.map PairTerm.direction).sum) : |
| ∃ R T : Matrix α α ℂ,R*R=1 ∧ R.IsSymm ∧ |
| RealMatrix.complex A*(1+R)=0 ∧ 1-R=RealMatrix.complex A*T ∧ |
| p.value R≤(3:ℝ)/2*L.length+2*Fintype.card α := by |
| obtain ⟨U,a,hU,hi,he⟩ := RealMatrix.diagonalization A hA |
| let V := RealMatrix.complex U |
| let b : α → ℂ := fun i => (a i : ℂ) |
| have hV : IsUnit V := RealMatrix.unit U hU |
| have hec : RealMatrix.complex A=Similarity.conj V (Matrix.diagonal b) := by |
| rw [he,RealMatrix.map_mul,RealMatrix.map_mul,RealMatrix.map_diagonal,RealMatrix.inv U hU] |
| rfl |
| have hiv : V⁻¹=V.transpose := by rw [← RealMatrix.inv U hU,hi,RealMatrix.map_transpose] |
| let R := Similarity.conj V (Matrix.diagonal (CayleyLimit.sign b)) |
| refine ⟨R,Similarity.conj V (Matrix.diagonal (CayleyLimit.reciprocal b)), |
| CayleyLimit.reflection_square V hV b,CayleyLimit.reflection_symm V hiv b,?_,?_,?_⟩ |
| · rw [hec]; exact CayleyLimit.killed_sum V hV b |
| · rw [hec]; exact CayleyLimit.difference_factor V hV b |
| · apply CayleyLimit.price p V hV b |
| intro t hp hm |
| obtain ⟨Q,E,hQ0,hQ⟩ := exists_tangent p d L |
| have heQ : Q.map (Polynomial.eval 0)=Similarity.conj V (Matrix.diagonal b) := by |
| rw [← hec,hL]; exact hQ0 |
| rw [← heQ] at hp hm ⊢ |
| exact p.cayley_tangent Q E ((3:ℝ)/2*L.length) hQ t hp hm |
|
|
| end ExactFourier.SparseReflection |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.SparseReflection |
| variable {α : Type} [Fintype α] [LinearOrder α] |
|
|
| def pairs (A : Matrix α α ℂ) : Finset (α×α) := Finset.univ.filter (fun ij=>ij.1 < ij.2 ∧ A ij.1 ij.2≠0) |
|
|
| @[simp] theorem mem_pairs (A : Matrix α α ℂ) (ij : α×α) : ij∈pairs A ↔ ij.1 < ij.2 ∧ A ij.1 ij.2≠0 := by simp [pairs] |
|
|
| def term (A : Matrix α α ℂ) (hA : A.IsSymm) (ij : {ij // ij∈pairs A}) : PairTerm α := |
| ⟨ij.1.1,ij.1.2,ne_of_lt ((mem_pairs A ij).mp ij.2).1,A ij.1.1 ij.1.2,A ij.1.2 ij.1.1, |
| ((mem_pairs A ij).mp ij.2).2,by |
| have hh : A ij.1.2 ij.1.1=A ij.1.1 ij.1.2 := congrFun (congrFun hA ij.1.1) ij.1.2 |
| rw [hh]; exact ((mem_pairs A ij).mp ij.2).2⟩ |
| |
| def terms (A : Matrix α α ℂ) (hA : A.IsSymm) : List (PairTerm α) := |
| (pairs A).attach.toList.map (term A hA) |
|
|
| @[simp] theorem terms_length (A : Matrix α α ℂ) (hA : A.IsSymm) : (terms A hA).length=(pairs A).card := by simp [terms] |
|
|
| theorem terms_sum (A : Matrix α α ℂ) (hA : A.IsSymm) : |
| ((terms A hA).map PairTerm.direction).sum= |
| ∑ ij∈pairs A,(Matrix.single ij.1 ij.2 (A ij.1 ij.2)+Matrix.single ij.2 ij.1 (A ij.2 ij.1)) := by |
| simp only [terms,List.map_map,Finset.sum_map_toList,Function.comp_def,term,PairTerm.direction] |
| exact Finset.sum_attach (pairs A) (fun ij => (Matrix.single ij.1 ij.2 (A ij.1 ij.2)+Matrix.single ij.2 ij.1 (A ij.2 ij.1))) |
|
|
| theorem decomposition (A : Matrix α α ℂ) (hA : A.IsSymm) : |
| A=Matrix.diagonal (fun i=>A i i)+((terms A hA).map PairTerm.direction).sum := by |
| rw [terms_sum,Finset.sum_add_distrib] |
| ext i j |
| have hl : (∑ ij∈pairs A,Matrix.single ij.1 ij.2 (A ij.1 ij.2)) i j= |
| if (i,j)∈pairs A then A i j else 0 := by |
| simp only [Matrix.sum_apply,Matrix.single_apply,← Prod.mk.injEq,Prod.mk.eta] |
| simp |
| have hr : (∑ ij∈pairs A,Matrix.single ij.2 ij.1 (A ij.2 ij.1)) i j= |
| if (j,i)∈pairs A then A i j else 0 := by |
| simp only [Matrix.sum_apply,Matrix.single_apply,and_comm (b := _=j),← Prod.mk.injEq,Prod.mk.eta] |
| simp |
| simp only [Matrix.add_apply,hl,hr,mem_pairs] |
| by_cases hij : i=j |
| · subst j; simp |
| · rcases lt_or_gt_of_ne hij with hlt|hlt |
| · simp [hij,hlt,not_lt_of_ge hlt.le] |
| · simp [hij,hlt,not_lt_of_ge hlt.le,hA.apply i j] |
| |
| theorem twice_pairs_le (A : Matrix α α ℂ) (hA : A.IsSymm) : 2*(pairs A).card≤nnz A := by |
| classical |
| let e : (α×α) ≃ (α×α) := Equiv.prodComm α α |
| have hd : Disjoint (pairs A) ((pairs A).map e.toEmbedding) := by |
| apply Finset.disjoint_left.mpr |
| intro ij hi hj |
| obtain ⟨ji,hji,he⟩ := Finset.mem_map.mp hj |
| subst ij |
| have h1 := ((mem_pairs A _).mp hi).1 |
| have h2 := ((mem_pairs A _).mp hji).1 |
| exact not_lt_of_ge h2.le h1 |
| have hs : pairs A∪(pairs A).map e.toEmbedding⊆support A := by |
| intro ij hij |
| rcases Finset.mem_union.mp hij with h|h |
| · exact (mem_support A ij).mpr ((mem_pairs A ij).mp h).2 |
| · obtain ⟨ji,hji,rfl⟩ := Finset.mem_map.mp h |
| apply (mem_support A _).mpr |
| change A ji.2 ji.1≠0 |
| rw [show A ji.2 ji.1=A ji.1 ji.2 from congrFun (congrFun hA ji.1) ji.2] |
| exact ((mem_pairs A _).mp hji).2 |
| have hh := Finset.card_le_card hs |
| rw [Finset.card_union_of_disjoint hd,Finset.card_map] at hh |
| simpa [two_mul,nnz] using hh |
|
|
| end ExactFourier.SparseReflection |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.SparseReflection |
| variable {α : Type} [Fintype α] [LinearOrder α] |
|
|
| /-- Uniform sparse reflection certificate, with supported unordered pairs counted exactly. |
| The annihilator identities characterize the reflection when A is real symmetric. -/ |
| theorem exists_reflection (p : MatrixPrice) (A : Matrix α α ℂ) (hA : A.IsSymm) |
| (hreal : ∀ i j,star (A i j)=A i j) : |
| ∃ R T : Matrix α α ℂ,R*R=1 ∧ R.IsSymm ∧ A*(1+R)=0 ∧ 1-R=A*T ∧ |
| p.value R≤(3:ℝ)/2*(pairs A).card+2*Fintype.card α := by |
| have hre := RealMatrix.complex_re A hreal |
| obtain ⟨R,T,hR,hs,hp,hm,hc⟩ := spectral_price p (A.map Complex.re) (RealMatrix.re_symm A hA) |
| (fun i=>A i i) (terms A hA) (by rw [hre]; exact decomposition A hA) |
| rw [hre] at hp hm |
| exact ⟨R,T,hR,hs,hp,hm,by simpa using hc⟩ |
| |
| theorem exists_reflection_nnz (p : MatrixPrice) (A : Matrix α α ℂ) (hA : A.IsSymm) |
| (hreal : ∀ i j,star (A i j)=A i j) : |
| ∃ R T : Matrix α α ℂ,R*R=1 ∧ R.IsSymm ∧ A*(1+R)=0 ∧ 1-R=A*T ∧ |
| p.value R≤(3:ℝ)/4*nnz A+2*Fintype.card α := by |
| obtain ⟨R,T,hR,hs,hp,hm,hc⟩ := exists_reflection p A hA hreal |
| refine ⟨R,T,hR,hs,hp,hm,?_⟩ |
| have hh : (2:ℝ)*(pairs A).card≤nnz A := by exact_mod_cast twice_pairs_le A hA |
| linarith |
|
|
| end ExactFourier.SparseReflection |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.SymLap |
| open scoped Kronecker |
| variable {α : Type} [Fintype α] [DecidableEq α] |
|
|
| theorem relations (G J R T : Matrix α α ℂ) (M A : Matrix α α ℂ) |
| (hJ : IsUnit J) (hG : IsUnit G) (hA : A=J*G*(1-M)) |
| (hs : A.IsSymm) (hk : A*(1+M)=0) (hp : A*(1+R)=0) (hm : 1-R=A*T) : |
| M*(1+R)=1+R ∧ M.transpose*(1-R)=-(1-R) := by |
| have hl : (1-M)*(1+R)=0 := by |
| apply (hJ.mul hG).mul_left_cancel |
| rw [← mul_assoc,← hA,hp,mul_zero] |
| have hrt : (1+M.transpose)*A=0 := by |
| have ht := congrArg Matrix.transpose hk |
| simpa [Matrix.transpose_mul,Matrix.transpose_add,hs.eq] using ht |
| constructor |
| · rw [sub_mul,one_mul,sub_eq_zero] at hl |
| exact hl.symm |
| · have ht : (1+M.transpose)*(1-R)=0 := by rw [hm,← mul_assoc,hrt,zero_mul] |
| rw [add_mul,one_mul] at ht |
| exact eq_neg_of_add_eq_zero_right ht |
|
|
| theorem exists_tensor_reflection (p : MatrixPrice) (G J : Matrix α α ℂ) |
| (hG : G*G=1) (hJ : MonomialMatrix J) |
| (s : ℂ) (hs : s*s=1) (ht : J.transpose=s•J) (hc : J*G=G.transpose*J) |
| (hrG : ∀ i j,star (G i j)=G i j) (hrJ : ∀ i j,star (J i j)=J i j) : |
| ∃ R : Matrix (α×α) (α×α) ℂ, R*R=1 ∧ R.IsSymm ∧ |
| tensor G*(1+R)=1+R ∧ (tensor G).transpose*(1-R)=-(1-R) ∧ |
| p.value R≤(3:ℝ)/4*(2*nnz G*Fintype.card α)+2*(Fintype.card α)^2 := by |
| let ord := LinearOrder.lift' (Fintype.equivFin (α×α)) (Fintype.equivFin (α×α)).injective |
| let deq : DecidableEq (α×α) := inferInstance |
| let : LinearOrder (α×α) := { ord with |
| toDecidableEq := deq |
| compare := fun a b => @compareOfLessAndEq _ a b ord.toLT (ord.toDecidableLT a b) deq |
| compare_eq_compareOfLessAndEq := by intro a b; rfl } |
| let A := symmetrized G J |
| have hAs : A.IsSymm := symmetric G J s hs ht hc |
| obtain ⟨R,T,hR,hrs,hp,hm,hpr⟩ := SparseReflection.exists_reflection_nnz p A hAs |
| (real_entries G J hrG hrJ) |
| have huG : IsUnit G := isUnit_iff_exists_inv'.mpr ⟨G,hG⟩ |
| have huJ := MonomialMatrix.unit J hJ |
| have hfactor : A=(J⊗ₖJ)*(G⊗ₖ(1 : Matrix α α ℂ))*(1-tensor G) := by |
| dsimp only [A,symmetrized] |
| rw [lap_factor G hG,mul_assoc] |
| have hk : A*(1+tensor G)=0 := by |
| dsimp only [A,symmetrized] |
| rw [mul_assoc,lap_kill G hG,mul_zero] |
| obtain ⟨hrp,hrm⟩ := relations (G⊗ₖ(1 : Matrix α α ℂ)) (J⊗ₖJ) R T (tensor G) A |
| (TensorTools.unit_tensor _ _ huJ huJ) (TensorTools.unit_tensor _ _ huG isUnit_one) |
| hfactor hAs hk hp hm |
| refine ⟨R,hR,hrs,hrp,hrm,?_⟩ |
| have hb : (nnz A : ℝ)≤2*nnz G*Fintype.card α := by exact_mod_cast support_bound G J hJ |
| simp only [Fintype.card_prod,Nat.cast_mul] at hpr |
| nlinarith |
|
|
| end ExactFourier.SymLap |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.SignedBits |
|
|
| def parity : (m : ℕ) → Bits m → Bool |
| | 0, _ => false |
| | m+1, .inl i => parity m i |
| | m+1, .inr i => !(parity m i) |
|
|
| theorem D_parity (m : ℕ) : ∀ i j,parity m i=parity m j → D m i j=0 := by |
| induction m with |
| | zero => simp [D] |
| | succ m ih => |
| intro i j hij |
| rcases i with i|i <;> rcases j with j|j |
| · exact ih i j hij |
| · rfl |
| · have hn : i≠j := by intro he; subst j; simp [parity] at hij |
| simp [D,hn] |
| · change -(D m i j)=0 |
| have he : parity m i=parity m j := by simpa [parity] using hij |
| rw [ih i j he,neg_zero] |
|
|
| theorem Gamma_parity (m : ℕ) : ∀ i j,parity (m+1) i=parity (m+1) j → Gamma m i j=0 := by |
| intro i j hij |
| rcases i with i|i <;> rcases j with j|j |
| · exact D_parity m i j hij |
| · have hn : i≠j := by intro he; subst j; simp [parity] at hij |
| simp [Gamma,hn] |
| · have hn : i≠j := by intro he; subst j; simp [parity] at hij |
| simp [Gamma,hn] |
| · change -(D m i j)=0 |
| have he : parity m i=parity m j := by simpa [parity] using hij |
| rw [D_parity m i j he,neg_zero] |
|
|
| def paritySwitch (m : ℕ) : Bits (m+1) → Bits (m+1) |
| | .inl i => if parity m i then .inr i else .inl i |
| | .inr i => if parity m i then .inl i else .inr i |
|
|
| theorem paritySwitch_involutive (m : ℕ) : Function.Involutive (paritySwitch m) := by |
| intro i; rcases i with i|i <;> cases he : parity m i <;> simp [paritySwitch,he] |
| |
| def parityEquiv (m : ℕ) : (Bits m⊕Bits m) ≃ Bits (m+1) := |
| (paritySwitch_involutive m).toPerm |
|
|
| theorem parityEquiv_left (m : ℕ) (i : Bits m) : parity (m+1) (parityEquiv m (.inl i))=false := by |
| change parity (m+1) (paritySwitch m (.inl i))=false |
| cases he : parity m i <;> simp [paritySwitch,parity,he] |
| |
| theorem parityEquiv_right (m : ℕ) (i : Bits m) : parity (m+1) (parityEquiv m (.inr i))=true := by |
| change parity (m+1) (paritySwitch m (.inr i))=true |
| cases he : parity m i <;> simp [paritySwitch,parity,he] |
| |
| end ExactFourier.SignedBits |
| |
| end |
| end |
| |
| section |
| noncomputable section |
| namespace ExactFourier.GraphReflection |
| open scoped ComplexOrder |
| variable {α : Type} [Fintype α] [DecidableEq α] |
|
|
| def swap : Matrix (α⊕α) (α⊕α) ℂ := Matrix.fromBlocks 0 1 1 0 |
|
|
| theorem swap_monomial |
| {α : Type} [Fintype α] [DecidableEq α] : MonomialMatrix (swap (α := α)) := by |
| refine ⟨Equiv.sumComm α α,fun _=>1,by simp,?_⟩ |
| intro i j; rcases i with i|i <;> rcases j with j|j <;> simp [swap,Matrix.one_apply] |
| |
| theorem swap_square : swap (α := α)*swap=1 := by simp [swap,Matrix.fromBlocks_multiply,← Matrix.fromBlocks_one] |
|
|
| def hadamard : Matrix (α⊕α) (α⊕α) ℂ := Matrix.fromBlocks 1 1 1 (-1) |
|
|
| theorem hadamard_square : hadamard (α := α)*hadamard=(2:ℂ)•1 := by |
| simp [hadamard,Matrix.fromBlocks_multiply,← Matrix.fromBlocks_one,← two_smul ℂ (1 : Matrix α α ℂ),Matrix.fromBlocks_smul] |
|
|
| theorem hadamard_unit : IsUnit (hadamard (α := α)) := by |
| apply isUnit_iff_exists_inv'.mpr |
| refine ⟨(1/2:ℂ)•hadamard,?_⟩ |
| rw [Matrix.smul_mul,hadamard_square,smul_smul] |
| norm_num |
|
|
| theorem hadamard_price (p : MatrixPrice) : p.value (hadamard (α := α))≤2*Fintype.card α := by |
| let F : Matrix (Fin 2) (Fin 2) ℂ := !![1,1;1,-1] |
| have hF : IsUnit F := by rw [Matrix.isUnit_iff_isUnit_det,Matrix.det_fin_two]; norm_num [F] |
| have he : hadamard (α := α)=pairLayer F := by rw [pairLayer_eq]; simp [hadamard,F] |
| rw [he]; exact p.pair_layer F hF |
| |
| noncomputable def graph (B : Matrix α α ℂ) : Matrix (α⊕α) (α⊕α) ℂ := Matrix.fromBlocks 0 B B⁻¹ 0 |
|
|
| theorem graph_square (B : Matrix α α ℂ) (hB : IsUnit B) : graph B*graph B=1 := by |
| have hi := Matrix.nonsing_inv_mul B ((Matrix.isUnit_iff_isUnit_det _).mp hB) |
| have hj := Matrix.mul_nonsing_inv B ((Matrix.isUnit_iff_isUnit_det _).mp hB) |
| simp [graph,Matrix.fromBlocks_multiply,hi,hj,← Matrix.fromBlocks_one] |
|
|
| theorem graph_price (p : MatrixPrice) (B : Matrix α α ℂ) (hB : IsUnit B) : p.value (graph B)=2*p.value B := by |
| have hG : IsUnit (graph B) := isUnit_iff_exists_inv'.mpr ⟨graph B,graph_square B hB⟩ |
| have hh := p.monomial (graph B) 1 swap hG MonomialMatrix.one swap_monomial |
| rw [one_mul] at hh |
| have he : graph B*swap=Matrix.fromBlocks B 0 0 B⁻¹ := by simp [graph,swap,Matrix.fromBlocks_multiply] |
| rw [he,p.directSum _ _ hB (Matrix.isUnit_nonsing_inv_iff.mpr hB),p.inverse _ hB] at hh |
| linarith |
|
|
| theorem gram_unit (B : Matrix α α ℂ) (hB : ∀ i j,star (B i j)=B i j) : IsUnit (1+B.transpose*B) := by |
| have he : B.conjTranspose=B.transpose := by ext i j; exact hB j i |
| rw [← he] |
| exact (Matrix.PosDef.one.add_posSemidef (Matrix.posSemidef_conjTranspose_mul_self B)).isUnit |
| |
| end ExactFourier.GraphReflection |
| |
| end |
| end |
| |
| section |
| noncomputable section |
| namespace ExactFourier.SignedBits |
| open scoped Kronecker |
| |
| abbrev Half (m : ℕ) := Bits m × Bits (m+1) |
| def tensorParityEquiv (m : ℕ) : (Half m⊕Half m) ≃ Bits (m+1)×Bits (m+1) := |
| (Equiv.sumProdDistrib (Bits m) (Bits m) (Bits (m+1))).symm.trans |
| (Equiv.prodCongr (parityEquiv m) (Equiv.refl _)) |
|
|
| def parityTensor (m : ℕ) : Matrix (Half m⊕Half m) (Half m⊕Half m) ℂ := |
| (SymLap.tensor (Gamma m)).submatrix (tensorParityEquiv m) (tensorParityEquiv m) |
|
|
| theorem parityTensor_square (m : ℕ) : parityTensor m*parityTensor m=1 := by |
| rw [parityTensor,Matrix.submatrix_mul_equiv,SymLap.tensor_square _ (Gamma_square m)] |
| simp |
|
|
| theorem parityTensor_diag_left (m : ℕ) : (parityTensor m).toBlocks₁₁=0 := by |
| ext i j |
| change Gamma m (parityEquiv m (.inl i.1)) (parityEquiv m (.inl j.1))*Gamma m i.2 j.2=0 |
| rw [Gamma_parity m _ _ (by rw [parityEquiv_left,parityEquiv_left]),zero_mul] |
|
|
| theorem parityTensor_diag_right (m : ℕ) : (parityTensor m).toBlocks₂₂=0 := by |
| ext i j |
| change Gamma m (parityEquiv m (.inr i.1)) (parityEquiv m (.inr j.1))*Gamma m i.2 j.2=0 |
| rw [Gamma_parity m _ _ (by rw [parityEquiv_right,parityEquiv_right]),zero_mul] |
|
|
| def graphB (m : ℕ) : Matrix (Half m) (Half m) ℂ := (parityTensor m).toBlocks₁₂ |
|
|
| theorem graphB_unit (m : ℕ) : IsUnit (graphB m) := by |
| have h := congrArg Matrix.toBlocks₁₁ (parityTensor_square m) |
| rw [← Matrix.fromBlocks_toBlocks (parityTensor m),parityTensor_diag_left,parityTensor_diag_right] at h |
| simp only [Matrix.fromBlocks_multiply,zero_mul,mul_zero,zero_add,add_zero, |
| Matrix.toBlocks_fromBlocks₁₁] at h |
| rw [← Matrix.fromBlocks_one,Matrix.toBlocks_fromBlocks₁₁] at h |
| exact isUnit_iff_exists_inv.mpr ⟨(parityTensor m).toBlocks₂₁,h⟩ |
|
|
| theorem parityTensor_graph (m : ℕ) : parityTensor m=GraphReflection.graph (graphB m) := by |
| have h := congrArg Matrix.toBlocks₂₂ (parityTensor_square m) |
| rw [← Matrix.fromBlocks_toBlocks (parityTensor m),parityTensor_diag_left,parityTensor_diag_right] at h |
| simp only [Matrix.fromBlocks_multiply,zero_mul,mul_zero,zero_add,add_zero, |
| Matrix.toBlocks_fromBlocks₂₂] at h |
| rw [← Matrix.fromBlocks_one,Matrix.toBlocks_fromBlocks₂₂] at h |
| have hi : (parityTensor m).toBlocks₂₁=(graphB m)⁻¹ := (Matrix.inv_eq_left_inv h).symm |
| conv_lhs => rw [← Matrix.fromBlocks_toBlocks (parityTensor m)] |
| rw [parityTensor_diag_left,parityTensor_diag_right,hi] |
| rfl |
|
|
| theorem graphB_real (m : ℕ) : ∀ i j,star (graphB m i j)=graphB m i j := by |
| intro i j |
| change star (Gamma m (parityEquiv m (.inl i.1)) (parityEquiv m (.inr j.1))*Gamma m i.2 j.2)=_ |
| rw [star_mul,Gamma_star,Gamma_star] |
| exact mul_comm _ _ |
|
|
| end ExactFourier.SignedBits |
|
|
| end |
| end |
|
|
| end OAI |
|
|
