| import OAI.Analysis.CStarAlgebra.PureInfiniteness.Nonvanishing |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open Filter |
| open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace |
|
|
| namespace MainGap |
| variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] |
|
|
| def cutInverseFn (δ t : ℝ) : ℝ := t/(max δ t)^2 |
|
|
| lemma continuous_cutInverseFn {δ : ℝ} (hδ : 0 < δ) : Continuous (cutInverseFn δ) := by |
| exact continuous_id.div (((continuous_const.max continuous_id).pow 2)) |
| (fun t => pow_ne_zero _ (ne_of_gt (hδ.trans_le (le_max_left _ _)))) |
|
|
| lemma cutInverseFn_zero (δ : ℝ) : cutInverseFn δ 0=0 := by simp [cutInverseFn] |
|
|
| def cutInverse (a : A) (δ : ℝ) : A := cfcₙ (cutInverseFn δ) a |
|
|
| lemma cutInverseFn_bound {δ t : ℝ} (hδ : 0 < δ) (ht : 0 ≤ t) : |
| 0 ≤ cutInverseFn δ t ∧ cutInverseFn δ t ≤ 1/δ := by |
| refine ⟨div_nonneg ht (sq_nonneg _), ?_⟩ |
| by_cases htδ : t ≤ δ |
| · dsimp [cutInverseFn] |
| rw [max_eq_left htδ] |
| apply (div_le_iff₀ (sq_pos_of_pos hδ)).mpr |
| calc |
| t ≤ δ := htδ |
| _ = 1/δ*δ^2 := by field_simp |
| · have htpos : 0 < t := hδ.trans (lt_of_not_ge htδ) |
| have he : cutInverseFn δ t=1/t := by |
| dsimp [cutInverseFn] |
| rw [max_eq_right (le_of_not_ge htδ)] |
| field_simp |
| rw [he] |
| exact one_div_le_one_div_of_le hδ (le_of_not_ge htδ) |
|
|
| lemma norm_cutInverse_le {a : A} (ha : 0 ≤ a) {δ : ℝ} (hδ : 0 < δ) : |
| ‖cutInverse a δ‖ ≤ 1/δ := by |
| apply norm_cfcₙ_le |
| intro t ht |
| have hb := cutInverseFn_bound hδ (quasispectrum_nonneg_of_nonneg a ha t ht) |
| rw [Real.norm_eq_abs, abs_of_nonneg hb.1] |
| exact hb.2 |
|
|
| lemma cut_mul_cutInverse {a : A} (ha : 0 ≤ a) {δ : ℝ} (hδ : 0 < δ) : |
| cut a δ * (cutInverse a δ * a) = cut a δ := by |
| have hc : Continuous (fun t : ℝ => max (t-δ) 0) := by fun_prop |
| have h0 : (fun t : ℝ => max (t-δ) 0) 0=0 := by |
| simp [max_eq_right (neg_nonpos.mpr hδ.le)] |
| have he : cutInverse a δ*a = cfcₙ (fun t : ℝ => cutInverseFn δ t*t) a := by |
| simpa only [id_eq, cfcₙ_id' ℝ a ha.isSelfAdjoint, cutInverse] using |
| (cfcₙ_mul (cutInverseFn δ) id a (continuous_cutInverseFn hδ).continuousOn |
| (cutInverseFn_zero δ) continuousOn_id rfl).symm |
| rw [he, cut, ← cfcₙ_mul (fun t : ℝ => max (t-δ) 0) |
| (fun t : ℝ => cutInverseFn δ t*t) a hc.continuousOn h0 |
| ((continuous_cutInverseFn hδ).mul continuous_id).continuousOn (by simp [cutInverseFn_zero])] |
| apply cfcₙ_congr |
| intro t _ |
| dsimp only |
| by_cases ht : t ≤ δ |
| · rw [max_eq_right (sub_nonpos.mpr ht), zero_mul] |
| · have ht0 : t ≠ 0 := ne_of_gt (hδ.trans (lt_of_not_ge ht)) |
| dsimp [cutInverseFn] |
| rw [max_eq_right (le_of_not_ge ht)] |
| field_simp |
|
|
| lemma Her_right_fixed_cutInverse {a x : A} (ha : 0 ≤ a) {δ : ℝ} (hδ : 0 < δ) |
| (hx : x ∈ Her (cut a δ)) : x*(cutInverse a δ*a)=x := |
| Her_fixed_right (cut_nonneg a δ).isSelfAdjoint (cut_mul_cutInverse ha hδ) hx |
|
|
| end MainGap |
|
|
| namespace MainGap |
| variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] |
|
|
| def HerCompression (p q c : A) (κ : ℝ) : Prop := |
| ∀ x : A, x ∈ Her p → ∀ k : A, k ∈ Her q → ‖x*c*k‖ ≤ κ * ‖x‖ * ‖k‖ |
|
|
| lemma cut_sqrt_lower {d : A} (hd : 0 ≤ d) {δ : ℝ} (hδ : 0 ≤ δ) : |
| δ • cut d δ ≤ CFC.sqrt (cut d δ) * d * CFC.sqrt (cut d δ) := by |
| let f : ℝ → ℝ := fun t => max (t-δ) 0 |
| have hf : Continuous f := (continuous_id.sub continuous_const).max continuous_const |
| have hf0 : f 0=0 := by simp [f, max_eq_right (neg_nonpos.mpr hδ)] |
| have hl : δ • cut d δ ≤ d * cut d δ := by |
| change δ • cfcₙ f d ≤ d * cfcₙ f d |
| have hu : cfcₙ (fun t => t*f t) d = d*cfcₙ f d := by |
| rw [cfcₙ_mul (fun t : ℝ => t) f d continuousOn_id rfl hf.continuousOn hf0] |
| exact congrArg (fun x => x*cfcₙ f d) (cfcₙ_id ℝ d hd.isSelfAdjoint) |
| rw [← cfcₙ_const_mul δ f d hf.continuousOn hf0, ← hu] |
| apply (cfcₙ_le_iff _ _ d (continuous_const.mul hf).continuousOn |
| (continuous_id.mul hf).continuousOn (by simp [hf0]) (by simp [hf0]) hd.isSelfAdjoint).mpr |
| intro t _ |
| by_cases ht : δ ≤ t |
| · exact mul_le_mul_of_nonneg_right ht (le_max_right _ _) |
| · simp [f, max_eq_right (by linarith : t-δ ≤ 0)] |
| have hc : Commute (cut d δ) d := (Commute.refl d).cfcₙ_real f |
| have hs : Commute (CFC.sqrt (cut d δ)) d := hc.cfcₙ_nnreal NNReal.sqrt |
| calc |
| δ • cut d δ ≤ d * cut d δ := hl |
| _ = CFC.sqrt (cut d δ) * d * CFC.sqrt (cut d δ) := by |
| rw [hs.eq, mul_assoc, CFC.sqrt_mul_sqrt_self (cut d δ) (cut_nonneg d δ)] |
|
|
| lemma norm_mul_factor_of_order {m z : A} {r : ℝ} (hr : 0 ≤ r) |
| (h : star (m*z) * (m*z) ≤ r^2 • (star z*z)) (b : A) : |
| ‖m*(z*b)‖ ≤ r*‖z*b‖ := by |
| have ho := star_left_conjugate_le_conjugate h b |
| have ht : star (m*(z*b))*(m*(z*b)) ≤ r^2 • (star (z*b)*(z*b)) := by |
| simpa only [star_mul, mul_assoc, mul_smul_comm, smul_mul_assoc] using ho |
| have hn := CStarAlgebra.norm_le_norm_of_le_of_nonneg ht (star_mul_self_nonneg _) |
| rw [CStarRing.norm_star_mul_self, norm_smul, Real.norm_eq_abs, |
| abs_of_nonneg (sq_nonneg r), CStarRing.norm_star_mul_self] at hn |
| apply (sq_le_sq₀ (norm_nonneg _) (mul_nonneg hr (norm_nonneg _))).mp |
| calc |
| ‖m*(z*b)‖^2 = ‖m*(z*b)‖*‖m*(z*b)‖ := pow_two _ |
| _ ≤ r^2 * (‖z*b‖*‖z*b‖) := hn |
| _ = (r*‖z*b‖)^2 := by ring |
|
|
| lemma norm_mul_Her_of_order {m z : A} {r : ℝ} (hr : 0 ≤ r) |
| (h : star (m*z) * (m*z) ≤ r^2 • (star z*z)) |
| {k : A} (hk : k ∈ Her (z*star z)) : ‖m*k‖ ≤ r*‖k‖ := by |
| have hc : IsClosed {k : A | ‖m*k‖ ≤ r*‖k‖} := isClosed_le (by fun_prop) (by fun_prop) |
| apply closure_minimal (s := Set.range (fun b : A => (z*star z)*b*star (z*star z))) _ hc hk |
| rintro k ⟨b, rfl⟩ |
| change ‖m*((z*star z)*b*star (z*star z))‖ ≤ r*‖(z*star z)*b*star (z*star z)‖ |
| simpa only [star_mul, star_star, mul_assoc] using |
| norm_mul_factor_of_order hr h (star z*b*(z*star z)) |
|
|
| end MainGap |
|
|
| namespace MainGap |
| variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] |
|
|
| lemma conditional_defect_bounds {p y c : A} (hp : 0 ≤ p) (hy : 0 ≤ y) |
| (hpn : ‖p‖ ≤ 1) (hyn : ‖y‖ ≤ 1) (hcn : ‖c‖ ≤ 1) : |
| 0 ≤ y*(1-star c*(p*p)*c)*y ∧ |
| y*(1-star c*(p*p)*c)*y ≤ y*y ∧ y*y ≤ 1 := by |
| have hm : ‖p*c‖ ≤ 1 := (norm_mul_le _ _).trans (by nlinarith [norm_nonneg p, norm_nonneg c]) |
| have hm₁ : star (p*c)*(p*c) ≤ 1 := by |
| apply (CStarAlgebra.norm_le_one_iff_of_nonneg _ (star_mul_self_nonneg _)).mp |
| rw [CStarRing.norm_star_mul_self] |
| nlinarith [norm_nonneg (p*c)] |
| have he : star (p*c)*(p*c) = star c*(p*p)*c := by |
| simp only [star_mul, hp.isSelfAdjoint.star_eq, mul_assoc] |
| have hn : 0 ≤ 1-star c*(p*p)*c := sub_nonneg.mpr (he ▸ hm₁) |
| have hl : 1-star c*(p*p)*c ≤ 1 := sub_le_self _ (he ▸ star_mul_self_nonneg (p*c)) |
| refine ⟨?_, ?_, ?_⟩ |
| · simpa only [hy.isSelfAdjoint.star_eq] using star_left_conjugate_nonneg hn y |
| · simpa only [hy.isSelfAdjoint.star_eq, mul_one] using star_left_conjugate_le_conjugate hl y |
| · apply (CStarAlgebra.norm_le_one_iff_of_nonneg _ ?_).mp |
| · rw [hy.isSelfAdjoint.norm_mul_self] |
| nlinarith [norm_nonneg y] |
| · simpa only [hy.isSelfAdjoint.star_eq] using star_mul_self_nonneg y |
|
|
| lemma conditional_order_loss {p y c d : A} (hp : 0 ≤ p) (hy : 0 ≤ y) |
| (hd : 0 ≤ d) (_hyd : d ≤ y*y) (hy₂ : y*y ≤ 1) |
| (he : d=y*(1-star c*(p*p)*c)*y) {δ : ℝ} (hδ : 0 ≤ δ) : |
| let z := y*CFC.sqrt (cut d δ) |
| star ((p*c)*z)*((p*c)*z) ≤ (1-δ) • (star z*z) := by |
| let s := CFC.sqrt (cut d δ) |
| let z := y*s |
| have hs : IsSelfAdjoint s := (CFC.sqrt_nonneg _).isSelfAdjoint |
| have hZ : star z*z ≤ cut d δ := by |
| calc |
| star z*z = s*(y*y)*s := by |
| dsimp [z] |
| simp only [star_mul, hs.star_eq, hy.isSelfAdjoint.star_eq, mul_assoc] |
| _ ≤ s*1*s := by |
| simpa only [hs.star_eq] using star_left_conjugate_le_conjugate hy₂ s |
| _ = cut d δ := by |
| rw [mul_one] |
| exact CFC.sqrt_mul_sqrt_self (cut d δ) (cut_nonneg d δ) |
| have hδZ : δ • (star z*z) ≤ s*d*s := |
| (smul_le_smul_of_nonneg_left hZ hδ).trans (cut_sqrt_lower hd hδ) |
| have hid : star ((p*c)*z)*((p*c)*z) = star z*z-s*d*s := by |
| dsimp [z] |
| rw [he] |
| simp only [star_mul, hp.isSelfAdjoint.star_eq, hy.isSelfAdjoint.star_eq, hs.star_eq] |
| noncomm_ring |
| change star ((p*c)*z)*((p*c)*z) ≤ (1-δ) • (star z*z) |
| rw [hid, sub_smul, one_smul] |
| exact sub_le_sub_left hδZ _ |
|
|
| lemma conditional_Her_loss {p y c : A} (hp : 0 ≤ p) (hy : 0 ≤ y) |
| (hpn : ‖p‖ ≤ 1) (hyn : ‖y‖ ≤ 1) (hcn : ‖c‖ ≤ 1) |
| {δ : ℝ} (hδ : 0 ≤ δ) (hδ₁ : δ ≤ 1) : |
| let d := y*(1-star c*(p*p)*c)*y |
| let q := y*cut d δ*y |
| ∀ k : A, k ∈ Her q → ‖p*c*k‖ ≤ Real.sqrt (1-δ) * ‖k‖ := by |
| let d := y*(1-star c*(p*p)*c)*y |
| let z := y*CFC.sqrt (cut d δ) |
| have hb := conditional_defect_bounds hp hy hpn hyn hcn |
| have hh : star ((p*c)*z)*((p*c)*z) ≤ (Real.sqrt (1-δ))^2 • (star z*z) := by |
| rw [Real.sq_sqrt (sub_nonneg.mpr hδ₁)] |
| exact conditional_order_loss hp hy hb.1 hb.2.1 hb.2.2 rfl hδ |
| have hq : z*star z=y*cut d δ*y := by |
| dsimp [z] |
| simp only [star_mul, hy.isSelfAdjoint.star_eq, (CFC.sqrt_nonneg (cut d δ)).isSelfAdjoint.star_eq] |
| calc |
| y*CFC.sqrt (cut d δ)*(CFC.sqrt (cut d δ)*y) = |
| y*(CFC.sqrt (cut d δ)*CFC.sqrt (cut d δ))*y := by simp only [mul_assoc] |
| _ = _ := by rw [CFC.sqrt_mul_sqrt_self (cut d δ) (cut_nonneg d δ)] |
| change ∀ k : A, k ∈ Her (y*cut d δ*y) → ‖p*c*k‖ ≤ Real.sqrt (1-δ)*‖k‖ |
| intro k hk |
| exact norm_mul_Her_of_order (Real.sqrt_nonneg _) hh (hq.symm ▸ hk) |
|
|
| end MainGap |
|
|
| namespace MainGap |
| variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] |
|
|
| lemma conditional_q_zero {p y c : A} (hp : 0 ≤ p) (hy : 0 ≤ y) |
| (hpn : ‖p‖ ≤ 1) (hyn : ‖y‖ ≤ 1) (hcn : ‖c‖ ≤ 1) |
| {δ : ℝ} (hδ : 0 < δ) |
| (hq : y*cut (y*(1-star c*(p*p)*c)*y) δ*y=0) : |
| ‖y*(1-star c*(p*p)*c)*y‖ ≤ δ := by |
| let d := y*(1-star c*(p*p)*c)*y |
| let h := cut d δ |
| let s := CFC.sqrt h |
| have hs : IsSelfAdjoint s := (CFC.sqrt_nonneg h).isSelfAdjoint |
| have hd := conditional_defect_bounds hp hy hpn hyn hcn |
| have hzz : (y*s)*star (y*s) = y*h*y := by |
| simp only [star_mul, hs.star_eq, hy.isSelfAdjoint.star_eq] |
| calc |
| y*s*(s*y)= y*(s*s)*y := by simp only [mul_assoc] |
| _ = y*h*y := by rw [show s*s=h from CFC.sqrt_mul_sqrt_self h (cut_nonneg d δ)] |
| have hz : y*s=0 := (CStarRing.mul_star_self_eq_zero_iff _).mp (hzz.trans hq) |
| have hl : δ • h ≤ 0 := by |
| calc |
| δ • h ≤ s*d*s := cut_sqrt_lower hd.1 hδ.le |
| _ ≤ s*(y*y)*s := by |
| simpa only [hs.star_eq] using star_left_conjugate_le_conjugate hd.2.1 s |
| _ = star (y*s)*(y*s) := by |
| simp only [star_mul, hs.star_eq, hy.isSelfAdjoint.star_eq, mul_assoc] |
| _ = 0 := by rw [hz, star_zero, mul_zero] |
| have hsm : δ • h=0 := le_antisymm hl (smul_nonneg hδ.le (cut_nonneg d δ)) |
| have hh : h=0 := (smul_eq_zero.mp hsm).resolve_left (ne_of_gt hδ) |
| have hb := norm_sub_cut_le hd.1 hδ.le |
| change ‖d-h‖ ≤ δ at hb |
| simpa only [hh, sub_zero] using hb |
|
|
| lemma compression_of_conditional_loss {p q c : A} (hp : 0 ≤ p) {τ r : ℝ} |
| (hτ : 0 < τ) (_hr : 0 ≤ r) |
| (h : ∀ k : A, k ∈ Her q → ‖p*c*k‖ ≤ r*‖k‖) : |
| HerCompression (ramp p τ 1) q c (r/τ) := by |
| intro x hx k hk |
| have hxH : x ∈ Her (cut p τ) := |
| Her_mono_of_mem (ramp_mem_Her_cut hp hτ.le) hx |
| have hfix : x*(cutInverse p τ*p)=x := Her_right_fixed_cutInverse hp hτ hxH |
| have he : x*c*k = (x*cutInverse p τ)*(p*c*k) := by |
| calc |
| x*c*k = (x*(cutInverse p τ*p))*c*k := by rw [hfix] |
| _ = _ := by simp only [mul_assoc] |
| rw [he] |
| calc |
| ‖(x*cutInverse p τ)*(p*c*k)‖ ≤ ‖x*cutInverse p τ‖*‖p*c*k‖ := norm_mul_le _ _ |
| _ ≤ (‖x‖*(1/τ))*(r*‖k‖) := by |
| apply mul_le_mul |
| · exact (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_left (norm_cutInverse_le hp hτ) (norm_nonneg x)) |
| · exact h k hk |
| · exact norm_nonneg _ |
| · positivity |
| _ = (r/τ)*‖x‖*‖k‖ := by ring |
|
|
| end MainGap |
|
|
| end |
|
|
| end OAI |
|
|
