Download data/lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Graph.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 31.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Graph.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Graph.lean
-
curl -L -o Graph.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Graph.lean
31.4 kB
| import OAI.Analysis.CStarAlgebra.PureInfiniteness.Avoidance | |
| namespace OAI | |
| noncomputable section | |
| open Filter | |
| open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace | |
| namespace MainGap | |
| variable {A : Type*} [NonUnitalCStarAlgebra A] | |
| namespace OrthogonalSlots | |
| section GraphAlgebra | |
| variable {n : β} {h v : A} (S : OrthogonalSlots n h v) | |
| def graphWord (R : Fin n β A) (hR : β i (k : Her h), R i * (k : A) β Her h) | |
| (k : Her h) : A := β i, S.carrier i β¨R i * (k : A), hR i kβ© | |
| lemma graphWord_inner (R : Fin n β A) (hR : β i (k : Her h), R i * (k : A) β Her h) | |
| (k l : Her h) : | |
| star (S.graphWord R hR k) * S.graphWord R hR l = | |
| star (k : A) * (β i, star (R i) * R i) * (l : A) := by | |
| classical | |
| simp only [graphWord, star_sum, Finset.sum_mul, Finset.mul_sum, S.inner] | |
| simp only [Finset.sum_ite_eq', Finset.mem_univ, ite_true] | |
| simp only [star_mul, mul_assoc] | |
| lemma graphWord_outer (R : Fin n β A) (hR : β i (k : Her h), R i * (k : A) β Her h) | |
| (k l : Her h) : S.graphWord R hR k * star (S.graphWord R hR l) β Her v := by | |
| classical | |
| simp only [graphWord, star_sum, Finset.sum_mul, Finset.mul_sum] | |
| exact (Her v).sum_mem fun i _ => (Her v).sum_mem fun j _ => S.outer j i _ _ | |
| lemma slot_graphWord (R : Fin n β A) (hR : β i (k : Her h), R i * (k : A) β Her h) | |
| (i : Fin n) (k l : Her h) : | |
| star (S.carrier i k) * S.graphWord R hR l = star (k : A) * R i * (l : A) := by | |
| classical | |
| simp only [graphWord, Finset.mul_sum, S.inner] | |
| simp [mul_assoc] | |
| lemma graphWord_mul (R : Fin n β A) (hR : β i (k : Her h), R i * (k : A) β Her h) | |
| (k l : Her h) : S.graphWord R hR (k*l) = S.graphWord R hR k * (l : A) := by | |
| classical | |
| simp only [graphWord, Finset.sum_mul] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| have he : (β¨R i * ((k*l : Her h) : A), hR i (k*l)β© : Her h) = | |
| β¨R i * (k : A), hR i kβ© * l := by apply Subtype.ext; exact (mul_assoc _ _ _).symm | |
| rw [he, S.mul] | |
| end GraphAlgebra | |
| end OrthogonalSlots | |
| section UnitalGraph | |
| variable {D : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] | |
| omit [PartialOrder D] [StarOrderedRing D] in | |
| lemma cfc_mul_mem_Her {h q : D} (hq : q β Her h) (hqa : IsSelfAdjoint q) | |
| (f : β β β) (hf : Continuous f) {k : D} (hk : k β Her h) : | |
| cfc f q * k β Her h := by | |
| have hm : cfcβ (fun x => f x - f 0) q β Her h := cfcβ_mem (π' := β) _ hq | |
| have he : cfcβ (fun x => f x - f 0) q = cfc f q - (f 0) β’ (1 : D) := by | |
| rw [cfcβ_eq_cfc (f := fun x => f x - f 0) (a := q) ((hf.sub continuous_const).continuousOn) (by simp), | |
| cfc_sub f (fun _ => f 0) q hf.continuousOn continuous_const.continuousOn, | |
| cfc_const _ q hqa, Algebra.algebraMap_eq_smul_one] | |
| have he' : cfc f q = cfcβ (fun x => f x - f 0) q + (f 0) β’ (1 : D) := by rw [he]; abel | |
| rw [he', add_mul, smul_mul_assoc, one_mul] | |
| exact (Her h).add_mem ((Her h).mul_mem hm hk) (real_smul_mem_Her hk _) | |
| def graphComplement (S : Fin 4 β D) : D := | |
| cfc (fun t : β => Real.sqrt ((15-t)/16)) (β i, star (S i)*S i) | |
| lemma graphComplement_nonneg (S : Fin 4 β D) : 0 β€ graphComplement S := | |
| cfc_nonneg fun _ _ => Real.sqrt_nonneg _ | |
| lemma graphComplement_mul_self (S : Fin 4 β D) (hS : β i, βS iβ β€ 1) : | |
| graphComplement S * graphComplement S = | |
| (15/16 : β) β’ (1 : D) - (1/16 : β) β’ (β i, star (S i)*S i) := by | |
| rcases subsingleton_or_nontrivial D with hD | hD | |
| Β· exact Subsingleton.elim _ _ | |
| let q := β i, star (S i)*S i | |
| have hq : 0 β€ q := Finset.sum_nonneg fun i _ => star_mul_self_nonneg _ | |
| have hn : βqβ β€ 4 := by | |
| calc | |
| βqβ β€ β i, βstar (S i)*S iβ := norm_sum_le _ _ | |
| _ β€ β _i : Fin 4, (1 : β) := by | |
| apply Finset.sum_le_sum | |
| intro i hi | |
| rw [CStarRing.norm_star_mul_self] | |
| simpa using mul_self_le_mul_self (norm_nonneg _) (hS i) | |
| _ = 4 := by simp | |
| have hc : Continuous (fun t : β => Real.sqrt ((15-t)/16)) := by fun_prop | |
| change cfc _ q * cfc _ q = _ | |
| rw [β cfc_mul _ _ q hc.continuousOn hc.continuousOn] | |
| have he : cfc (fun t : β => Real.sqrt ((15-t)/16) * Real.sqrt ((15-t)/16)) q = | |
| cfc (fun t : β => 15/16 - (1/16)*t) q := by | |
| apply cfc_congr | |
| intro t ht | |
| have ht' : t β€ 4 := (Real.le_norm_self t).trans ((spectrum.norm_le_norm_of_mem ht).trans hn) | |
| dsimp only | |
| rw [Real.mul_self_sqrt (by linarith : 0 β€ (15-t)/16)] | |
| ring | |
| rw [he, cfc_sub (fun _ : β => 15/16) (fun t : β => (1/16)*t) q, | |
| cfc_const _ q hq.isSelfAdjoint, cfc_const_mul (1/16 : β) (fun t : β => t) q, | |
| cfc_id' β q hq.isSelfAdjoint, Algebra.algebraMap_eq_smul_one] | |
| lemma graphComplement_mul_mem {h : D} (S : Fin 4 β D) (hS : β i, S i β Her h) | |
| {k : D} (hk : k β Her h) : graphComplement S * k β Her h := by | |
| apply cfc_mul_mem_Her ?_ ?_ _ (by fun_prop) hk | |
| Β· exact (Her h).sum_mem fun i _ => (Her h).mul_mem (StarMemClass.star_mem (s := Her h) (hS i)) (hS i) | |
| Β· exact (Finset.sum_nonneg fun i _ => star_mul_self_nonneg (S i)).isSelfAdjoint | |
| def graphCoeffs (T : Fin 4 β D) : Fin 6 β D := | |
| ![(1/4 : β) β’ 1, (1/4 : β) β’ T 0, (1/4 : β) β’ T 1, | |
| (1/4 : β) β’ T 2, (1/4 : β) β’ T 3, graphComplement T] | |
| lemma graphCoeffs_inner (T : Fin 4 β D) (hT : β i, βT iβ β€ 1) : | |
| β i, star (graphCoeffs T i) * graphCoeffs T i = 1 := by | |
| classical | |
| rw [Fin.sum_univ_six] | |
| dsimp [graphCoeffs] | |
| simp only [star_smul, star_trivial, star_one, smul_mul_assoc, mul_smul_comm, | |
| smul_smul, one_mul] | |
| rw [(graphComplement_nonneg T).isSelfAdjoint.star_eq, | |
| graphComplement_mul_self T hT, Fin.sum_univ_four] | |
| module | |
| lemma graphCoeffs_mem {h : D} (T : Fin 4 β D) (hT : β i, T i β Her h) | |
| (i : Fin 6) (k : Her h) : graphCoeffs T i * (k : D) β Her h := by | |
| fin_cases i <;> dsimp [graphCoeffs] <;> try simp only [smul_mul_assoc, one_mul] | |
| Β· exact real_smul_mem_Her k.property _ | |
| Β· exact real_smul_mem_Her ((Her h).mul_mem (hT 0) k.property) _ | |
| Β· exact real_smul_mem_Her ((Her h).mul_mem (hT 1) k.property) _ | |
| Β· exact real_smul_mem_Her ((Her h).mul_mem (hT 2) k.property) _ | |
| Β· exact real_smul_mem_Her ((Her h).mul_mem (hT 3) k.property) _ | |
| Β· exact graphComplement_mul_mem T hT k.property | |
| end UnitalGraph | |
| lemma Her_fixed_right {h t : A} (hh : IsSelfAdjoint h) (ht : h * t = h) | |
| {k : A} (hk : k β Her h) : k * t = k := by | |
| have he : star t * h = h := by | |
| simpa only [star_mul, hh.star_eq] using congrArg star ht | |
| have hs := Her_fixed_left he (StarMemClass.star_mem (s := Her h) hk) | |
| simpa only [star_mul, star_star] using congrArg star hs | |
| def graphInverseFn (t : β) : β := t / (max (1/32 : β) t)^2 | |
| lemma continuous_graphInverseFn : Continuous graphInverseFn := by | |
| apply Continuous.div continuous_id | |
| (((continuous_const : Continuous (fun _ : β => (1/32 : β))).max continuous_id).pow 2) | |
| intro t | |
| exact pow_ne_zero _ (ne_of_gt (lt_of_lt_of_le (by norm_num : (0:β)<1/32) (le_max_left _ _))) | |
| lemma graphInverseFn_zero : graphInverseFn 0 = 0 := by simp [graphInverseFn] | |
| def graphInverse (X : A) : A := cfcβ graphInverseFn X | |
| section InverseOrder | |
| variable [PartialOrder A] [StarOrderedRing A] | |
| omit [PartialOrder A] [StarOrderedRing A] in | |
| lemma graphInverse_mem {h X : A} (hX : X β Her h) : graphInverse X β Her h := | |
| cfcβ_mem (π' := β) _ hX | |
| lemma cut_mul_graphInverse {X : A} (hX : 0 β€ X) : | |
| cut X (1/32) * (X * graphInverse X) = cut X (1/32) := by | |
| have hc : Continuous (fun t : β => max (t-1/32) 0) := by fun_prop | |
| have h0 : (fun t : β => max (t-1/32) 0) 0 = 0 := by norm_num | |
| have he : X * graphInverse X = cfcβ (fun t : β => t * graphInverseFn t) X := by | |
| simpa only [id_eq, cfcβ_id' β X hX.isSelfAdjoint, graphInverse] using | |
| (cfcβ_mul id graphInverseFn X continuousOn_id rfl | |
| continuous_graphInverseFn.continuousOn graphInverseFn_zero).symm | |
| rw [he, cut, β cfcβ_mul (fun t : β => max (t-1/32) 0) | |
| (fun t : β => t * graphInverseFn t) X hc.continuousOn h0 | |
| (continuous_id.mul continuous_graphInverseFn).continuousOn (by simp)] | |
| apply cfcβ_congr | |
| intro t ht | |
| dsimp only | |
| by_cases h : t β€ 1/32 | |
| Β· rw [max_eq_right (sub_nonpos.mpr h), zero_mul] | |
| Β· have ht0 : t β 0 := ne_of_gt (lt_trans (by norm_num) (lt_of_not_ge h)) | |
| dsimp [graphInverseFn] | |
| rw [max_eq_right (le_of_not_ge h)] | |
| field_simp | |
| lemma right_fixed_by_graphInverse {X S : A} (hX : 0 β€ X) | |
| (hS : S β Her (cut X (1/32))) : S * (X * graphInverse X) = S := | |
| Her_fixed_right (cut_nonneg X (1/32)).isSelfAdjoint (cut_mul_graphInverse hX) hS | |
| lemma map_graphInverse {B : Type*} [NonUnitalCStarAlgebra B] [PartialOrder B] [StarOrderedRing B] | |
| (Ο : A ββββ[β] B) {X : A} (hX : 0 β€ X) : | |
| Ο (graphInverse X) = graphInverse (Ο X) := | |
| Ο.map_cfcβ graphInverseFn X continuous_graphInverseFn.continuousOn graphInverseFn_zero | |
| (map_continuous Ο) hX.isSelfAdjoint (map_nonneg Ο hX).isSelfAdjoint | |
| end InverseOrder | |
| section GraphDefect | |
| variable {D : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] | |
| lemma positive_mul_zero_of_conjugate_zero {a x : D} (ha : 0 β€ a) | |
| (hz : star x * a * x = 0) : a * x = 0 := by | |
| have hr : CFC.sqrt a * x = 0 := by | |
| apply (CStarRing.star_mul_self_eq_zero_iff _).mp | |
| calc | |
| star (CFC.sqrt a * x) * (CFC.sqrt a * x) = | |
| star x * (CFC.sqrt a * CFC.sqrt a) * x := by | |
| simp only [star_mul, (CFC.sqrt_nonneg a).isSelfAdjoint.star_eq, mul_assoc] | |
| _ = 0 := by rw [CFC.sqrt_mul_sqrt_self a ha, hz] | |
| rw [β CFC.sqrt_mul_sqrt_self a ha, mul_assoc, hr, mul_zero] | |
| lemma positive_fixed_of_square_fixed {p x : D} (hp : 0 β€ p) | |
| (he : p * p * x = x) : p * x = x := by | |
| have hi : IsUnit ((1 : D) + p) := CStarAlgebra.isUnit_of_le 1 (le_add_of_nonneg_right hp) | |
| apply hi.mul_left_cancel | |
| simp only [add_mul, one_mul, β mul_assoc, he] | |
| exact add_comm _ _ | |
| lemma sqrt_fixed_of_fixed {p x : D} (hp : 0 β€ p) (he : p*x=x) : CFC.sqrt p*x=x := by | |
| apply positive_fixed_of_square_fixed (CFC.sqrt_nonneg _) | |
| rwa [CFC.sqrt_mul_sqrt_self p hp] | |
| lemma star_mul_le_one_of_norm_le_one {x : D} (hx : βxβ β€ 1) : star x * x β€ 1 := by | |
| apply (CStarAlgebra.norm_le_one_iff_of_nonneg _ (star_mul_self_nonneg x)).mp | |
| rw [CStarRing.norm_star_mul_self] | |
| simpa using mul_self_le_mul_self (norm_nonneg _) hx | |
| lemma graph_defect_forces {p c y : D} (hp : 0 β€ p) (hpn : βpβ β€ 1) | |
| (hcn : βcβ β€ 1) (hy : 0 β€ y) | |
| (hd : y * (1 - star c * (p*p) * c) * y = 0) : | |
| p * (c*y) = c*y β§ star c * c * y = y := by | |
| have hp2 : 0 β€ 1 - p*p := sub_nonneg.mpr (by | |
| simpa only [hp.isSelfAdjoint.star_eq] using star_mul_le_one_of_norm_le_one hpn) | |
| have hc2 : 0 β€ 1 - star c*c := sub_nonneg.mpr (star_mul_le_one_of_norm_le_one hcn) | |
| have hβ : 0 β€ y*(1-star c*c)*y := by | |
| simpa only [hy.isSelfAdjoint.star_eq] using star_left_conjugate_nonneg hc2 y | |
| have hβ : 0 β€ star (c*y)*(1-p*p)*(c*y) := star_left_conjugate_nonneg hp2 _ | |
| have he : y*(1-star c*c)*y + star (c*y)*(1-p*p)*(c*y) = 0 := by | |
| calc | |
| _ = y * (1 - star c * (p*p) * c) * y := by | |
| simp only [star_mul, hy.isSelfAdjoint.star_eq]; noncomm_ring | |
| _ = 0 := hd | |
| have hzβ : y*(1-star c*c)*y = 0 := le_antisymm ((le_add_of_nonneg_right hβ).trans_eq he) hβ | |
| have hzβ : star (c*y)*(1-p*p)*(c*y) = 0 := le_antisymm ((le_add_of_nonneg_left hβ).trans_eq he) hβ | |
| have hcfix := positive_mul_zero_of_conjugate_zero hc2 | |
| (show star y*(1-star c*c)*y=0 by simpa only [hy.isSelfAdjoint.star_eq] using hzβ) | |
| have hpfix := positive_mul_zero_of_conjugate_zero hp2 hzβ | |
| have hec : star c*c*y=y := by | |
| apply Eq.symm | |
| apply sub_eq_zero.mp | |
| simpa only [sub_mul, one_mul] using hcfix | |
| have hep : p*p*(c*y)=c*y := by | |
| apply Eq.symm | |
| apply sub_eq_zero.mp | |
| simpa only [sub_mul, one_mul] using hpfix | |
| exact β¨positive_fixed_of_square_fixed hp hep, hecβ© | |
| lemma norm_conjugate_eq_of_isometric_on {c y : D} (hy : 0 β€ y) | |
| (hc : star c*c*y=y) : βc*y*star cβ=βyβ := by | |
| have hs := Her_fixed_left hc (sqrt_mem_Her (self_mem_Her hy) hy) | |
| have he : c*y*star c = (c*CFC.sqrt y)*star (c*CFC.sqrt y) := by | |
| simp only [star_mul, (CFC.sqrt_nonneg y).isSelfAdjoint.star_eq] | |
| rw [show c*y*star c = c * (CFC.sqrt y * CFC.sqrt y) * star c by rw [CFC.sqrt_mul_sqrt_self y hy]] | |
| simp only [mul_assoc] | |
| rw [he, CStarRing.norm_self_mul_star, β CStarRing.norm_star_mul_self] | |
| congr 1 | |
| calc | |
| star (c*CFC.sqrt y)*(c*CFC.sqrt y) = CFC.sqrt y*(star c*c*CFC.sqrt y) := by | |
| simp only [star_mul, (CFC.sqrt_nonneg y).isSelfAdjoint.star_eq, mul_assoc] | |
| _ = y := by rw [hs, CFC.sqrt_mul_sqrt_self y hy] | |
| end GraphDefect | |
| section GraphConstruction | |
| variable {D : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] | |
| variable {h a t : D} (V : OrthogonalSlots 6 h a) (ht : 0 β€ t) (htH : t β Her h) | |
| def graphSlot (i : Fin 6) : D := V.carrier i β¨t, htHβ© | |
| def graphZ (T : Fin 4 β D) (hT : β i, T i β Her h) : D := | |
| V.graphWord (graphCoeffs T) (graphCoeffs_mem T hT) β¨CFC.sqrt t, sqrt_mem_Her htH htβ© | |
| def graphP (T : Fin 4 β D) (hT : β i, T i β Her h) : D := | |
| graphZ V ht htH T hT * star (graphZ V ht htH T hT) | |
| lemma graphZ_inner (T : Fin 4 β D) (hT : β i, T i β Her h) (hn : β i, βT iβ β€ 1) : | |
| star (graphZ V ht htH T hT) * graphZ V ht htH T hT = t := by | |
| rw [graphZ, V.graphWord_inner, graphCoeffs_inner T hn] | |
| simpa only [mul_one, (CFC.sqrt_nonneg t).isSelfAdjoint.star_eq] using CFC.sqrt_mul_sqrt_self t ht | |
| lemma graphP_nonneg (T : Fin 4 β D) (hT : β i, T i β Her h) : 0 β€ graphP V ht htH T hT := | |
| mul_star_self_nonneg _ | |
| lemma graphP_mem (T : Fin 4 β D) (hT : β i, T i β Her h) : graphP V ht htH T hT β Her a := | |
| V.graphWord_outer _ _ _ _ | |
| lemma graphP_represented_norm {E : Type*} [NonUnitalCStarAlgebra E] | |
| (Ο : D ββββ[β] E) (T : Fin 4 β D) (hT : β i, T i β Her h) (hn : β i, βT iβ β€ 1) : | |
| βΟ (graphP V ht htH T hT)β = βΟ tβ := by | |
| rw [graphP, map_mul, map_star, CStarRing.norm_self_mul_star, | |
| β CStarRing.norm_star_mul_self, β map_star, β map_mul, graphZ_inner V ht htH T hT hn] | |
| include ht in | |
| lemma slot_sandwich_mem (i j : Fin 6) (F : D) : | |
| star (graphSlot V htH i) * F * graphSlot V htH j β Her h := by | |
| let r : Her h := β¨CFC.sqrt t, sqrt_mem_Her htH htβ© | |
| have he : (β¨t, htHβ© : Her h) = r*r := by | |
| apply Subtype.ext | |
| exact (CFC.sqrt_mul_sqrt_self t ht).symm | |
| have hWi : graphSlot V htH i = V.carrier i r * CFC.sqrt t := by rw [graphSlot, he, V.mul] | |
| have hWj : graphSlot V htH j = V.carrier j r * CFC.sqrt t := by rw [graphSlot, he, V.mul] | |
| rw [hWi, hWj, star_mul, (CFC.sqrt_nonneg t).isSelfAdjoint.star_eq] | |
| have hm := Her_sandwich (sqrt_mem_Her htH ht) (star (V.carrier i r) * F * V.carrier j r) | |
| simpa only [(CFC.sqrt_nonneg t).isSelfAdjoint.star_eq, mul_assoc] using hm | |
| def graphX (F : D) : D := (16 : β) β’ (star (graphSlot V htH 0) * F * graphSlot V htH 0) | |
| def graphB (F : D) (i : Fin 4) : D := (16 : β) β’ | |
| (star (graphSlot V htH i.castSucc.succ) * F * graphSlot V htH 0 * graphInverse (graphX V htH F)) | |
| lemma graphX_nonneg {F : D} (hF : 0 β€ F) : 0 β€ graphX V htH F := | |
| smul_nonneg (by norm_num) (star_left_conjugate_nonneg hF _) | |
| include ht in | |
| lemma graphX_mem (F : D) : graphX V htH F β Her h := | |
| real_smul_mem_Her (slot_sandwich_mem V ht htH 0 0 F) _ | |
| include ht in | |
| lemma graphB_mem (F : D) (i : Fin 4) : graphB V htH F i β Her h := | |
| real_smul_mem_Her ((Her h).mul_mem (slot_sandwich_mem V ht htH _ _ F) | |
| (graphInverse_mem (graphX_mem V ht htH F))) _ | |
| lemma graphSlot0_Z (T : Fin 4 β D) (hT : β i, T i β Her h) : | |
| star (graphSlot V htH 0) * graphZ V ht htH T hT = (1/4 : β) β’ (t * CFC.sqrt t) := by | |
| rw [graphSlot, graphZ, V.slot_graphWord] | |
| simp [graphCoeffs, ht.isSelfAdjoint.star_eq] | |
| lemma graphSlot_Z (T : Fin 4 β D) (hT : β i, T i β Her h) (i : Fin 4) : | |
| star (graphSlot V htH i.castSucc.succ) * graphZ V ht htH T hT = | |
| (1/4 : β) β’ (t * T i * CFC.sqrt t) := by | |
| rw [graphSlot, graphZ, V.slot_graphWord] | |
| have he : graphCoeffs T i.castSucc.succ = (1/4 : β) β’ T i := by fin_cases i <;> rfl | |
| rw [he, ht.isSelfAdjoint.star_eq, mul_smul_comm, smul_mul_assoc] | |
| lemma norm_compression_eq_of_fixed {z F : D} (hF : 0 β€ F) (hfix : z*star z*F=F) : | |
| βstar z*F*zβ=βFβ := by | |
| have hs := Her_fixed_left hfix (sqrt_mem_Her (self_mem_Her hF) hF) | |
| calc | |
| βstar z*F*zβ = βstar (CFC.sqrt F*z)*(CFC.sqrt F*z)β := by | |
| congr 1 | |
| simp only [star_mul, (CFC.sqrt_nonneg F).isSelfAdjoint.star_eq] | |
| calc | |
| star z*F*z = star z*(CFC.sqrt F*CFC.sqrt F)*z := by rw [CFC.sqrt_mul_sqrt_self F hF] | |
| _ = _ := by noncomm_ring | |
| _ = β(CFC.sqrt F*z)*star (CFC.sqrt F*z)β := by | |
| rw [CStarRing.norm_star_mul_self, CStarRing.norm_self_mul_star] | |
| _ = βFβ := by | |
| congr 1 | |
| calc | |
| (CFC.sqrt F*z)*star (CFC.sqrt F*z) = CFC.sqrt F*(z*star z*CFC.sqrt F) := by | |
| simp only [star_mul, (CFC.sqrt_nonneg F).isSelfAdjoint.star_eq, mul_assoc] | |
| _ = F := by rw [hs, CFC.sqrt_mul_sqrt_self F hF] | |
| theorem graph_failure (htn : βtβ β€ 1) (c y : D) (hy : 0 β€ y) (hcn : βcβ β€ 1) | |
| (T : Fin 4 β D) (hT : β i, T i β Her h) (hTn : β i, βT iβ β€ 1) | |
| (hTX : β i, T i β Her (cut (graphX V htH (c*y*star c)) (1/32))) | |
| (hd : y * (1-star c*(graphP V ht htH T hT * graphP V ht htH T hT)*c)*y=0) : | |
| βgraphX V htH (c*y*star c)β=βyβ β§ β i, graphB V htH (c*y*star c) i = T i := by | |
| let z := graphZ V ht htH T hT | |
| let p := z*star z | |
| let F := c*y*star c | |
| let Hβ := star z*F*z | |
| have hp : 0 β€ p := mul_star_self_nonneg z | |
| have hpn : βpβ β€ 1 := by | |
| change βgraphP V ht htH T hTβ β€ 1 | |
| change βz*star zβ β€ 1 | |
| rw [CStarRing.norm_self_mul_star, β CStarRing.norm_star_mul_self] | |
| change βstar (graphZ V ht htH T hT)*graphZ V ht htH T hTβ β€ 1 | |
| rw [graphZ_inner V ht htH T hT hTn] | |
| exact htn | |
| have hz : star z*z=t := graphZ_inner V ht htH T hT hTn | |
| have hdf : y*(1-star c*(p*p)*c)*y=0 := hd | |
| obtain β¨hpc,hccβ© := graph_defect_forces hp hpn hcn hy hdf | |
| have hF : 0 β€ F := star_right_conjugate_nonneg hy c | |
| have hFH : 0 β€ Hβ := star_left_conjugate_nonneg hF z | |
| have hpF : p*F=F := by | |
| change p*(c*y*star c)=c*y*star c | |
| rw [β mul_assoc, hpc] | |
| have hFp : F*p=F := by | |
| simpa only [star_mul, hF.isSelfAdjoint.star_eq, hp.isSelfAdjoint.star_eq] using congrArg star hpF | |
| have heF : F=z*Hβ*star z := by | |
| calc | |
| F = p*F*p := by rw [hpF,hFp] | |
| _ = z*Hβ*star z := by dsimp [p,Hβ]; noncomm_ring | |
| have htHβ : t*Hβ=Hβ := by | |
| calc | |
| t*Hβ = star z*(p*F)*z := by rw [β hz]; dsimp [Hβ,p]; noncomm_ring | |
| _ = Hβ := by rw [hpF] | |
| have hHβt : Hβ*t=Hβ := by | |
| simpa only [star_mul, hFH.isSelfAdjoint.star_eq, ht.isSelfAdjoint.star_eq] using congrArg star htHβ | |
| have hrHβ : CFC.sqrt t*Hβ=Hβ := sqrt_fixed_of_fixed ht htHβ | |
| have hHβr : Hβ*CFC.sqrt t=Hβ := by | |
| simpa only [star_mul, hFH.isSelfAdjoint.star_eq, (CFC.sqrt_nonneg t).isSelfAdjoint.star_eq] | |
| using congrArg star hrHβ | |
| have hWβ : star (graphSlot V htH 0)*z=(1/4 : β) β’ (t*CFC.sqrt t) := | |
| graphSlot0_Z V ht htH T hT | |
| have hzW : star z*graphSlot V htH 0=(1/4 : β) β’ (CFC.sqrt t*t) := by | |
| simpa only [star_mul, star_star, star_smul, star_trivial, | |
| ht.isSelfAdjoint.star_eq, (CFC.sqrt_nonneg t).isSelfAdjoint.star_eq] using congrArg star hWβ | |
| have hW (i : Fin 6) : star (graphSlot V htH i)*F*graphSlot V htH 0 = | |
| (star (graphSlot V htH i)*z)*Hβ*(star z*graphSlot V htH 0) := by | |
| rw [heF]; noncomm_ring | |
| have hXeq : graphX V htH F=Hβ := by | |
| rw [graphX, hW 0, hWβ, hzW] | |
| simp only [smul_mul_assoc, mul_smul_comm, smul_smul] | |
| rw [show (t*CFC.sqrt t)*Hβ*(CFC.sqrt t*t)=Hβ by | |
| rw [mul_assoc t (CFC.sqrt t) Hβ, hrHβ, htHβ, β mul_assoc, hHβr, hHβt]] | |
| norm_num | |
| have hX : 0 β€ graphX V htH F := graphX_nonneg V htH hF | |
| refine β¨?_, fun i => ?_β© | |
| Β· rw [hXeq, norm_compression_eq_of_fixed hF hpF, norm_conjugate_eq_of_isometric_on hy hcc] | |
| Β· have hTi := hTX i | |
| change T i β Her (cut (graphX V htH F) (1/32)) at hTi | |
| have htX : t*graphX V htH F=graphX V htH F := by rw [hXeq]; exact htHβ | |
| have htT : t*T i=T i := Her_fixed_left htX (Her_mono_of_mem (cut_mem_Her hX _) hTi) | |
| have hright := right_fixed_by_graphInverse hX hTi | |
| change graphB V htH F i=T i | |
| rw [graphB, hW i.castSucc.succ, graphSlot_Z V ht htH T hT i, hzW] | |
| simp only [smul_mul_assoc, mul_smul_comm, smul_smul] | |
| have he : (t*T i*CFC.sqrt t)*Hβ*(CFC.sqrt t*t)*graphInverse (graphX V htH F) = T i := by | |
| calc | |
| _ = (t*T i)*Hβ*graphInverse (graphX V htH F) := by | |
| rw [mul_assoc (t*T i) (CFC.sqrt t) Hβ, hrHβ, | |
| mul_assoc (t*T i) Hβ (CFC.sqrt t*t), β mul_assoc Hβ, | |
| hHβr, hHβt] | |
| _ = T i := by rw [htT, β hXeq, mul_assoc]; exact hright | |
| rw [he] | |
| norm_num | |
| end GraphConstruction | |
| section AbstractMeasurements | |
| variable {D : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] | |
| def measurementX (w F : D) : D := (16 : β) β’ (star w*F*w) | |
| def measurementB (w : Fin 6 β D) (F : D) (i : Fin 4) : D := | |
| (16 : β) β’ (star (w i.castSucc.succ)*F*w 0*graphInverse (measurementX (w 0) F)) | |
| theorem graph_failure_of_identities {t z : D} (ht : 0 β€ t) (htn : βtβ β€ 1) | |
| (w : Fin 6 β D) (hz : star z*z=t) (T : Fin 4 β D) | |
| (hWβ : star (w 0)*z=(1/4 : β) β’ (t*CFC.sqrt t)) | |
| (hWi : β i : Fin 4, star (w i.castSucc.succ)*z=(1/4 : β) β’ (t*T i*CFC.sqrt t)) | |
| (c y : D) (hy : 0 β€ y) (hcn : βcβ β€ 1) | |
| (hTX : β i, T i β Her (cut (measurementX (w 0) (c*y*star c)) (1/32))) | |
| (hd : y*(1-star c*((z*star z)*(z*star z))*c)*y=0) : | |
| βmeasurementX (w 0) (c*y*star c)β=βyβ β§ β i, measurementB w (c*y*star c) i=T i := by | |
| let p := z*star z | |
| let F := c*y*star c | |
| let Hβ := star z*F*z | |
| have hp : 0 β€ p := mul_star_self_nonneg z | |
| have hpn : βpβ β€ 1 := by | |
| change βz*star zβ β€ 1 | |
| rw [CStarRing.norm_self_mul_star, β CStarRing.norm_star_mul_self, hz] | |
| exact htn | |
| have hdf : y*(1-star c*(p*p)*c)*y=0 := hd | |
| obtain β¨hpc,hccβ© := graph_defect_forces hp hpn hcn hy hdf | |
| have hF : 0 β€ F := star_right_conjugate_nonneg hy c | |
| have hFH : 0 β€ Hβ := star_left_conjugate_nonneg hF z | |
| have hpF : p*F=F := by | |
| change p*(c*y*star c)=c*y*star c | |
| rw [β mul_assoc, hpc] | |
| have hFp : F*p=F := by | |
| simpa only [star_mul, hF.isSelfAdjoint.star_eq, hp.isSelfAdjoint.star_eq] using congrArg star hpF | |
| have heF : F=z*Hβ*star z := by | |
| calc | |
| F = p*F*p := by rw [hpF,hFp] | |
| _ = z*Hβ*star z := by dsimp [p,Hβ]; noncomm_ring | |
| have htHβ : t*Hβ=Hβ := by | |
| calc | |
| t*Hβ = star z*(p*F)*z := by rw [β hz]; dsimp [Hβ,p]; noncomm_ring | |
| _ = Hβ := by rw [hpF] | |
| have hHβt : Hβ*t=Hβ := by | |
| simpa only [star_mul, hFH.isSelfAdjoint.star_eq, ht.isSelfAdjoint.star_eq] using congrArg star htHβ | |
| have hrHβ : CFC.sqrt t*Hβ=Hβ := sqrt_fixed_of_fixed ht htHβ | |
| have hHβr : Hβ*CFC.sqrt t=Hβ := by | |
| simpa only [star_mul, hFH.isSelfAdjoint.star_eq, (CFC.sqrt_nonneg t).isSelfAdjoint.star_eq] | |
| using congrArg star hrHβ | |
| have hzW : star z*w 0=(1/4 : β) β’ (CFC.sqrt t*t) := by | |
| simpa only [star_mul, star_star, star_smul, star_trivial, | |
| ht.isSelfAdjoint.star_eq, (CFC.sqrt_nonneg t).isSelfAdjoint.star_eq] using congrArg star hWβ | |
| have hW (i : Fin 6) : star (w i)*F*w 0 = | |
| (star (w i)*z)*Hβ*(star z*w 0) := by | |
| rw [heF]; noncomm_ring | |
| have hXeq : measurementX (w 0) F=Hβ := by | |
| rw [measurementX, hW 0, hWβ, hzW] | |
| simp only [smul_mul_assoc, mul_smul_comm, smul_smul] | |
| rw [show (t*CFC.sqrt t)*Hβ*(CFC.sqrt t*t)=Hβ by | |
| rw [mul_assoc t (CFC.sqrt t) Hβ, hrHβ, htHβ, β mul_assoc, hHβr, hHβt]] | |
| norm_num | |
| have hX : 0 β€ measurementX (w 0) F := smul_nonneg (by norm_num) (star_left_conjugate_nonneg hF (w 0)) | |
| refine β¨?_, fun i => ?_β© | |
| Β· rw [hXeq, norm_compression_eq_of_fixed hF hpF, norm_conjugate_eq_of_isometric_on hy hcc] | |
| Β· have hTi := hTX i | |
| change T i β Her (cut (measurementX (w 0) F) (1/32)) at hTi | |
| have htX : t*measurementX (w 0) F=measurementX (w 0) F := by rw [hXeq]; exact htHβ | |
| have htT : t*T i=T i := Her_fixed_left htX (Her_mono_of_mem (cut_mem_Her hX _) hTi) | |
| have hright := right_fixed_by_graphInverse hX hTi | |
| change measurementB w F i=T i | |
| rw [measurementB, hW i.castSucc.succ, hWi i, hzW] | |
| simp only [smul_mul_assoc, mul_smul_comm, smul_smul] | |
| have he : (t*T i*CFC.sqrt t)*Hβ*(CFC.sqrt t*t)*graphInverse (measurementX (w 0) F) = T i := by | |
| calc | |
| _ = (t*T i)*Hβ*graphInverse (measurementX (w 0) F) := by | |
| rw [mul_assoc (t*T i) (CFC.sqrt t) Hβ, hrHβ, | |
| mul_assoc (t*T i) Hβ (CFC.sqrt t*t), β mul_assoc Hβ, | |
| hHβr, hHβt] | |
| _ = T i := by rw [htT, β hXeq, mul_assoc]; exact hright | |
| rw [he] | |
| norm_num | |
| end AbstractMeasurements | |
| section RepresentedGraph | |
| variable {D E : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] | |
| [CStarAlgebra E] [PartialOrder E] [StarOrderedRing E] | |
| variable (Ο : D βββ[β] E) {h a t : D} (V : OrthogonalSlots 6 h a) | |
| (ht : 0 β€ t) (htH : t β Her h) | |
| omit [PartialOrder D] [StarOrderedRing D] [PartialOrder E] [StarOrderedRing E] in | |
| lemma graph_map_real_smul (r : β) (x : D) : Ο (r β’ x) = r β’ Ο x := | |
| Ο.toAlgHom.map_smul_of_tower r x | |
| lemma graph_map_inverse {X : D} (hX : 0 β€ X) : | |
| Ο (graphInverse X)=graphInverse (Ο X) := map_graphInverse Ο.toNonUnitalStarAlgHom hX | |
| omit [PartialOrder D] [StarOrderedRing D] [PartialOrder E] [StarOrderedRing E] in | |
| lemma graphX_map (F : D) : Ο (graphX V htH F) = | |
| measurementX (Ο (graphSlot V htH 0)) (Ο F) := by | |
| simp only [graphX, measurementX, graph_map_real_smul Ο, map_mul, map_star] | |
| lemma graphB_map {F : D} (hF : 0 β€ F) (i : Fin 4) : Ο (graphB V htH F i) = | |
| measurementB (fun j => Ο (graphSlot V htH j)) (Ο F) i := by | |
| simp only [graphB, measurementB, graph_map_real_smul Ο, map_mul, map_star, | |
| graph_map_inverse Ο (graphX_nonneg V htH hF), graphX_map] | |
| theorem graph_failure_represented (htn : βtβ β€ 1) (c y : D) (hy : 0 β€ y) (hcn : βcβ β€ 1) | |
| (T : Fin 4 β D) (hT : β i, T i β Her h) (hTn : β i, βT iβ β€ 1) | |
| (hTX : β i, T i β Her (cut (graphX V htH (c*y*star c)) (1/32))) | |
| (hd : Ο (y * (1-star c*(graphP V ht htH T hT * graphP V ht htH T hT)*c)*y)=0) : | |
| βΟ (graphX V htH (c*y*star c))β=βΟ yβ β§ | |
| β i, Ο (graphB V htH (c*y*star c) i) = Ο (T i) := by | |
| have hF : 0 β€ c*y*star c := star_right_conjugate_nonneg hy c | |
| have hm : Ο (CFC.sqrt t)=CFC.sqrt (Ο t) := | |
| Ο.toNonUnitalStarAlgHom.map_cfcβ NNReal.sqrt t (by fun_prop) (by simp) | |
| (map_continuous Ο) ht (map_nonneg Ο ht) | |
| have hc := graph_failure_of_identities (map_nonneg Ο ht) | |
| ((NonUnitalStarAlgHom.norm_apply_le Ο t).trans htn) | |
| (fun j => Ο (graphSlot V htH j)) (z := Ο (graphZ V ht htH T hT)) | |
| (by simpa only [map_mul, map_star] using congrArg Ο (graphZ_inner V ht htH T hT hTn)) | |
| (fun i => Ο (T i)) | |
| (by simpa only [map_mul, map_star, graph_map_real_smul Ο, hm] using | |
| (congrArg Ο (graphSlot0_Z V ht htH T hT))) | |
| (fun i => by simpa only [map_mul, map_star, graph_map_real_smul Ο, hm] using | |
| (congrArg Ο (graphSlot_Z V ht htH T hT i))) | |
| (Ο c) (Ο y) (map_nonneg Ο hy) | |
| ((NonUnitalStarAlgHom.norm_apply_le Ο c).trans hcn) (fun i => ?_) ?_ | |
| Β· simpa only [graphX_map, graphB_map Ο V htH hF, map_mul, map_star] using hc | |
| Β· have hmem := Her_map Ο.toNonUnitalStarAlgHom (hTX i) | |
| have hh := cut_map Ο.toNonUnitalStarAlgHom (graphX V htH (c*y*star c)) (1/32) | |
| (graphX_nonneg V htH hF).isSelfAdjoint (by norm_num) | |
| change Ο (T i) β Her (Ο (cut (graphX V htH (c*y*star c)) (1/32))) at hmem | |
| change cut (Ο (graphX V htH (c*y*star c))) (1/32) = | |
| Ο (cut (graphX V htH (c*y*star c)) (1/32)) at hh | |
| rw [β hh] at hmem | |
| simpa only [graphX_map, map_mul, map_star] using hmem | |
| Β· simpa only [graphP, map_mul, map_star, map_sub, map_one] using hd | |
| end RepresentedGraph | |
| end MainGap | |
| namespace MainGap | |
| universe u v | |
| variable {A : Type u} [CStarAlgebra A] | |
| local instance graphNonvanishingOrder : PartialOrder A := CStarAlgebra.spectralOrder A | |
| local instance graphNonvanishingStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A | |
| local instance graphOperatorOrder (J : Type*) [NormedAddCommGroup J] [InnerProductSpace β J] [CompleteSpace J] : | |
| PartialOrder (J βL[β] J) := CStarAlgebra.spectralOrder _ | |
| local instance graphOperatorStarOrder (J : Type*) [NormedAddCommGroup J] [InnerProductSpace β J] [CompleteSpace J] : | |
| StarOrderedRing (J βL[β] J) := CStarAlgebra.spectralOrderedRing _ | |
| theorem graph_nonvanishing {a y c : A} (ha : 0 β€ a) (hy : 0 β€ y) (hcn : βcβ β€ 1) | |
| (hp : β z : A, 0 β€ z β z β Her a β ProperlyInfinite z) : | |
| β p : A, 0 β€ p β§ βpβ β€ 1 β§ p β Her a β§ | |
| (β R : HilbertRep.{u,v} A, (1/2 : β) < βR.hom aβ β βR.hom pβ=1) β§ | |
| (β R : HilbertRep.{u,v} A, R.hom (y*(1-star c*(p*p)*c)*y)=0 β βR.hom yβ β€ (1/4 : β)) := by | |
| classical | |
| obtain β¨Vβ© := (hp a ha (self_mem_Her ha)).orthogonalSlots ha 6 (by norm_num : (0:β)<1/8) | |
| let t := ramp a (1/4) (1/2) | |
| have ht : 0 β€ t := ramp_nonneg a (by norm_num) | |
| have htn : βtβ β€ 1 := norm_ramp_le_one a (by norm_num) | |
| have htH : t β Her (cut a (1/8)) := by | |
| have hcut : cut a (1/4) β Her (cut a (1/8)) := by | |
| have hh := cut_mem_Her (cut_nonneg a (1/8)) (1/8) | |
| rw [cut_cut ha (by norm_num) (by norm_num)] at hh | |
| convert hh using 1; norm_num | |
| exact Her_mono_of_mem hcut (ramp_mem_Her_cut ha (by norm_num)) | |
| let F := c*y*star c | |
| have hF : 0 β€ F := star_right_conjugate_nonneg hy c | |
| let X := graphX V htH F | |
| let B := graphB V htH F | |
| have hX : 0 β€ X := graphX_nonneg V htH hF | |
| have hXH : X β Her (cut a (1/8)) := graphX_mem V ht htH F | |
| have hfour : fourHer X β€ Her (cut a (1/8)) := | |
| Her_mono_of_mem (Her_mono_of_mem hXH (cut_mem_Her hX (1/32))) | |
| obtain β¨T,hTn,hTX,havoidβ© := four_avoidance_unital.{u,v} hX B (fun z hz hzm => | |
| hp z hz (Her_mono_of_mem (cut_mem_Her ha (1/8)) (hfour hzm))) | |
| have hT : β i, T i β Her (cut a (1/8)) := fun i => hfour (hTX i) | |
| let p := graphP V ht htH T hT | |
| have hpn : βpβ β€ 1 := by | |
| have he := graphP_represented_norm V ht htH (NonUnitalStarAlgHom.id β A) T hT hTn | |
| change βpβ=βtβ at he | |
| rw [he] | |
| exact htn | |
| refine β¨p, graphP_nonneg V ht htH T hT, hpn, graphP_mem V ht htH T hT, ?_, ?_β© | |
| Β· intro R hRa | |
| change βR.hom.toNonUnitalStarAlgHom (graphP V ht htH T hT)β=1 | |
| rw [graphP_represented_norm V ht htH R.hom.toNonUnitalStarAlgHom T hT hTn] | |
| change βR.hom (ramp a (1/4) (1/2))β=1 | |
| rw [map_ramp_sa R.hom ha.isSelfAdjoint (by norm_num)] | |
| exact norm_ramp_eq_one (map_nonneg R.hom ha) (by norm_num) (by norm_num) hRa.le | |
| Β· intro R hd | |
| by_contra! hRy | |
| obtain β¨hRX,hBβ© := graph_failure_represented R.hom V ht htH htn c y hy hcn T hT hTn hTX hd | |
| exact havoid R (by rw [hRX]; exact hRy) | |
| (fun i => (hB i).symm) | |
| end MainGap | |
| end | |
| end OAI | |