Download data/lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Shrinking.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Shrinking.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Shrinking.lean
-
curl -L -o Shrinking.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Shrinking.lean
12.2 kB
| import OAI.Analysis.CStarAlgebra.PureInfiniteness.Compression | |
| namespace OAI | |
| noncomputable section | |
| open Filter | |
| open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace | |
| namespace MainGap | |
| universe u v | |
| variable {A : Type u} [CStarAlgebra A] | |
| local instance shrinkingPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A | |
| local instance shrinkingStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A | |
| local instance shrinkingOperatorPartialOrder (J : Type*) [NormedAddCommGroup J] | |
| [InnerProductSpace β J] [CompleteSpace J] : | |
| PartialOrder (J βL[β] J) := CStarAlgebra.spectralOrder _ | |
| local instance shrinkingOperatorStarOrderedRing (J : Type*) [NormedAddCommGroup J] | |
| [InnerProductSpace β J] [CompleteSpace J] : | |
| StarOrderedRing (J βL[β] J) := CStarAlgebra.spectralOrderedRing _ | |
| theorem conditional_shrinking {a y c p : A} (_ha : 0 β€ a) (hy : 0 β€ y) | |
| (hp : 0 β€ p) (hpn : βpβ β€ 1) (hyn : βyβ β€ 1) (hcn : βcβ β€ 1) | |
| (hpH : p β Her a) | |
| (hsignal : β R : HilbertRep.{u,u} A, (1/2:β)<βR.hom aβ β βR.hom pβ=1) | |
| (hvan : β R : HilbertRep.{u,u} A, | |
| R.hom (y*(1-star c*(p*p)*c)*y)=0 β βR.hom yβ β€ (1/4:β)) : | |
| β (pβ qβ : A) (ΞΊ : β), 0 β€ pβ β§ βpββ β€ 1 β§ pβ β Her a β§ | |
| 0 β€ qβ β§ βqββ β€ 1 β§ qβ β Her y β§ 0 β€ ΞΊ β§ ΞΊ < 1 β§ | |
| HerCompression pβ qβ c ΞΊ β§ | |
| (β R : HilbertRep.{u,u} A, (1/2:β)<βR.hom aβ β βR.hom pββ=1) β§ | |
| (β R : HilbertRep.{u,u} A, (1/2:β)<βR.hom yβ β βR.hom qββ=1) := by | |
| obtain β¨Ξ΄,hΞ΄,hΞ΄β,hquantβ© := quantitative_nonvanishing hy hvan | |
| let d := y*(1-star c*(p*p)*c)*y | |
| have hd : 0 β€ d := (conditional_defect_bounds hp hy hpn hyn hcn).1 | |
| let q := y*cut d Ξ΄*y | |
| have hq : 0 β€ q := by | |
| simpa only [hy.isSelfAdjoint.star_eq] using star_left_conjugate_nonneg (cut_nonneg d Ξ΄) y | |
| have hqH : q β Her y := by | |
| simpa only [hy.isSelfAdjoint.star_eq] using sandwich_mem_Her y (cut d Ξ΄) | |
| have hqvan (R : HilbertRep.{u,u} A) (hz : R.hom q=0) : βR.hom yβ β€ (3/8:β) := by | |
| have hqzero : R.hom y * cut (R.hom y*(1-star (R.hom c)*(R.hom p*R.hom p)*R.hom c)*R.hom y) Ξ΄ * R.hom y=0 := by | |
| change R.hom (y*cut d Ξ΄*y)=0 at hz | |
| rw [map_mul, map_mul, map_cut_sa R.hom hd.isSelfAdjoint hΞ΄.le] at hz | |
| simpa only [d, map_mul, map_sub, map_one, map_star] using hz | |
| have hb := conditional_q_zero (map_nonneg R.hom hp) (map_nonneg R.hom hy) | |
| ((NonUnitalStarAlgHom.norm_apply_le R.hom p).trans hpn) | |
| ((NonUnitalStarAlgHom.norm_apply_le R.hom y).trans hyn) | |
| ((NonUnitalStarAlgHom.norm_apply_le R.hom c).trans hcn) hΞ΄ hqzero | |
| have hb' : βR.hom dβ β€ Ξ΄ := by | |
| simpa only [d, map_mul, map_sub, map_one, map_star] using hb | |
| by_contra! hRy | |
| exact (not_lt_of_ge hb') (hquant R hRy) | |
| obtain β¨Ξ΄',hΞ΄',hΞ΄'β,hquant'β© := quantitative_nonvanishing_general hy | |
| (by norm_num : (0:β)β€3/8) (by norm_num : (3/8:β)<1/2) hqvan | |
| let r := Real.sqrt (1-Ξ΄) | |
| have hr : 0 β€ r := Real.sqrt_nonneg _ | |
| have hrβ : r < 1 := by | |
| apply (Real.sqrt_lt' (by norm_num : (0:β)<1)).mpr | |
| linarith | |
| let Ο := (r+1)/2 | |
| have hΟ : 0 < Ο := by dsimp [Ο]; linarith | |
| have hrΟ : r < Ο := by dsimp [Ο]; linarith | |
| have hΟβ : Ο < 1 := by dsimp [Ο]; linarith | |
| let pβ := ramp p Ο 1 | |
| let qβ := ramp q (Ξ΄'/2) Ξ΄' | |
| have hpβ : 0 β€ pβ := ramp_nonneg p hΟβ.le | |
| have hqβ : 0 β€ qβ := ramp_nonneg q (by linarith) | |
| have hqβH : qβ β Her q := | |
| Her_mono_of_mem (cut_mem_Her hq (Ξ΄'/2)) (ramp_mem_Her_cut hq (by positivity)) | |
| refine β¨pβ,qβ,r/Ο,hpβ,norm_ramp_le_one p hΟβ.le,?_,hqβ, | |
| norm_ramp_le_one q (by linarith),Her_mono_of_mem hqH hqβH, | |
| div_nonneg hr hΟ.le,(div_lt_one hΟ).mpr hrΟ,?_,?_,?_β© | |
| Β· exact Her_mono_of_mem hpH (Her_mono_of_mem (cut_mem_Her hp Ο) (ramp_mem_Her_cut hp hΟ.le)) | |
| Β· have hcomp := compression_of_conditional_loss hp hΟ hr (conditional_Her_loss hp hy hpn hyn hcn hΞ΄.le hΞ΄β.le) | |
| intro x hx k hk | |
| exact hcomp x hx k (Her_mono_of_mem hqβH hk) | |
| Β· intro R hRa | |
| change βR.hom (ramp p Ο 1)β=1 | |
| rw [map_ramp_sa R.hom hp.isSelfAdjoint hΟ.le] | |
| exact norm_ramp_eq_one (map_nonneg R.hom hp) hΟ.le hΟβ (by rw [hsignal R hRa]) | |
| Β· intro R hRy | |
| change βR.hom (ramp q (Ξ΄'/2) Ξ΄')β=1 | |
| rw [map_ramp_sa R.hom hq.isSelfAdjoint (by positivity)] | |
| exact norm_ramp_eq_one (map_nonneg R.hom hq) (by positivity) (by linarith) (hquant' R hRy).le | |
| theorem shrinking_unital_local {a y c : A} (ha : 0 β€ a) (hy : 0 β€ y) | |
| (hyn : βyβ β€ 1) (hcn : βcβ β€ 1) | |
| (hp : β z : A, 0 β€ z β z β Her a β ProperlyInfinite z) : | |
| β (p q : A) (ΞΊ : β), 0 β€ p β§ βpβ β€ 1 β§ p β Her a β§ | |
| 0 β€ q β§ βqβ β€ 1 β§ q β Her y β§ 0 β€ ΞΊ β§ ΞΊ < 1 β§ | |
| HerCompression p q c ΞΊ β§ | |
| (β R : HilbertRep.{u,u} A, (1/2:β)<βR.hom aβ β βR.hom pβ=1) β§ | |
| (β R : HilbertRep.{u,u} A, (1/2:β)<βR.hom yβ β βR.hom qβ=1) := by | |
| obtain β¨p,hpp,hpn,hpH,hsignal,hvanβ© := graph_nonvanishing.{u,u} ha hy hcn hp | |
| exact conditional_shrinking ha hy hpp hpn hyn hcn hpH hsignal hvan | |
| end MainGap | |
| namespace MainGap | |
| variable {A B : Type*} [NonUnitalCStarAlgebra A] [NonUnitalCStarAlgebra B] | |
| def matrixMap (Ο : A ββββ[β] B) {m n : β} (x : CStarMatrix (Fin m) (Fin n) A) : | |
| CStarMatrix (Fin m) (Fin n) B := CStarMatrix.ofMatrix (fun i j => Ο (x i j)) | |
| lemma matrixMap_mul (Ο : A ββββ[β] B) {l m n : β} | |
| (x : CStarMatrix (Fin l) (Fin m) A) (y : CStarMatrix (Fin m) (Fin n) A) : | |
| matrixMap Ο (x*y)=matrixMap Ο x * matrixMap Ο y := by | |
| ext i j | |
| change Ο (β k, x i k * y k j) = β k, Ο (x i k) * Ο (y k j) | |
| simp only [map_sum, map_mul] | |
| lemma matrixMap_star (Ο : A ββββ[β] B) {m n : β} | |
| (x : CStarMatrix (Fin m) (Fin n) A) : | |
| matrixMap Ο x.conjTranspose=(matrixMap Ο x).conjTranspose := by | |
| ext i j | |
| change Ο (star (x j i)) = star (Ο (x j i)) | |
| exact map_star Ο _ | |
| lemma continuous_matrixMap (Ο : A ββββ[β] B) {m n : β} : | |
| Continuous (matrixMap Ο : CStarMatrix (Fin m) (Fin n) A β CStarMatrix (Fin m) (Fin n) B) := by | |
| apply continuous_pi | |
| intro i | |
| apply continuous_pi | |
| intro j | |
| exact (map_continuous Ο).comp ((continuous_apply j).comp (continuous_apply i)) | |
| lemma FiniteCuntzLE.map (Ο : A ββββ[β] B) {m n : β} | |
| {d : CStarMatrix (Fin n) (Fin n) A} {v : CStarMatrix (Fin m) (Fin m) A} | |
| (h : FiniteCuntzLE d v) : FiniteCuntzLE (matrixMap Ο d) (matrixMap Ο v) := by | |
| obtain β¨r,htβ© := h | |
| refine β¨fun j => matrixMap Ο (r j), ?_β© | |
| have he := (continuous_matrixMap Ο).continuousAt.tendsto.comp ht | |
| change Tendsto (fun j => matrixMap Ο ((r j).conjTranspose * v * r j)) atTop (π (matrixMap Ο d)) at he | |
| simpa only [matrixMap_mul, matrixMap_star] using he | |
| lemma ProperlyInfinite.map (Ο : A ββββ[β] B) {h : A} (hh : ProperlyInfinite h) : | |
| ProperlyInfinite (Ο h) := by | |
| have he := FiniteCuntzLE.map Ο hh | |
| have hdouble : matrixMap Ο (doubleCorner h)=doubleCorner (Ο h) := by | |
| ext i j | |
| change Ο (if i=j then h else 0) = if i=j then Ο h else 0 | |
| split_ifs <;> simp | |
| have hsingle : matrixMap Ο (scalarCorner h)=scalarCorner (Ο h) := rfl | |
| change FiniteCuntzLE _ _ | |
| rwa [hdouble, hsingle] at he | |
| end MainGap | |
| namespace MainGap | |
| variable {A : Type*} [NonUnitalCStarAlgebra A] | |
| local instance shrinkingHerPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A | |
| local instance shrinkingHerStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A | |
| local instance shrinkingHerUnitizationPartialOrder : PartialOrder (Unitization β A) := | |
| CStarAlgebra.spectralOrder _ | |
| local instance shrinkingHerUnitizationStarOrderedRing : StarOrderedRing (Unitization β A) := | |
| CStarAlgebra.spectralOrderedRing _ | |
| lemma unitization_Her {a : A} {z : Unitization β A} | |
| (hz : z β Her (a : Unitization β A)) : z.fst=0 β§ z.snd β Her a := by | |
| have hc : IsClosed {z : Unitization β A | z.fst=0 β§ z.snd β Her a} := | |
| (isClosed_eq Unitization.continuous_fst continuous_const).inter | |
| ((isClosed_Her a).preimage Unitization.continuous_snd) | |
| apply closure_minimal (s := Set.range (fun b : Unitization β A => | |
| (a : Unitization β A)*b*star (a : Unitization β A))) _ hc hz | |
| rintro z β¨b,rflβ© | |
| constructor | |
| Β· simp | |
| Β· change ((a : Unitization β A)*b*star (a : Unitization β A)).snd β Her a | |
| have he : ((a : Unitization β A)*b*star (a : Unitization β A)).snd = | |
| b.fst β’ (a*star a) + a*b.snd*star a := by | |
| simp [Unitization.snd_mul, Unitization.fst_mul, add_mul, smul_mul_assoc] | |
| rw [he] | |
| exact (Her a).add_mem ((Her a).smul_mem b.fst (mul_star_mem_Her a)) (sandwich_mem_Her a b.snd) | |
| lemma unitization_inr_snd_of_Her {a : A} {z : Unitization β A} | |
| (hz : z β Her (a : Unitization β A)) : (z.snd : Unitization β A)=z := by | |
| have he := Unitization.inl_fst_add_inr_snd_eq z | |
| simpa only [(unitization_Her hz).1, Unitization.inl_zero, zero_add] using he | |
| lemma unitization_proper_hereditary (hp : PropertyP A) {a : A} | |
| {z : Unitization β A} (hz : 0 β€ z) (hzH : z β Her (a : Unitization β A)) : | |
| ProperlyInfinite z := by | |
| have he := unitization_inr_snd_of_Her hzH | |
| have hz' : 0 β€ z.snd := Unitization.inr_nonneg_iff.mp (he.symm βΈ hz) | |
| have hh := (hp z.snd hz').map (Unitization.inrNonUnitalStarAlgHom β A) | |
| change ProperlyInfinite (z.snd : Unitization β A) at hh | |
| rwa [he] at hh | |
| end MainGap | |
| namespace MainGap | |
| universe u | |
| variable {A : Type u} [NonUnitalCStarAlgebra A] | |
| local instance shrinkingNonunitalPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A | |
| local instance shrinkingNonunitalStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A | |
| local instance shrinkingNonunitalUnitizationPartialOrder : PartialOrder (Unitization β A) := | |
| CStarAlgebra.spectralOrder _ | |
| local instance shrinkingNonunitalUnitizationStarOrderedRing : StarOrderedRing (Unitization β A) := | |
| CStarAlgebra.spectralOrderedRing _ | |
| def NormSignal (a p : A) : Prop := | |
| β R : HilbertRep.{u,u} (Unitization β A), (1/2:β)<βR.hom (a : Unitization β A)β β | |
| βR.hom (p : Unitization β A)β=1 | |
| theorem shrinking_nonunital (hp : PropertyP A) {a y c : A} (ha : 0 β€ a) (hy : 0 β€ y) | |
| (hyn : βyβ β€ 1) (hcn : βcβ β€ 1) : | |
| β (p q : A) (ΞΊ : β), 0 β€ p β§ βpβ β€ 1 β§ p β Her a β§ | |
| 0 β€ q β§ βqβ β€ 1 β§ q β Her y β§ 0 β€ ΞΊ β§ ΞΊ < 1 β§ | |
| HerCompression p q c ΞΊ β§ NormSignal a p β§ NormSignal y q := by | |
| obtain β¨p,q,ΞΊ,hp0,hpn,hpH,hq0,hqn,hqH,hΞΊ0,hΞΊ1,hcomp,hps,hqsβ© := | |
| shrinking_unital_local (Unitization.inr_nonneg_iff.mpr ha) | |
| (Unitization.inr_nonneg_iff.mpr hy) | |
| (by simpa only [Unitization.norm_inr] using hyn : β(y : Unitization β A)β β€ 1) | |
| (by simpa only [Unitization.norm_inr] using hcn : β(c : Unitization β A)β β€ 1) | |
| (fun z hz hzH => unitization_proper_hereditary hp hz hzH) | |
| have hep := unitization_inr_snd_of_Her hpH | |
| have heq := unitization_inr_snd_of_Her hqH | |
| refine β¨p.snd,q.snd,ΞΊ,Unitization.inr_nonneg_iff.mp (hep.symm βΈ hp0),?_, | |
| (unitization_Her hpH).2,Unitization.inr_nonneg_iff.mp (heq.symm βΈ hq0),?_, | |
| (unitization_Her hqH).2,hΞΊ0,hΞΊ1,?_,?_,?_β© | |
| Β· have hn : βp.sndβ=βpβ := by simpa only [Unitization.norm_inr] using congrArg norm hep | |
| rwa [hn] | |
| Β· have hn : βq.sndβ=βqβ := by simpa only [Unitization.norm_inr] using congrArg norm heq | |
| rwa [hn] | |
| Β· intro x hx k hk | |
| have hx' := Her_map (Unitization.inrNonUnitalStarAlgHom β A) hx | |
| have hk' := Her_map (Unitization.inrNonUnitalStarAlgHom β A) hk | |
| change (x : Unitization β A) β Her (p.snd : Unitization β A) at hx' | |
| change (k : Unitization β A) β Her (q.snd : Unitization β A) at hk' | |
| rw [hep] at hx' | |
| rw [heq] at hk' | |
| have hb := hcomp _ hx' _ hk' | |
| simpa only [β Unitization.inr_mul, Unitization.norm_inr] using hb | |
| Β· intro R hRa | |
| rw [hep] | |
| exact hps R hRa | |
| Β· intro R hRy | |
| rw [heq] | |
| exact hqs R hRy | |
| end MainGap | |
| end | |
| end OAI | |