| import Mathlib |
| import OAI.Analysis.TracialSplitting.PreparedBlocks |
| import OAI.Analysis.JiangSu.Excision.PureGNSStrongDensity |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
|
|
| namespace PureStateExcision |
| open scoped ComplexOrder |
|
|
| variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] |
|
|
| def softScalar (t : ℝ) : ℝ := (1+max 0 t)⁻¹ |
| lemma softScalar_continuous : Continuous softScalar := by |
| apply Continuous.inv₀ (by fun_prop) |
| intro t |
| have : 0 < 1+max 0 t := by have := le_max_left 0 t; linarith |
| exact this.ne' |
| lemma softScalar_nonneg (t : ℝ) : 0 ≤ softScalar t := by unfold softScalar; positivity |
| lemma softScalar_le_one (t : ℝ) : softScalar t ≤ 1 := by |
| unfold softScalar |
| exact inv_le_one_of_one_le₀ (by have := le_max_left 0 t; linarith) |
| lemma softScalar_error {t : ℝ} (ht : 0 ≤ t) : 1-softScalar t ≤ t := by |
| unfold softScalar |
| rw [max_eq_right ht] |
| have hd : 0 < 1+t := by linarith |
| apply (mul_le_mul_iff_left₀ hd).mp |
| field_simp |
| nlinarith [sq_nonneg t] |
| lemma softScalar_compressed {t : ℝ} (ht : 0 ≤ t) : softScalar t*t*softScalar t ≤ 1 := by |
| unfold softScalar |
| rw [max_eq_right ht] |
| have hd : 0 < 1+t := by linarith |
| apply (mul_le_mul_iff_left₀ (sq_pos_of_pos hd)).mp |
| field_simp |
| nlinarith [sq_nonneg t] |
|
|
| def softCompression (u : A) : A := cfc softScalar u |
| lemma softCompression_nonneg (u : A) : 0 ≤ softCompression u := |
| cfc_nonneg fun t _ => softScalar_nonneg t |
| lemma softCompression_le_one (u : A) : softCompression u ≤ 1 := |
| cfc_le_one _ _ fun t _ => softScalar_le_one t |
| lemma softCompression_norm_le (u : A) : ‖softCompression u‖ ≤ 1 := |
| (CStarAlgebra.norm_le_one_iff_of_nonneg _ (softCompression_nonneg u)).mpr (softCompression_le_one u) |
| lemma softCompression_error (u : A) (hu : 0 ≤ u) : 1-softCompression u ≤ u := by |
| have ha := hu.isSelfAdjoint |
| have he : 1-softCompression u=cfc (fun t : ℝ => 1-softScalar t) u := by |
| rw [cfc_sub (fun _ : ℝ => 1) softScalar u continuousOn_const softScalar_continuous.continuousOn, cfc_const (1 : ℝ) u, map_one] |
| rfl |
| calc |
| 1-softCompression u=cfc (fun t : ℝ => 1-softScalar t) u := he |
| _ ≤ cfc (fun t : ℝ => t) u := |
| (cfc_le_iff (fun t : ℝ => 1-softScalar t) (fun t : ℝ => t) u |
| (continuous_const.sub softScalar_continuous).continuousOn continuousOn_id ha).mpr |
| fun t ht => softScalar_error (spectrum_nonneg_of_nonneg hu ht) |
| _=u := cfc_id' ℝ u |
| lemma softCompression_compressed (u : A) (hu : 0 ≤ u) : |
| softCompression u*u*softCompression u ≤ 1 := by |
| have ha := hu.isSelfAdjoint |
| have he : softCompression u*u*softCompression u= |
| cfc (fun t => softScalar t*t*softScalar t) u := by |
| rw [cfc_mul (fun t : ℝ => softScalar t*t) softScalar u (softScalar_continuous.mul continuous_id).continuousOn |
| softScalar_continuous.continuousOn,cfc_mul softScalar (fun t : ℝ => t) u softScalar_continuous.continuousOn |
| continuousOn_id,cfc_id' ℝ u] |
| rfl |
| rw [he] |
| exact cfc_le_one _ _ fun t ht => softScalar_compressed (spectrum_nonneg_of_nonneg hu ht) |
|
|
| lemma norm_mul_softCompression_le (u b : A) (hu : 0 ≤ u) {r : ℝ} (hr : 0 ≤ r) |
| (hb : star b*b ≤ r^2 • u) : ‖b*softCompression u‖ ≤ r := by |
| let g := softCompression u |
| have hg := (softCompression_nonneg u).isSelfAdjoint |
| have h : star (b*g)*(b*g) ≤ r^2 • (1 : A) := by |
| calc |
| star (b*g)*(b*g)=g*(star b*b)*g := by rw [star_mul,hg.star_eq]; noncomm_ring |
| _ ≤ g*(r^2 • u)*g := hg.conjugate_le_conjugate hb |
| _=r^2 • (g*u*g) := by simp only [mul_smul_comm,smul_mul_assoc] |
| _ ≤ r^2 • (1 : A) := smul_le_smul_of_nonneg_left (softCompression_compressed u hu) (sq_nonneg r) |
| have hn := CStarAlgebra.norm_le_norm_of_le_of_nonneg h (star_mul_self_nonneg (b*g)) |
| rw [CStarRing.norm_star_mul_self,norm_smul,Real.norm_eq_abs,abs_of_nonneg (sq_nonneg r)] at hn |
| have h1 : ‖(1 : A)‖ ≤ 1 := by nontriviality A; simp |
| have hnr : ‖b*g‖^2 ≤ r^2 := by nlinarith [mul_le_mul_of_nonneg_left h1 (sq_nonneg r)] |
| nlinarith [norm_nonneg (b*g)] |
|
|
| omit [PartialOrder A] [StarOrderedRing A] in |
| lemma realPart_compression (g b : A) (hg : IsSelfAdjoint g) : |
| (realPart (g*b*g) : A)=g*(realPart b : A)*g := by |
| rw [realPart_apply_coe,realPart_apply_coe] |
| simp only [star_mul,hg.star_eq,mul_smul_comm,smul_mul_assoc] |
| congr 1 |
| noncomm_ring |
|
|
| omit [PartialOrder A] [StarOrderedRing A] in |
| lemma realPart_compression_norm_le (g b : A) (hg : IsSelfAdjoint g) (hgn : ‖g‖ ≤ 1) : |
| ‖g*(realPart b : A)*g‖ ≤ ‖b*g‖ := by |
| rw [←realPart_compression g b hg] |
| calc |
| ‖(realPart (g*b*g) : A)‖ ≤ ‖g*b*g‖ := by simpa only [AddSubgroup.norm_coe] using realPart.norm_le (g*b*g) |
| _=‖g*(b*g)‖ := by rw [mul_assoc] |
| _ ≤ ‖g‖*‖b*g‖ := norm_mul_le _ _ |
| _ ≤ ‖b*g‖ := by nlinarith [norm_nonneg (b*g)] |
|
|
| end PureStateExcision |
|
|
|
|
| namespace PureStateExcision |
| open scoped ComplexOrder ComplexStarModule InnerProductSpace |
|
|
| variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] |
| variable {I : Type*} [Fintype I] |
|
|
| lemma state_left_norm_sq (f : A →ₚ[ℂ] ℂ) (b : A) : |
| (f (star b*b)).re=‖f.gnsStarAlgHom b (Pureness.stateGNSVector f)‖^2 := by |
| rw [←Pureness.stateGNS_vector_value f (star b*b),map_mul,map_star] |
| change (inner ℂ (Pureness.stateGNSVector f) |
| (star (f.gnsStarAlgHom b) (f.gnsStarAlgHom b (Pureness.stateGNSVector f)))).re=_ |
| rw [ContinuousLinearMap.star_eq_adjoint,ContinuousLinearMap.adjoint_inner_right] |
| exact inner_self_eq_norm_sq (𝕜 := ℂ) _ |
|
|
| omit [StarOrderedRing A] in |
| lemma state_real_smul (f : A →ₚ[ℂ] ℂ) (t : ℝ) (a : A) : |
| (f (t • a)).re=t*(f a).re := by |
| rw [←Complex.coe_smul,map_smul] |
| simp |
|
|
| lemma state_selfadjoint_real (f : A →ₚ[ℂ] ℂ) (a : A) (ha : IsSelfAdjoint a) : |
| ((f a).re : ℂ)=f a := by |
| have him := Complex.conj_eq_iff_im.mp (ha.map f).star_eq |
| apply Complex.ext |
| · rfl |
| · simpa using him.symm |
|
|
| theorem pure_state_finite_selfadjoint_excision (f : A →ₚ[ℂ] ℂ) (hf1 : f 1=1) |
| (hpure : ofPositiveState f hf1∈(realStateCarrier (A := A)).extremePoints ℝ) |
| (a : I → selfAdjoint A) {ε ρ : ℝ} (hε : 0<ε) (hρ : 0<ρ) : |
| ∃ g : A, 0 ≤ g ∧ ‖g‖ ≤ 1 ∧ 1-ρ<(f g).re ∧ |
| ∀ i, ‖g*(a i : A)*g-f (a i) • (g*g)‖<ε := by |
| classical |
| let c (i : I) : A := (a i : A)-(f (a i)).re • 1 |
| have hc (i : I) : IsSelfAdjoint (c i) := |
| (a i).property.sub ((IsSelfAdjoint.all _).smul (IsSelfAdjoint.one A)) |
| have hfc (i : I) : f (c i)=0 := by |
| simp only [c,map_sub,←Complex.coe_smul,map_smul,hf1,smul_eq_mul,mul_one] |
| rw [state_selfadjoint_real f (a i) (a i).property,sub_self] |
| let r := ε/2 |
| have hr : 0<r := by dsimp [r]; positivity |
| have hr2 : 0<r^2 := sq_pos_of_pos hr |
| let n : ℝ := Fintype.card I |
| have hn : 0 ≤ n := by dsimp [n]; positivity |
| let δ := Real.sqrt (ρ*r^2/(n+1)) |
| have hδ : 0<δ := Real.sqrt_pos.mpr (by positivity) |
| have hδsq : δ^2=ρ*r^2/(n+1) := Real.sq_sqrt (by positivity) |
| choose b hb hbn using fun i => pure_state_small_left_error f hf1 hpure (c i) (hc i) (hfc i) hδ |
| let u : A := (r^2)⁻¹ • ∑ i,star (b i)*b i |
| have hu : 0 ≤ u := smul_nonneg (inv_nonneg.mpr hr2.le) |
| (Finset.sum_nonneg fun i _ => star_mul_self_nonneg (b i)) |
| have hmass : r^2 • u=∑ i,star (b i)*b i := by |
| dsimp only [u] |
| rw [smul_smul,mul_inv_cancel₀ hr2.ne',one_smul] |
| have hbi (i : I) : star (b i)*b i ≤ r^2 • u := by |
| rw [hmass] |
| exact Finset.single_le_sum (fun j _ => star_mul_self_nonneg (b j)) (Finset.mem_univ i) |
| have hfu : (f u).re<ρ := by |
| have hs : ∑ i,(f (star (b i)*b i)).re ≤ n*δ^2 := by |
| calc |
| _ ≤ ∑ i,δ^2 := Finset.sum_le_sum fun i _ => by |
| rw [state_left_norm_sq] |
| nlinarith [hbn i,norm_nonneg (f.gnsStarAlgHom (b i) (Pureness.stateGNSVector f))] |
| _=n*δ^2 := by simp [n] |
| have hnum : (r^2)⁻¹*(n*δ^2)<ρ := by |
| rw [hδsq] |
| have hn1 : 0<n+1 := by linarith |
| field_simp |
| nlinarith |
| calc |
| (f u).re=(r^2)⁻¹*(∑ i,(f (star (b i)*b i)).re) := by |
| rw [state_real_smul] |
| simp only [map_sum,Complex.re_sum] |
| _ ≤ (r^2)⁻¹*(n*δ^2) := mul_le_mul_of_nonneg_left hs (inv_nonneg.mpr hr2.le) |
| _<ρ := hnum |
| let g := softCompression u |
| have hg := softCompression_nonneg u |
| have hgn := softCompression_norm_le u |
| refine ⟨g,hg,hgn,?_,fun i => ?_⟩ |
| · have hle : f (1-g) ≤ f u := f.monotone (softCompression_error u hu) |
| have hleR := (Complex.le_def.mp hle).1 |
| simp only [map_sub,Complex.sub_re,hf1,Complex.one_re] at hleR |
| linarith |
| · have hi : ‖g*c i*g‖ ≤ r := by |
| rw [←hb i] |
| exact (realPart_compression_norm_le g (b i) hg.isSelfAdjoint hgn).trans |
| (norm_mul_softCompression_le u (b i) hu hr.le (hbi i)) |
| have he : g*(a i : A)*g-f (a i) • (g*g)=g*c i*g := by |
| rw [←state_selfadjoint_real f (a i) (a i).property,Complex.coe_smul] |
| simp [c,mul_sub,sub_mul] |
| rw [he] |
| exact hi.trans_lt (by dsimp [r]; linarith) |
|
|
| end PureStateExcision |
|
|
| end |
|
|
| end OAI |
|
|
