| import OAI.Analysis.CharacterCriterion.InfiniteTensor | |
| namespace OAI | |
| noncomputable section | |
| open scoped TensorProduct | |
| open scoped InnerProductSpace | |
| open scoped BigOperators | |
| open Set Module | |
| open Topology | |
| open NormedSpace | |
| open scoped ComplexOrder | |
| open scoped ComplexOrder | |
| open scoped InnerProductSpace | |
| open scoped InnerProductSpace | |
| open NormedSpace | |
| open scoped TensorProduct InnerProductSpace | |
| open UniformSpace | |
| variable [KirchbergRordam.GenericRW.Size] | |
| local notation "rankNum" => KirchbergRordam.GenericRW.Size.n | |
| variable [KirchbergRordam.GenericRW.PauliData] | |
| omit [KirchbergRordam.GenericRW.Size] [KirchbergRordam.GenericRW.PauliData] | |
| open Filter Topology BoundedContinuousFunction | |
| open Filter Topology | |
| open Topology | |
| open scoped TensorProduct CStarAlgebra | |
| open scoped CStarAlgebra ComplexOrder | |
| open NormedSpace | |
| open scoped ComplexOrder | |
| open scoped ComplexOrder | |
| open scoped InnerProductSpace | |
| open scoped CStarAlgebra ComplexOrder | |
| open scoped TensorProduct InnerProductSpace | |
| open UniformSpace | |
| namespace KirchbergRordam.DropMatrixRepresentations | |
| open MatrixDiagonalPath MatrixBlockReindex | |
| open scoped CStarAlgebra ComplexOrder | |
| variable {ι κ : Type*} [Fintype ι] [Fintype κ] [DecidableEq ι] [DecidableEq κ] | |
| lemma left_injective [Nonempty κ] : Function.Injective (MatrixTensor.leftMatrix (ι:=ι) (κ:=κ)) := by | |
| intro a b h | |
| ext i j | |
| let k : κ := Classical.choice inferInstance | |
| have he := congrArg (fun m : Mat (ι×κ) => m (i,k) (j,k)) h | |
| simpa [left_apply] using he | |
| lemma right_injective [Nonempty ι] : Function.Injective (MatrixTensor.rightMatrix (ι:=ι) (κ:=κ)) := by | |
| intro a b h | |
| ext i j | |
| let k : ι := Classical.choice inferInstance | |
| have he := congrArg (fun m : Mat (ι×κ) => m (k,i) (k,j)) h | |
| simpa [right_apply] using he | |
| variable (p q : ℕ) [instNeZerop : NeZero p] [instNeZeroq : NeZero q] | |
| def leftValue (f : PrimeDimensionDrop.Algebra p q) : Mat (Fin p) := Classical.choose f.property.1 | |
| omit instNeZerop instNeZeroq in | |
| lemma leftValue_spec | |
| (p : ℕ) | |
| (q : ℕ) | |
| [NeZero p] | |
| [NeZero q] | |
| (f : PrimeDimensionDrop.Algebra p q) : | |
| MatrixTensor.leftMatrix (κ:=Fin q) (leftValue p q f)=f.val 0 := Classical.choose_spec f.property.1 | |
| def rightValue (f : PrimeDimensionDrop.Algebra p q) : Mat (Fin q) := Classical.choose f.property.2 | |
| omit instNeZerop instNeZeroq in | |
| lemma rightValue_spec | |
| (p : ℕ) | |
| (q : ℕ) | |
| [NeZero p] | |
| [NeZero q] | |
| (f : PrimeDimensionDrop.Algebra p q) : | |
| MatrixTensor.rightMatrix (ι:=Fin p) (rightValue p q f)=f.val 1 := Classical.choose_spec f.property.2 | |
| def leftEvaluation : PrimeDimensionDrop.Algebra p q →⋆ₐ[ℂ] Mat (Fin p) where | |
| toFun := leftValue p q | |
| map_zero' := left_injective (κ:=Fin q) (by rw [map_zero,leftValue_spec]; rfl) | |
| map_one' := left_injective (κ:=Fin q) (by rw [map_one,leftValue_spec]; rfl) | |
| map_add' a b := left_injective (κ:=Fin q) (by rw [leftValue_spec,map_add,leftValue_spec,leftValue_spec]; rfl) | |
| map_mul' a b := left_injective (κ:=Fin q) (by rw [leftValue_spec,map_mul,leftValue_spec,leftValue_spec]; rfl) | |
| commutes' z := left_injective (κ:=Fin q) (by rw [AlgHomClass.commutes,leftValue_spec]; rfl) | |
| map_star' a := left_injective (κ:=Fin q) (by rw [leftValue_spec,map_star,leftValue_spec]; rfl) | |
| def rightEvaluation : PrimeDimensionDrop.Algebra p q →⋆ₐ[ℂ] Mat (Fin q) where | |
| toFun := rightValue p q | |
| map_zero' := right_injective (ι:=Fin p) (by rw [map_zero,rightValue_spec]; rfl) | |
| map_one' := right_injective (ι:=Fin p) (by rw [map_one,rightValue_spec]; rfl) | |
| map_add' a b := right_injective (ι:=Fin p) (by rw [rightValue_spec,map_add,rightValue_spec,rightValue_spec]; rfl) | |
| map_mul' a b := right_injective (ι:=Fin p) (by rw [rightValue_spec,map_mul,rightValue_spec,rightValue_spec]; rfl) | |
| commutes' z := right_injective (ι:=Fin p) (by rw [AlgHomClass.commutes,rightValue_spec]; rfl) | |
| map_star' a := right_injective (ι:=Fin p) (by rw [rightValue_spec,map_star,rightValue_spec]; rfl) | |
| lemma two_three (r : ℕ) (hr : 2≤r) : ∃ a b : ℕ, 2*a+3*b=r := by | |
| by_cases h : r%2=0 | |
| · exact ⟨r/2,0,by omega⟩ | |
| · have hr3 : 3≤r := by omega | |
| exact ⟨(r-3)/2,1,by omega⟩ | |
| def blockRepresentation (a b : ℕ) : DimensionDrop23 →⋆ₐ[ℂ] | |
| Mat ((Fin 2×Fin a) ⊕ (Fin 3×Fin b)) := | |
| sumBlock.comp (((MatrixTensor.leftMatrix (κ:=Fin a)).comp (leftEvaluation 2 3)).prod | |
| ((MatrixTensor.leftMatrix (κ:=Fin b)).comp (rightEvaluation 2 3))) | |
| def representation (ι : Type*) [Fintype ι] [DecidableEq ι] (hι : 2≤Fintype.card ι) : | |
| DimensionDrop23 →⋆ₐ[ℂ] Mat ι := by | |
| let a := (two_three (Fintype.card ι) hι).choose | |
| let b := (two_three (Fintype.card ι) hι).choose_spec.choose | |
| have h : 2*a+3*b=Fintype.card ι := (two_three (Fintype.card ι) hι).choose_spec.choose_spec | |
| let e : ((Fin 2×Fin a) ⊕ (Fin 3×Fin b)) ≃ ι := | |
| BalancedDropSystem.cardEquiv (by simpa using h) | |
| exact (CStarMatrix.reindexₐ ℂ ℂ e).toStarAlgHom.comp (blockRepresentation a b) | |
| end KirchbergRordam.DropMatrixRepresentations | |
| namespace KirchbergRordam.EndpointMultiplicity | |
| open MatrixDiagonalPath MatrixBlockReindex DiagonalIteration | |
| open scoped ComplexOrder CStarAlgebra | |
| variable {P Q R : Type*} [Fintype P] [Fintype Q] [Fintype R] | |
| [DecidableEq P] [DecidableEq Q] [DecidableEq R] | |
| def leftExpand : P ⊕ ((P×Q)×R) ≃ P × (Unit ⊕ (Q×R)) where | |
| toFun x := match x with | |
| | .inl a => (a,.inl ()) | |
| | .inr ((a,b),r) => (a,.inr (b,r)) | |
| invFun x := match x.2 with | |
| | .inl _ => .inl x.1 | |
| | .inr (b,r) => .inr ((x.1,b),r) | |
| left_inv x := by rcases x with a|⟨⟨a,b⟩,r⟩ <;> rfl | |
| right_inv x := by | |
| rcases x with ⟨a,u|⟨b,r⟩⟩ | |
| · cases u; rfl | |
| · rfl | |
| def rightExpand : Q ⊕ ((P×Q)×R) ≃ Q × (Unit ⊕ (P×R)) where | |
| toFun x := match x with | |
| | .inl b => (b,.inl ()) | |
| | .inr ((a,b),r) => (b,.inr (a,r)) | |
| invFun x := match x.2 with | |
| | .inl _ => .inl x.1 | |
| | .inr (a,r) => .inr ((a,x.1),r) | |
| left_inv x := by rcases x with b|⟨⟨a,b⟩,r⟩ <;> rfl | |
| right_inv x := by | |
| rcases x with ⟨b,u|⟨a,r⟩⟩ | |
| · cases u; rfl | |
| · rfl | |
| lemma leftExpand_matrix (a : Mat P) : | |
| CStarMatrix.reindexₐ ℂ ℂ (leftExpand (Q:=Q) (R:=R)) | |
| (sumBlock (a,block (fun _ : R => MatrixTensor.leftMatrix (κ:=Q) a))) = | |
| MatrixTensor.leftMatrix (κ:=Unit ⊕ (Q×R)) a := by | |
| ext ⟨i,k⟩ ⟨j,l⟩ | |
| rcases k with u|⟨b,r⟩ <;> rcases l with v|⟨c,s⟩ | |
| · cases u; cases v; change a i j = a i j * 1; simp | |
| · cases u; change 0 = a i j * 0; simp | |
| · cases v; change 0 = a i j * 0; simp | |
| · change (if r=s then a i j * (if b=c then 1 else 0) else 0) = | |
| a i j * (if (Sum.inr (b,r) : Unit ⊕ Q×R)=.inr (c,s) then 1 else 0) | |
| by_cases hb : b=c <;> by_cases hr : r=s <;> simp [hb,hr,Prod.ext_iff] | |
| lemma rightExpand_matrix (a : Mat Q) : | |
| CStarMatrix.reindexₐ ℂ ℂ (rightExpand (P:=P) (R:=R)) | |
| (sumBlock (a,block (fun _ : R => MatrixTensor.rightMatrix (ι:=P) a))) = | |
| MatrixTensor.leftMatrix (κ:=Unit ⊕ (P×R)) a := by | |
| ext ⟨i,k⟩ ⟨j,l⟩ | |
| rcases k with u|⟨b,r⟩ <;> rcases l with v|⟨c,s⟩ | |
| · cases u; cases v; change a i j = a i j * 1; simp | |
| · cases u; change 0 = a i j * 0; simp | |
| · cases v; change 0 = a i j * 0; simp | |
| · change (if r=s then (if b=c then 1 else 0) * a i j else 0) = | |
| a i j * (if (Sum.inr (b,r) : Unit ⊕ P×R)=.inr (c,s) then 1 else 0) | |
| by_cases hb : b=c <;> by_cases hr : r=s <;> simp [hb,hr,Prod.ext_iff] | |
| variable {A B C : Type*} [CStarAlgebra A] [CStarAlgebra B] [CStarAlgebra C] | |
| def constHom (ι : Type*) : A →⋆ₐ[ℂ] (ι→A) where | |
| toFun a _ := a | |
| map_zero' := rfl | |
| map_one' := rfl | |
| map_add' _ _ := rfl | |
| map_mul' _ _ := rfl | |
| commutes' _ := rfl | |
| map_star' _ := rfl | |
| def prodUnitary (u : unitary A) (v : unitary B) : unitary (A×B) := | |
| ⟨(u,v),⟨Prod.ext u.property.1 v.property.1,Prod.ext u.property.2 v.property.2⟩⟩ | |
| lemma map_conj (φ : A →⋆ₐ[ℂ] B) (u : unitary A) (a : A) : | |
| φ (conj u a) = conj (Unitary.map (StarMonoidHom.ofClass φ) u) (φ a) := by | |
| change φ ((u:A)*a*star (u:A)) = φ (u:A)*φ a*star (φ (u:A)) | |
| rw [map_mul,map_mul,map_star] | |
| def duplicate : Mat P × Mat Q →⋆ₐ[ℂ] Mat (P ⊕ (Q×R)) := | |
| sumBlock.comp ((StarAlgHom.fst ℂ (Mat P) (Mat Q)).prod | |
| ((block.comp (constHom R)).comp (StarAlgHom.snd ℂ (Mat P) (Mat Q)))) | |
| def duplicateUnitary (v : unitary (Mat Q)) : unitary (Mat (P⊕(Q×R))) := | |
| Unitary.map (StarMonoidHom.ofClass (duplicate (P:=P) (Q:=Q) (R:=R))) | |
| (prodUnitary (1:unitary (Mat P)) v) | |
| lemma conj_duplicate (v : unitary (Mat Q)) (a : Mat P) (b : Mat Q) : | |
| conj (duplicateUnitary (P:=P) (Q:=Q) (R:=R) v) (sumBlock (a,block (fun _ : R => b))) = | |
| sumBlock (a,block (fun _ : R => conj v b)) := by | |
| have hm := map_conj (duplicate (P:=P) (Q:=Q) (R:=R)) (prodUnitary 1 v) (a,b) | |
| change duplicate (conj (prodUnitary 1 v) (a,b)) = _ at hm | |
| change conj (Unitary.map (StarMonoidHom.ofClass (duplicate (P:=P) (Q:=Q) (R:=R))) (prodUnitary 1 v)) | |
| (duplicate (a,b)) = _ | |
| rw [← hm] | |
| change duplicate ((1:Mat P)*a*star (1:Mat P),conj v b)=_ | |
| simp only [star_one,one_mul,mul_one] | |
| rfl | |
| end KirchbergRordam.EndpointMultiplicity | |
| namespace KirchbergRordam.EndpointMultiplicity | |
| open MatrixDiagonalPath MatrixBlockReindex DiagonalIteration | |
| open scoped ComplexOrder CStarAlgebra | |
| variable {P Q R : Type*} [Fintype P] [Fintype Q] [Fintype R] | |
| [DecidableEq P] [DecidableEq Q] [DecidableEq R] | |
| def leftBase (h : 2≤Fintype.card (Unit ⊕ (Q×R))) : | |
| DimensionDrop23 →⋆ₐ[ℂ] Mat (P⊕((P×Q)×R)) := | |
| (CStarMatrix.reindexₐ ℂ ℂ (leftExpand (P:=P) (Q:=Q) (R:=R)).symm).toStarAlgHom.comp | |
| (MatrixTensor.rightMatrix.comp (DropMatrixRepresentations.representation _ h)) | |
| def rightBase (h : 2≤Fintype.card (Unit ⊕ (P×R))) : | |
| DimensionDrop23 →⋆ₐ[ℂ] Mat (Q⊕((P×Q)×R)) := | |
| (CStarMatrix.reindexₐ ℂ ℂ (rightExpand (P:=P) (Q:=Q) (R:=R)).symm).toStarAlgHom.comp | |
| (MatrixTensor.rightMatrix.comp (DropMatrixRepresentations.representation _ h)) | |
| lemma leftBase_commute (h : 2≤Fintype.card (Unit ⊕ (Q×R))) (a : Mat P) | |
| (d : DimensionDrop23) : | |
| Commute (leftBase (P:=P) h d) | |
| (sumBlock (a,block (fun _ : R => MatrixTensor.leftMatrix (κ:=Q) a))) := by | |
| let e := CStarMatrix.reindexₐ ℂ ℂ (leftExpand (P:=P) (Q:=Q) (R:=R)) | |
| apply e.injective | |
| change e (leftBase h d * _)=e (_ * leftBase h d) | |
| rw [map_mul,map_mul,leftExpand_matrix] | |
| have he : e (leftBase (P:=P) h d)=MatrixTensor.rightMatrix | |
| (DropMatrixRepresentations.representation _ h d) := by | |
| simp only [leftBase,StarAlgHom.comp_apply, | |
| CStarMatrix.reindexₐ_symm] | |
| change e (e.symm (MatrixTensor.rightMatrix (DropMatrixRepresentations.representation _ h d))) = _ | |
| exact e.apply_symm_apply _ | |
| rw [he] | |
| exact (MatrixTensor.legs_commute a _).symm.eq | |
| lemma rightBase_commute (h : 2≤Fintype.card (Unit ⊕ (P×R))) (a : Mat Q) | |
| (d : DimensionDrop23) : | |
| Commute (rightBase (Q:=Q) h d) | |
| (sumBlock (a,block (fun _ : R => MatrixTensor.rightMatrix (ι:=P) a))) := by | |
| let e := CStarMatrix.reindexₐ ℂ ℂ (rightExpand (P:=P) (Q:=Q) (R:=R)) | |
| apply e.injective | |
| change e (rightBase h d * _)=e (_ * rightBase h d) | |
| rw [map_mul,map_mul,rightExpand_matrix] | |
| have he : e (rightBase (Q:=Q) h d)=MatrixTensor.rightMatrix | |
| (DropMatrixRepresentations.representation _ h d) := by | |
| simp only [rightBase,StarAlgHom.comp_apply, | |
| CStarMatrix.reindexₐ_symm] | |
| change e (e.symm (MatrixTensor.rightMatrix (DropMatrixRepresentations.representation _ h d))) = _ | |
| exact e.apply_symm_apply _ | |
| rw [he] | |
| exact (MatrixTensor.legs_commute a _).symm.eq | |
| def leftRep (h : 2≤Fintype.card (Unit ⊕ (Q×R))) (v : unitary (Mat (P×Q))) : | |
| DimensionDrop23 →⋆ₐ[ℂ] Mat (P⊕((P×Q)×R)) := | |
| (conj (duplicateUnitary (P:=P) (Q:=P×Q) (R:=R) v)).toStarAlgHom.comp (leftBase (P:=P) (Q:=Q) (R:=R) h) | |
| def rightRep (h : 2≤Fintype.card (Unit ⊕ (P×R))) (v : unitary (Mat (P×Q))) : | |
| DimensionDrop23 →⋆ₐ[ℂ] Mat (Q⊕((P×Q)×R)) := | |
| (conj (duplicateUnitary (P:=Q) (Q:=P×Q) (R:=R) v)).toStarAlgHom.comp (rightBase (P:=P) (Q:=Q) (R:=R) h) | |
| lemma leftRep_commute (h : 2≤Fintype.card (Unit ⊕ (Q×R))) (v : unitary (Mat (P×Q))) | |
| (a : Mat P) (d : DimensionDrop23) : | |
| Commute (leftRep h v d) | |
| (sumBlock (a,block (fun _ : R => conj v (MatrixTensor.leftMatrix (κ:=Q) a)))) := by | |
| have hc := (leftBase_commute h a d).map | |
| (conj (duplicateUnitary (P:=P) (Q:=P×Q) (R:=R) v)).toRingHom | |
| change Commute (conj (duplicateUnitary (P:=P) (Q:=P×Q) (R:=R) v) (leftBase h d)) | |
| (conj (duplicateUnitary (P:=P) (Q:=P×Q) (R:=R) v) | |
| (sumBlock (a,block (fun _ : R => MatrixTensor.leftMatrix (κ:=Q) a)))) at hc | |
| rw [conj_duplicate] at hc | |
| exact hc | |
| lemma rightRep_commute (h : 2≤Fintype.card (Unit ⊕ (P×R))) (v : unitary (Mat (P×Q))) | |
| (a : Mat Q) (d : DimensionDrop23) : | |
| Commute (rightRep h v d) | |
| (sumBlock (a,block (fun _ : R => conj v (MatrixTensor.rightMatrix (ι:=P) a)))) := by | |
| have hc := (rightBase_commute h a d).map | |
| (conj (duplicateUnitary (P:=Q) (Q:=P×Q) (R:=R) v)).toRingHom | |
| change Commute (conj (duplicateUnitary (P:=Q) (Q:=P×Q) (R:=R) v) (rightBase h d)) | |
| (conj (duplicateUnitary (P:=Q) (Q:=P×Q) (R:=R) v) | |
| (sumBlock (a,block (fun _ : R => MatrixTensor.rightMatrix (ι:=P) a)))) at hc | |
| rw [conj_duplicate] at hc | |
| exact hc | |
| variable {D B : Type*} [CStarAlgebra D] [CStarAlgebra B] | |
| lemma commutator_approx (ρ : D →⋆ₐ[ℂ] B) (a b : B) (d : D) {ε : ℝ} | |
| (hc : Commute (ρ d) b) (h : ‖a-b‖≤ε) : | |
| ‖ρ d*a-a*ρ d‖≤2*ε*‖d‖ := by | |
| have he : ρ d*a-a*ρ d=ρ d*(a-b)-(a-b)*ρ d := by | |
| rw [mul_sub,sub_mul,hc.eq] | |
| abel | |
| rw [he] | |
| calc | |
| _ ≤ ‖ρ d‖*‖a-b‖+‖a-b‖*‖ρ d‖ := (norm_sub_le _ _).trans | |
| (add_le_add (norm_mul_le _ _) (norm_mul_le _ _)) | |
| _ ≤ ‖d‖*ε+ε*‖d‖ := add_le_add | |
| (mul_le_mul (NonUnitalStarAlgHom.norm_apply_le ρ d) h (norm_nonneg _) (norm_nonneg _)) | |
| (mul_le_mul h (NonUnitalStarAlgHom.norm_apply_le ρ d) (norm_nonneg _) (le_trans (norm_nonneg _) h)) | |
| _ = _ := by ring | |
| lemma duplicate_difference (a : Mat P) (x y : Mat Q) : | |
| ‖sumBlock (a,block (fun _ : R => x))-sumBlock (a,block (fun _ : R => y))‖≤‖x-y‖ := by | |
| change ‖duplicate (a,x)-duplicate (a,y)‖≤_ | |
| rw [←map_sub] | |
| exact (NonUnitalStarAlgHom.norm_apply_le (duplicate (P:=P) (Q:=Q) (R:=R)) _).trans | |
| (by simp [Prod.norm_def]) | |
| lemma leftRep_bound (h : 2≤Fintype.card (Unit ⊕ (Q×R))) (v : unitary (Mat (P×Q))) | |
| (a : Mat P) (x : Mat (P×Q)) (d : DimensionDrop23) {ε : ℝ} | |
| (hx : ‖x-conj v (MatrixTensor.leftMatrix (κ:=Q) a)‖≤ε) : | |
| ‖leftRep h v d*sumBlock (a,block (fun _ : R => x))- | |
| sumBlock (a,block (fun _ : R => x))*leftRep h v d‖≤2*ε*‖d‖ := | |
| commutator_approx (leftRep h v) _ _ d (leftRep_commute h v a d) | |
| ((duplicate_difference a x _).trans hx) | |
| lemma rightRep_bound (h : 2≤Fintype.card (Unit ⊕ (P×R))) (v : unitary (Mat (P×Q))) | |
| (a : Mat Q) (x : Mat (P×Q)) (d : DimensionDrop23) {ε : ℝ} | |
| (hx : ‖x-conj v (MatrixTensor.rightMatrix (ι:=P) a)‖≤ε) : | |
| ‖rightRep h v d*sumBlock (a,block (fun _ : R => x))- | |
| sumBlock (a,block (fun _ : R => x))*rightRep h v d‖≤2*ε*‖d‖ := | |
| commutator_approx (rightRep h v) _ _ d (rightRep_commute h v a d) | |
| ((duplicate_difference a x _).trans hx) | |
| end KirchbergRordam.EndpointMultiplicity | |
| end | |
| end OAI | |