| import OAI.Analysis.CharacterCriterion.CubeCalculus |
|
|
| 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 [instSize : KirchbergRordam.GenericRW.Size] |
| local notation "rankNum" => KirchbergRordam.GenericRW.Size.n |
| variable [instPauliData : KirchbergRordam.GenericRW.PauliData] |
|
|
|
|
| namespace KirchbergRordam.GenericRW.ConeCube |
| open scoped CStarAlgebra BigOperators ComplexOrder |
| open ConeModel _root_.OAI.KirchbergRordam.GenericRW.MaxTensor |
| abbrev Cube (n : ℕ) := Fin (n+1)→unitInterval |
| abbrev Tensor (n : ℕ) := powerPack Cone n |
| abbrev Fiber (n : ℕ) := PauliPower.CMat n |
| abbrev Label (n : ℕ) := PauliPower.Label n |
|
|
| def post {X A B : Type*} [TopologicalSpace X] [CStarAlgebra A] [CStarAlgebra B] |
| (φ : A→⋆ₐ[ℂ] B) : C(X,A)→⋆ₐ[ℂ] C(X,B) where |
| toFun f := ⟨φ∘f,(map_continuous φ).comp f.continuous⟩ |
| map_zero' := by ext t; exact map_zero φ |
| map_one' := by ext t; exact map_one φ |
| map_add' f g := by ext t; exact map_add φ _ _ |
| map_mul' f g := by ext t; exact map_mul φ _ _ |
| commutes' c := by ext t; exact φ.commutes c |
| map_star' f := by ext t; exact map_star φ _ |
|
|
| def first (n : ℕ) : C(Cube n,unitInterval) := ⟨fun t=>t 0,continuous_apply 0⟩ |
| def tail (n : ℕ) : C(Cube (n+1),Cube n) := ⟨fun t i=>t i.succ,by fun_prop⟩ |
|
|
| def matLeg : (n : ℕ)→Fin (n+1)→M2→⋆ₐ[ℂ] Fiber n |
| | 0,_ => StarAlgHom.id ℂ M2 |
| | n+1,i => Fin.cases MatrixTensor.leftMatrix |
| (fun j=>MatrixTensor.rightMatrix.comp (matLeg n j)) i |
|
|
| def repr : (n : ℕ)→Tensor n→⋆ₐ[ℂ] C(Cube n,Fiber n) |
| | 0 => ((first 0).compStarAlgHom' ℂ M2).comp coneSubalgebra.subtype |
| | n+1 => |
| let l := (post (MatrixTensor.leftMatrix (κ:=PauliPower.Row n))).comp |
| (((first (n+1)).compStarAlgHom' ℂ M2).comp coneSubalgebra.subtype) |
| let r := (post (MatrixTensor.rightMatrix (ι:=Fin Size.n))).comp |
| (((tail n).compStarAlgHom' ℂ (Fiber n)).comp (repr n)) |
| lift l r (by intro a b; apply ContinuousMap.ext; intro t; exact (MatrixTensor.legs_commute _ _).eq) |
|
|
| lemma repr_left (n : ℕ) (a : Cone) (t : Cube (n+1)) : |
| repr (n+1) (includeLeft a) t=MatrixTensor.leftMatrix (κ:=PauliPower.Row n) ((a:C(unitInterval,M2)) (t 0)) := by |
| exact DFunLike.congr_fun (DFunLike.congr_fun (lift_includeLeft _ _ _) a) t |
| lemma repr_right (n : ℕ) (b : Tensor n) (t : Cube (n+1)) : |
| repr (n+1) (includeRight b) t=MatrixTensor.rightMatrix (ι:=Fin Size.n) (repr n b (tail n t)) := by |
| exact DFunLike.congr_fun (DFunLike.congr_fun (lift_includeRight _ _ _) b) t |
| lemma repr_leg (n : ℕ) (i : Fin (n+1)) (a : Cone) (t : Cube n) : |
| repr n (leg Cone n i a) t=matLeg n i ((a:C(unitInterval,M2)) (t i)) := by |
| induction n with |
| | zero => |
| change (a:C(unitInterval,M2)) (t 0)=(a:C(unitInterval,M2)) (t i) |
| rw [Fin.eq_zero i] |
| | succ n ih => |
| induction i using Fin.cases with |
| | zero => exact repr_left n a t |
| | succ i => |
| change repr (n+1) (includeRight (leg Cone n i a)) t=_ |
| rw [repr_right,ih] |
| rfl |
|
|
| lemma scalar_leg_commute (n : ℕ) (i : Fin (n+1)) (f : C(unitInterval,ℂ)) (a : Tensor n) : |
| Commute (leg Cone n i (scalar f)) a := by |
| apply commute_of_power_legs n (StarAlgHom.id ℂ (Tensor n)) _ _ a |
| intro j b |
| change Commute (leg Cone n i (scalar f)) (leg Cone n j b) |
| by_cases hij : i=j |
| · subst j; exact (ConePauli.scalar_commute f b).map (leg Cone n i) |
| · exact commute_legs Cone n i j hij (scalar f) b |
|
|
| def scalarLeg (n : ℕ) (i : Fin (n+1)) : C(unitInterval,ℂ)→⋆ₐ[ℂ] Tensor n := |
| (leg Cone n i).comp scalar |
| def κ (n : ℕ) : C(Cube n,ℂ)→⋆ₐ[ℂ] Tensor n := |
| CentralCalculus.hom (scalarLeg n) (scalar_leg_commute n) |
| lemma κ_commute (n : ℕ) (f : C(Cube n,ℂ)) (a : Tensor n) : Commute (κ n f) a := |
| CentralCalculus.hom_commute _ _ f a |
| lemma κ_coordinate (n : ℕ) (i : Fin (n+1)) (f : C(unitInterval,ℂ)) : |
| κ n (JointCalculus.coordinate i f)=leg Cone n i (scalar f) := |
| CentralCalculus.hom_coordinate _ _ i f |
|
|
| def point {X A : Type*} [TopologicalSpace X] [CStarAlgebra A] (t : X) : C(X,A)→⋆ₐ[ℂ] A where |
| toFun f := f t |
| map_zero' := rfl |
| map_one' := rfl |
| map_add' _ _ := rfl |
| map_mul' _ _ := rfl |
| commutes' _ := rfl |
| map_star' _ := rfl |
| lemma repr_κ (n : ℕ) (f : C(Cube n,ℂ)) (t : Cube n) : |
| repr n (κ n f) t=algebraMap ℂ (Fiber n) (f t) := by |
| let φ := ((point t).comp (repr n)).comp (κ n) |
| let ψ := (StarAlgHom.ofId ℂ (Fiber n)).comp (point (A:=ℂ) t) |
| have he : φ=ψ := by |
| apply CubeCalculus.ext_coord |
| intro i |
| change repr n (κ n (JointCalculus.coordinate i |
| ⟨fun s:unitInterval=>((s:ℝ):ℂ),by fun_prop⟩)) t=_ |
| rw [κ_coordinate,repr_leg,scalar_apply] |
| exact (matLeg n i).commutes _ |
| exact DFunLike.congr_fun he f |
|
|
| lemma κ_first (n : ℕ) (f : C(unitInterval,ℂ)) : |
| κ (n+1) (f.comp (first (n+1)))=includeLeft (scalar f) := κ_coordinate (n+1) 0 f |
| lemma κ_tail (n : ℕ) (f : C(Cube n,ℂ)) : |
| κ (n+1) (f.comp (tail n))=includeRight (κ n f) := by |
| let φ := (κ (n+1)).comp ((tail n).compStarAlgHom' ℂ ℂ) |
| let ψ := (includeRight (A:=Cone)).comp (κ n) |
| have he : φ=ψ := by |
| apply CubeCalculus.ext_coord |
| intro i |
| change κ (n+1) (JointCalculus.coordinate i.succ |
| ⟨fun s:unitInterval=>((s:ℝ):ℂ),by fun_prop⟩)= |
| includeRight (κ n (JointCalculus.coordinate i |
| ⟨fun s:unitInterval=>((s:ℝ):ℂ),by fun_prop⟩)) |
| rw [κ_coordinate,κ_coordinate] |
| rfl |
| exact DFunLike.congr_fun he f |
|
|
| def p : (n : ℕ)→Label n→C(Cube n,ℂ) |
| | 0,a => (ConePauli.p a).comp (first 0) |
| | n+1,a => ((ConePauli.p a.1).comp (first (n+1)))*((p n a.2).comp (tail n)) |
| def u : (n : ℕ)→Label n→Tensor n |
| | 0,a => ConePauli.u a |
| | n+1,a => includeLeft (ConePauli.u a.1)*includeRight (u n a.2) |
|
|
| omit instSize instPauliData in |
| lemma commuting_gram |
| [KirchbergRordam.GenericRW.Size] |
| [KirchbergRordam.GenericRW.PauliData] |
| {A B E : Type*} [CStarAlgebra A] [CStarAlgebra B] |
| [CStarAlgebra E] (φ : A→⋆ₐ[ℂ] E) (ψ : B→⋆ₐ[ℂ] E) |
| (hc : ∀ a b, Commute (φ a) (ψ b)) (x:A) (y:B) : |
| star (φ x*ψ y)*(φ x*ψ y)=φ (star x*x)*ψ (star y*y) := by |
| rw [star_mul,← map_star ψ y,← map_star φ x] |
| calc |
| ψ (star y)*φ (star x)*(φ x*ψ y)=ψ (star y)*φ (star x*x)*ψ y := by |
| rw [map_mul]; noncomm_ring |
| _ = _ := by rw [← (hc (star x*x) (star y)).eq,mul_assoc,← map_mul] |
| lemma gram_product {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] (x:A) (y:B) : |
| star (includeLeft (B:=B) x*includeRight (A:=A) y)*(includeLeft (B:=B) x*includeRight (A:=A) y)= |
| includeLeft (B:=B) (star x*x)*includeRight (A:=A) (star y*y) := |
| commuting_gram includeLeft includeRight legs_commute x y |
|
|
| lemma u_gram (n : ℕ) (a : Label n) : star (u n a)*u n a=κ n (star (p n a)*p n a) := by |
| induction n with |
| | zero => |
| rw [show star (p 0 a)*p 0 a=JointCalculus.coordinate (0:Fin 1) |
| (star (ConePauli.p a)*ConePauli.p a) from rfl,κ_coordinate] |
| exact ConePauli.u_gram a |
| | succ n ih => |
| have hp : star (p (n+1) a)*p (n+1) a= |
| (star (ConePauli.p a.1)*ConePauli.p a.1).comp (first (n+1))* |
| (star (p n a.2)*p n a.2).comp (tail n) := by |
| apply ContinuousMap.ext; intro t |
| simp only [p,ContinuousMap.mul_apply,ContinuousMap.star_apply,ContinuousMap.comp_apply,star_mul] |
| ring |
| rw [hp,map_mul,κ_first,κ_tail] |
| exact (gram_product (ConePauli.u a.1) (u n a.2)).trans |
| (congrArg₂ (fun x y => includeLeft (B := Tensor n) x * includeRight (A := Cone) y) |
| (ConePauli.u_gram a.1) (ih a.2)) |
|
|
| lemma ce_product (n : ℕ) (a : Label (n+1)) : |
| MatrixTensor.leftMatrix (κ:=PauliPower.Row n) (ConePauli.E a.1)*MatrixTensor.rightMatrix (ι:=Fin Size.n) (PauliPower.ce n a.2)= |
| PauliPower.ce (n+1) a := MatrixTensor.legs_product _ _ |
| lemma repr_u (n : ℕ) (a : Label n) (t : Cube n) : |
| repr n (u n a) t=p n a t • PauliPower.ce n a := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| let ρ : MaxTensor.Algebra Cone (Tensor n)→⋆ₐ[ℂ] C(Cube (n+1),Fiber (n+1)) := repr (n+1) |
| change ρ (includeLeft (ConePauli.u a.1)*includeRight (u n a.2)) t=_ |
| rw [map_mul] |
| change (repr (n+1) (includeLeft (ConePauli.u a.1))* |
| repr (n+1) (includeRight (u n a.2))) t=_ |
| rw [ContinuousMap.mul_apply,repr_left,repr_right,ih] |
| change MatrixTensor.leftMatrix (κ:=PauliPower.Row n) (ConePauli.p a.1 (t 0) • ConePauli.E a.1)* |
| MatrixTensor.rightMatrix (ι:=Fin Size.n) (p n a.2 (tail n t) • PauliPower.ce n a.2)=_ |
| rw [map_smul,map_smul,smul_mul_smul_comm,ce_product] |
| rfl |
|
|
| def expansion (n : ℕ) : (Label n→C(Cube n,ℂ))→ₗ[ℂ] Tensor n where |
| toFun f := ∑ i,κ n (f i)*u n i |
| map_add' f g := by simp [map_add,add_mul,Finset.sum_add_distrib] |
| map_smul' c f := by simp [map_smul,Finset.smul_sum] |
|
|
| lemma expansion_zero (f : Pauli.Label→C(unitInterval,ℂ)) : |
| expansion 0 (fun i => (f i).comp (first 0))=ConePauli.expansion f := by |
| dsimp only [expansion,ConePauli.expansion,LinearMap.coe_mk,AddHom.coe_mk] |
| apply Finset.sum_congr rfl |
| intro i _ |
| exact congrArg (·*ConePauli.u i) (κ_coordinate 0 (0:Fin 1) (f i)) |
|
|
| lemma expansion_product (n : ℕ) (f : Pauli.Label→C(unitInterval,ℂ)) (g : Label n→C(Cube n,ℂ)) : |
| includeLeft (ConePauli.expansion f)*includeRight (expansion n g)= |
| expansion (n+1) (fun a => (f a.1).comp (first (n+1))*(g a.2).comp (tail n)) := by |
| let κ' : C(Cube (n+1),ℂ)→⋆ₐ[ℂ] MaxTensor.Algebra Cone (Tensor n) := κ (n+1) |
| have result : (includeLeft (∑ i,scalar (f i)*ConePauli.u i)*includeRight (∑ j,κ n (g j)*u n j) : |
| MaxTensor.Algebra Cone (Tensor n)) = |
| ∑ a:Pauli.Label×Label n,κ' ((f a.1).comp (first (n+1))*(g a.2).comp (tail n))* |
| (includeLeft (ConePauli.u a.1)*includeRight (u n a.2)) := by |
| rw [map_sum,map_sum,Finset.sum_mul,Fintype.sum_prod_type] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro j _ |
| simp only [map_mul] |
| have hfirst : ∀ h,κ' (h.comp (first (n+1)))=includeLeft (scalar h) := κ_first n |
| have htail : ∀ h,κ' (h.comp (tail n))=includeRight (κ n h) := κ_tail n |
| rw [hfirst,htail] |
| have hc := (legs_commute (ConePauli.u i) (κ n (g j))).eq |
| calc |
| _ = includeLeft (scalar (f i))*(includeLeft (ConePauli.u i)*includeRight (κ n (g j)))* |
| includeRight (u n j) := by noncomm_ring |
| _ = _ := by rw [hc]; noncomm_ring |
| exact result |
|
|
| lemma dense (n : ℕ) : DenseRange (expansion n) := by |
| induction n with |
| | zero => |
| let S : Submodule ℂ (Tensor 0) := (LinearMap.range (expansion 0)).topologicalClosure |
| have hc : IsClosed (S:Set (Tensor 0)) := Submodule.isClosed_topologicalClosure _ |
| intro x |
| change x∈S |
| refine ConePauli.dense.induction_on x hc ?_ |
| intro f |
| apply (LinearMap.range (expansion 0)).le_topologicalClosure |
| exact ⟨fun i=>(f i).comp (first 0),expansion_zero f⟩ |
| | succ n ih => |
| let S : Submodule ℂ (Tensor (n+1)) := (LinearMap.range (expansion (n+1))).topologicalClosure |
| have hc : IsClosed (S:Set (Tensor (n+1))) := Submodule.isClosed_topologicalClosure _ |
| have hp (a : Cone) (b : Tensor n) : includeLeft a*includeRight b ∈ S := by |
| refine ConePauli.dense.induction_on a |
| (hc.preimage ((map_continuous (includeLeft (B:=Tensor n))).mul continuous_const)) ?_ |
| intro f |
| refine ih.induction_on b |
| (hc.preimage (continuous_const.mul (map_continuous (includeRight (A:=Cone))))) ?_ |
| intro g |
| rw [expansion_product] |
| exact (LinearMap.range (expansion (n+1))).le_topologicalClosure ⟨_,rfl⟩ |
| intro x |
| change x∈S |
| induction x using UniformSpace.Completion.induction_on with |
| | hp => exact hc |
| | ih x => |
| let inclusion : (Cone ⊗[ℂ] Tensor n) →ₗ[ℂ] Tensor (n+1) := |
| of.toLinearMap.comp rawEquiv.toStarAlgHom.toLinearMap |
| suffices ∀ tensor : Cone ⊗[ℂ] Tensor n, inclusion tensor ∈ S from this x |
| intro tensor |
| induction tensor using TensorProduct.inductionOn with |
| | add x y hx hy => rw [map_add]; exact S.add_mem hx hy |
| | tmul a b => |
| change of (a ⊗ₜ[ℂ] b) ∈ S |
| rw [of_tmul] |
| exact hp a b |
|
|
|
|
| lemma faithful (n : ℕ) : Function.Injective (repr n) := |
| CubeFrame.faithful (κ n) (repr n) (p n) (u n) (PauliPower.ce n) |
| (κ_commute n) (u_gram n) (repr_κ n) (repr_u n) |
| (PauliPower.ccoeff n) (PauliPower.ccoeff_ce n) (dense n) |
|
|
|
|
| theorem exists_unique_lift (n : ℕ) (f : C(Cube n,Fiber n)) |
| (hf : ∀ a t,p n a t=0 → PauliPower.ccoeff n a (f t)=0) : |
| ∃! b : Tensor n,repr n b=f ∧ ‖b‖=‖f‖ := |
| CubeFrame.exists_unique_lift (κ n) (repr n) (p n) (u n) (PauliPower.ce n) |
| (repr_κ n) (repr_u n) (PauliPower.ccoeff n) (PauliPower.ccoeff_sum n) |
| (κ_commute n) (u_gram n) (PauliPower.ccoeff_ce n) (dense n) f hf |
|
|
| end KirchbergRordam.GenericRW.ConeCube |
|
|
|
|
| namespace KirchbergRordam.GenericRW.PauliSupport |
| open scoped Matrix Kronecker BigOperators |
| open KirchbergRordam.GenericRW.PauliPower |
|
|
| def coord : (n : ℕ)→Label n→Fin (n+1)→Pauli.Label |
| | 0,a,_ => a |
| | n+1,a,i => Fin.cases a.1 (fun j=>coord n a.2 j) i |
|
|
| def leg : (n : ℕ)→Fin (n+1)→Pauli.M2→⋆ₐ[ℂ] Mat n |
| | 0,_ => StarAlgHom.id ℂ Pauli.M2 |
| | n+1,i => Fin.cases MatrixTensor.leftMatrixAlgebra |
| (fun j=>MatrixTensor.rightMatrixAlgebra.comp (leg n j)) i |
|
|
| lemma anti_leg (n : ℕ) (a : Label n) (j : Fin (n+1)) (b : Pauli.M2) |
| (he : b*Pauli.e (coord n a j) = -(Pauli.e (coord n a j)*b)) : |
| leg n j b*e n a = -(e n a*leg n j b) := by |
| induction n with |
| | zero => exact he |
| | succ n ih => |
| induction j using Fin.cases with |
| | zero => |
| change b*Pauli.e a.1 = -(Pauli.e a.1*b) at he |
| have result : (Matrix.kronecker b 1*Matrix.kronecker (Pauli.e a.1) (e n a.2) : |
| Matrix (Fin rankNum × Row n) (Fin rankNum × Row n) ℂ) = |
| -(Matrix.kronecker (Pauli.e a.1) (e n a.2)*Matrix.kronecker b 1) := by |
| dsimp only [Matrix.kronecker] |
| rw [← Matrix.mul_kronecker_mul,← Matrix.mul_kronecker_mul,he,one_mul,mul_one] |
| ext row col |
| simp [Matrix.kroneckerMap_apply] |
| exact result |
| | succ j => |
| have result : (Matrix.kronecker 1 (leg n j b)*Matrix.kronecker (Pauli.e a.1) (e n a.2) : |
| Matrix (Fin rankNum × Row n) (Fin rankNum × Row n) ℂ) = |
| -(Matrix.kronecker (Pauli.e a.1) (e n a.2)*Matrix.kronecker 1 (leg n j b)) := by |
| dsimp only [Matrix.kronecker] |
| rw [← Matrix.mul_kronecker_mul,← Matrix.mul_kronecker_mul,one_mul,mul_one,ih a.2 j he] |
| ext row col |
| simp [Matrix.kroneckerMap_apply] |
| exact result |
|
|
| lemma coeff_zero (n : ℕ) (a : Label n) (j : Fin (n+1)) (hj : coord n a j≠0) |
| (x : Mat n) (hx : ∀ b,Commute (leg n j b) x) : coeff n a x=0 := by |
| obtain ⟨b,hb,he⟩ := PauliData.anti (coord n a j) hj |
| rw [coeff_apply, KirchbergRordam.PauliSupport.trace_zero_of_anti _ _ _ ?_ |
| (anti_leg n a j b he) (hx b), mul_zero] |
| rw [← map_mul,hb,map_one] |
| end KirchbergRordam.GenericRW.PauliSupport |
|
|
| namespace KirchbergRordam.GenericRW.ConeCube |
| open scoped CStarAlgebra ComplexOrder BigOperators |
| open ConeModel |
|
|
| omit instSize instPauliData in |
| lemma matLeg_plain |
| [KirchbergRordam.GenericRW.Size] |
| [KirchbergRordam.GenericRW.PauliData] |
| (n : ℕ) (j : Fin (n+1)) (b : Pauli.M2) : |
| matLeg n j (CStarMatrix.ofMatrix b)=CStarMatrix.ofMatrix (PauliSupport.leg n j b) := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| induction j using Fin.cases with |
| | zero => rfl |
| | succ j => |
| change MatrixTensor.rightMatrix (matLeg n j (CStarMatrix.ofMatrix b))=_ |
| rw [ih] |
| rfl |
|
|
| lemma matLeg_commute (n : ℕ) (i j : Fin (n+1)) (hij : i≠j) (a b : M2) : |
| Commute (matLeg n i a) (matLeg n j b) := by |
| induction n with |
| | zero => exact (hij ((Fin.eq_zero i).trans (Fin.eq_zero j).symm)).elim |
| | succ n ih => |
| induction i using Fin.cases with |
| | zero => |
| induction j using Fin.cases with |
| | zero => exact (hij rfl).elim |
| | succ j => exact MatrixTensor.legs_commute _ _ |
| | succ i => |
| induction j using Fin.cases with |
| | zero => exact (MatrixTensor.legs_commute _ _).symm |
| | succ j => exact (ih i j (fun h=>hij (congrArg Fin.succ h))).map MatrixTensor.rightMatrix |
|
|
| lemma ccoeff_zero (n : ℕ) (a : Label n) (j : Fin (n+1)) (hj : PauliSupport.coord n a j≠0) |
| (x : Fiber n) (hx : ∀ b,Commute (matLeg n j b) x) : PauliPower.ccoeff n a x=0 := by |
| apply PauliSupport.coeff_zero n a j hj (CStarMatrix.ofMatrix.symm x) |
| intro b |
| have h := (hx (CStarMatrix.ofMatrix b)).map CStarMatrix.ofMatrixStarAlgEquiv.symm |
| rw [matLeg_plain] at h |
| exact h |
|
|
|
|
| lemma p_zero (n : ℕ) (a : Label n) (t : Cube n) (hp : p n a t=0) : |
| ∃ j,t j=0 ∧ PauliSupport.coord n a j≠0 := by |
| induction n with |
| | zero => |
| refine ⟨0,?_,?_⟩ |
| · by_cases ha : a=(0:Pauli.Label) |
| · subst a; simp [p,ConePauli.p,first] at hp |
| · have eval_nonzero : ∀ label : Pauli.Label, label ≠ 0 → |
| ConePauli.p label (t 0) = ((t 0 : ℝ) : ℂ) := by |
| intro label hlabel |
| simp [ConePauli.p, hlabel] |
| have hz : ((t 0:ℝ):ℂ)=0 := (eval_nonzero a ha).symm.trans hp |
| apply Subtype.ext |
| exact_mod_cast hz |
| · intro ha |
| change a=(0:Pauli.Label) at ha |
| subst a |
| simp [p,ConePauli.p,first] at hp |
| | succ n ih => |
| change ConePauli.p a.1 (t 0)*p n a.2 (tail n t)=0 at hp |
| rcases mul_eq_zero.mp hp with hp|hp |
| · have ha : a.1≠0 := by intro ha; simp [ha,ConePauli.p] at hp |
| refine ⟨0,?_,ha⟩ |
| have hz : ((t 0:ℝ):ℂ)=0 := by simpa [ConePauli.p,ha] using hp |
| apply Subtype.ext |
| exact_mod_cast hz |
| · obtain ⟨j,hj,hne⟩ := ih a.2 (tail n t) hp |
| exact ⟨j.succ,hj,hne⟩ |
| end KirchbergRordam.GenericRW.ConeCube |
| end |
|
|
| end OAI |
|
|
