| 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 |
|
|
