Download data/lean/OAI/Analysis/CharacterCriterion/Fullness.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 11.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CharacterCriterion/Fullness.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/CharacterCriterion/Fullness.lean
-
curl -L -o Fullness.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CharacterCriterion/Fullness.lean
11.5 kB
| import OAI.Analysis.CharacterCriterion.Representations | |
| namespace OAI | |
| noncomputable section | |
| open scoped TensorProduct | |
| open scoped InnerProductSpace | |
| open scoped BigOperators | |
| open Set Module | |
| open Topology | |
| open NormedSpace | |
| open scoped ComplexOrder | |
| open scoped ComplexOrder | |
| open scoped InnerProductSpace | |
| namespace KirchbergRordam.GenericRW | |
| namespace PrimitiveSeparation | |
| variable {A : Type*} [CStarAlgebra A] [Nontrivial A] | |
| variable (I : Ideal A) [I.IsTwoSided] [IsClosed (I : Set A)] | |
| instance quotientNormedAlgebra : NormedAlgebra β (A β§Έ I) where | |
| norm_smul_le := norm_smul_le | |
| def quotientCLM : A βL[β] (A β§Έ I) := | |
| (Ideal.Quotient.mkβ β I).toLinearMap.mkContinuous 1 fun a => by | |
| change β(Submodule.Quotient.mk a : A β§Έ I)β β€ 1 * βaβ | |
| simpa only [one_mul] using Submodule.Quotient.norm_mk_le I a | |
| omit [Nontrivial A] in | |
| @[simp] lemma quotientCLM_apply (a : A) : quotientCLM I a = Ideal.Quotient.mk I a := rfl | |
| lemma quotient_norm_one (hI : I β β€) : β(1 : A β§Έ I)β = 1 := by | |
| let _ : Nontrivial (A β§Έ I) := Ideal.Quotient.nontrivial_iff.mpr hI | |
| apply le_antisymm _ (one_le_norm_one (A β§Έ I)) | |
| change β(Submodule.Quotient.mk (1 : A) : A β§Έ I)β β€ 1 | |
| simpa only [norm_one] using Submodule.Quotient.norm_mk_le I (1 : A) | |
| def stateFace : Set (WeakDual β A) := PureStates.normStates A β© {Ο | β a β I, Ο a = 0} | |
| omit [Nontrivial A] [I.IsTwoSided] [IsClosed (I : Set A)] in | |
| lemma stateFace_compact : IsCompact (stateFace I) := | |
| (PureStates.normStates_compact A).inter_right | |
| (by | |
| simp only [Set.ofPred_forall] | |
| exact isClosed_iInter fun a => isClosed_iInter fun _ => | |
| isClosed_eq (WeakDual.eval_continuous a) continuous_const) | |
| lemma stateFace_nonempty (hI : I β β€) : (stateFace I).Nonempty := by | |
| let _ : Nontrivial (A β§Έ I) := Ideal.Quotient.nontrivial_iff.mpr hI | |
| obtain β¨f, hfn, hf1β© := exists_dual_vector β (1 : A β§Έ I) (by rw [quotient_norm_one I hI]; exact one_ne_zero) | |
| have hf1 : f 1 = 1 := by simpa [quotient_norm_one I hI] using hf1 | |
| let g := f.comp (quotientCLM I) | |
| have hg : βgβ β€ 1 := by | |
| apply g.opNorm_le_bound (by norm_num) | |
| intro a | |
| have hq : βquotientCLM I aβ β€ βaβ := Submodule.Quotient.norm_mk_le I a | |
| change βf (quotientCLM I a)β β€ 1 * βaβ | |
| calc | |
| βf (quotientCLM I a)β β€ βfβ * βquotientCLM I aβ := f.le_opNorm _ | |
| _ β€ 1 * βaβ := by rw [hfn, one_mul, one_mul]; exact hq | |
| refine β¨StrongDual.toWeakDual g, β¨hg, ?_β©, ?_β© | |
| Β· change f (Ideal.Quotient.mk I 1) = 1 | |
| simpa only [map_one] using hf1 | |
| Β· intro a ha | |
| change f (Ideal.Quotient.mk I a) = 0 | |
| rw [Ideal.Quotient.eq_zero_iff_mem.mpr ha, map_zero] | |
| variable [PartialOrder A] [StarOrderedRing A] | |
| omit [I.IsTwoSided] [IsClosed (I : Set A)] in | |
| lemma stateFace_isFace (Ο Ο Ο : WeakDual β A) (hΟ : β a β I, Ο a = 0) | |
| (hΟ : Ο β PureStates.normStates A) (hΟ : Ο β PureStates.normStates A) | |
| (s t : β) (hs : 0 < s) (ht : 0 < t) (he : s β’ Ο + t β’ Ο = Ο) : | |
| (β a β I, Ο a = 0) β§ (β a β I, Ο a = 0) := by | |
| have hΟp (a : A) (ha : 0 β€ a) : 0 β€ Ο a := | |
| States.eval_nonneg Ο.toStrongDual hΟ.1 hΟ.2 a ha | |
| have hΟp (a : A) (ha : 0 β€ a) : 0 β€ Ο a := | |
| States.eval_nonneg Ο.toStrongDual hΟ.1 hΟ.2 a ha | |
| have hz (a : A) (ha : a β I) : Ο (star a * a) = 0 β§ Ο (star a * a) = 0 := by | |
| have hpa := hΟp (star a * a) (star_mul_self_nonneg a) | |
| have hca := hΟp (star a * a) (star_mul_self_nonneg a) | |
| have he' := congrArg (fun f : WeakDual β A => (f (star a * a)).re) he | |
| have hf := hΟ (star a * a) (I.mul_mem_left _ ha) | |
| change ((s β’ Ο (star a * a) + t β’ Ο (star a * a)) : β).re = (Ο (star a * a)).re at he' | |
| simp only [Complex.add_re, Complex.smul_re, smul_eq_mul] at he' | |
| rw [hf, Complex.zero_re] at he' | |
| have hp0 : (Ο (star a * a)).re = 0 := by | |
| nlinarith [(Complex.nonneg_iff.mp hpa).1, (Complex.nonneg_iff.mp hca).1] | |
| have hc0 : (Ο (star a * a)).re = 0 := by | |
| nlinarith [(Complex.nonneg_iff.mp hpa).1, (Complex.nonneg_iff.mp hca).1] | |
| constructor <;> apply Complex.ext | |
| Β· exact hp0 | |
| Β· exact (Complex.nonneg_iff.mp hpa).2.symm | |
| Β· exact hc0 | |
| Β· exact (Complex.nonneg_iff.mp hca).2.symm | |
| constructor | |
| Β· intro a ha | |
| exact Representations.positive_zero_of_square_zero | |
| (PositiveLinearMap.mkβ Ο.toStrongDual.toLinearMap hΟp) a (hz a ha).1 | |
| Β· intro a ha | |
| exact Representations.positive_zero_of_square_zero | |
| (PositiveLinearMap.mkβ Ο.toStrongDual.toLinearMap hΟp) a (hz a ha).2 | |
| theorem exists_pure_annihilating (hI : I β β€) : | |
| β Ο : A βL[β] β, PureStates.IsPure A Ο β§ β a β I, Ο a = 0 := by | |
| obtain β¨Ο, hΟβ© := (stateFace_compact I).extremePoints_nonempty (stateFace_nonempty I hI) | |
| refine β¨Ο.toStrongDual, β¨hΟ.1.1, ?_β©, hΟ.1.2β© | |
| intro Ο hΟ Ο hΟ he | |
| obtain β¨s, t, hs, ht, hst, heqβ© := he | |
| obtain β¨hΟI, hΟIβ© := stateFace_isFace I Ο Ο Ο hΟ.1.2 hΟ hΟ s t hs ht heq | |
| exact hΟ.2 β¨hΟ, hΟIβ© β¨hΟ, hΟIβ© β¨s, t, hs, ht, hst, heqβ© | |
| omit [IsClosed (I : Set A)] in | |
| lemma pureRepresentation_annihilates (Ο : A βL[β] β) (hp : PureStates.IsPure A Ο) | |
| (hΟ : β a β I, Ο a = 0) (a : A) (ha : a β I) : | |
| (Representations.pureRepresentation Ο hp).representation a = 0 := by | |
| let f := Representations.stateOfPure Ο hp | |
| have hv (b : A) : Representations.gnsVector f (a * b) = 0 := by | |
| apply (inner_self_eq_zero (π := β)).mp | |
| rw [Representations.gnsVector_inner] | |
| exact hΟ _ (I.mul_mem_left _ (I.mul_mem_right _ ha)) | |
| apply ContinuousLinearMap.ext | |
| intro x | |
| have hd := Representations.gns_cyclic f | |
| apply hd.induction_on (p := fun x => f.gnsStarAlgHom a x = 0) x | |
| Β· exact isClosed_eq ((f.gnsStarAlgHom a).continuous) continuous_const | |
| Β· intro b | |
| simp only [Representations.gnsVector_apply, mul_one] | |
| exact hv b | |
| theorem exists_irreducible_annihilating (hI : I β β€) : | |
| β Ο : IrreducibleRepresentation A, β a β I, Ο.representation a = 0 := by | |
| obtain β¨Ο, hp, hΟβ© := exists_pure_annihilating I hI | |
| exact β¨Representations.pureRepresentation Ο hp, | |
| fun a ha => pureRepresentation_annihilates I Ο hp hΟ a haβ© | |
| end PrimitiveSeparation | |
| end KirchbergRordam.GenericRW | |
| namespace KirchbergRordam.GenericRW.Fullness | |
| variable {A : Type*} [CStarAlgebra A] | |
| def closedIdeal (I : TwoSidedIdeal A) : Ideal A := I.asIdeal.topologicalClosure | |
| instance closedIdeal_twoSided (I : TwoSidedIdeal A) : (closedIdeal I).IsTwoSided where | |
| mul_mem_of_left := by | |
| intro a b ha | |
| exact (show Set.MapsTo (fun x : A => x * b) (I : Set A) (I : Set A) from | |
| fun x hx => I.mul_mem_right x b hx).closure (continuous_mul_const b) ha | |
| instance closedIdeal_isClosed (I : TwoSidedIdeal A) : IsClosed (closedIdeal I : Set A) := | |
| isClosed_closure | |
| lemma eq_top_of_closedIdeal_eq_top (I : TwoSidedIdeal A) (hI : closedIdeal I = β€) : I = β€ := by | |
| have h1 : (1 : A) β closure (I : Set A) := by | |
| change (1 : A) β closedIdeal I | |
| rw [hI] | |
| trivial | |
| obtain β¨x, hx, hnearβ© := Metric.mem_closure_iff.mp h1 1 zero_lt_one | |
| have hu : IsUnit x := by | |
| have hnorm : β1 - xβ < 1 := by simpa only [dist_eq_norm] using hnear | |
| simpa only [sub_sub_cancel] using isUnit_one_sub_of_norm_lt_one hnorm | |
| have ht := I.asIdeal.eq_top_of_isUnit_mem hx hu | |
| apply le_antisymm le_top | |
| intro x _ | |
| change x β I.asIdeal | |
| rw [ht] | |
| trivial | |
| def IsFull (a : A) : Prop := TwoSidedIdeal.span {a} = β€ | |
| lemma full_iff_closed (a : A) : IsFull a β closedIdeal (TwoSidedIdeal.span {a}) = β€ := by | |
| constructor | |
| Β· intro h | |
| apply top_unique | |
| intro x hx | |
| apply subset_closure | |
| rw [show TwoSidedIdeal.span {a} = β€ from h] | |
| trivial | |
| Β· exact eq_top_of_closedIdeal_eq_top _ | |
| lemma full_of_survives [Nontrivial A] | |
| (a : A) (h : β Ο : IrreducibleRepresentation A, Ο.representation a β 0) : IsFull a := by | |
| let := CStarAlgebra.spectralOrder A | |
| let := CStarAlgebra.spectralOrderedRing A | |
| apply (full_iff_closed a).mpr | |
| by_contra hn | |
| obtain β¨Ο, hΟβ© := PrimitiveSeparation.exists_irreducible_annihilating | |
| (closedIdeal (TwoSidedIdeal.span {a})) hn | |
| exact h Ο (hΟ a (subset_closure (TwoSidedIdeal.subset_span rfl))) | |
| lemma full_ne_zero [Nontrivial A] {a : A} (ha : IsFull a) : a β 0 := by | |
| intro he | |
| subst a | |
| have h : (1 : A) β TwoSidedIdeal.span {0} := by | |
| rw [show TwoSidedIdeal.span {(0 : A)} = β€ from ha] | |
| exact TwoSidedIdeal.mem_top A | |
| have hh : TwoSidedIdeal.span ({0} : Set A) β€ β₯ := TwoSidedIdeal.span_le.mpr (by simp) | |
| exact one_ne_zero ((TwoSidedIdeal.mem_bot _).mp (hh h)) | |
| lemma full_survives {B : Type*} [CStarAlgebra B] [Nontrivial B] | |
| {a : A} (ha : IsFull a) (Ο : A βββ[β] B) : Ο a β 0 := by | |
| intro hz | |
| have hk : TwoSidedIdeal.span {a} β€ TwoSidedIdeal.ker Ο.toRingHom := | |
| TwoSidedIdeal.span_le.mpr (Set.singleton_subset_iff.mpr ((TwoSidedIdeal.mem_ker _).mpr hz)) | |
| have h1 : (1 : A) β TwoSidedIdeal.span {a} := by | |
| rw [show TwoSidedIdeal.span {a} = β€ from ha] | |
| exact TwoSidedIdeal.mem_top A | |
| have hz1 := (TwoSidedIdeal.mem_ker _).mp (hk h1) | |
| exact one_ne_zero (by simpa only [map_one] using hz1) | |
| lemma bridges_span_one {a b : A} (ha : IsFull a) (hb : IsFull b) : | |
| TwoSidedIdeal.span (Set.range (fun d : A => a * d * b)) = β€ := by | |
| let J := TwoSidedIdeal.span (Set.range (fun d : A => a * d * b)) | |
| have hmul {x : A} (hx : x β TwoSidedIdeal.span {a}) : β d : A, x * d * b β J := by | |
| induction hx using TwoSidedIdeal.span_induction with | |
| | mem x hx => subst x; intro d; exact TwoSidedIdeal.subset_span β¨d, rflβ© | |
| | zero => intro d; simp only [zero_mul]; exact J.zero_mem | |
| | add x y hx hy ihx ihy => | |
| intro d | |
| simpa only [add_mul] using J.add_mem (ihx d) (ihy d) | |
| | neg x hx ih => | |
| intro d | |
| simpa only [neg_mul] using J.neg_mem (ih d) | |
| | left_absorb c x hx ih => | |
| intro d | |
| simpa only [mul_assoc] using J.mul_mem_left c _ (ih d) | |
| | right_absorb c x hx ih => | |
| intro d | |
| simpa only [mul_assoc] using ih (c * d) | |
| have h1 : (1 : A) β TwoSidedIdeal.span {a} := by | |
| rw [show TwoSidedIdeal.span {a} = β€ from ha] | |
| exact TwoSidedIdeal.mem_top A | |
| have hbJ : b β J := by simpa using hmul h1 1 | |
| have hk : TwoSidedIdeal.span {b} β€ J := TwoSidedIdeal.span_le.mpr (by simpa) | |
| apply top_unique | |
| rwa [hb] at hk | |
| lemma mem_span_finite {s : Set A} {x : A} (hx : x β TwoSidedIdeal.span s) : | |
| β t : Finset A, βt β s β§ x β TwoSidedIdeal.span (t : Set A) := by | |
| classical | |
| induction hx using TwoSidedIdeal.span_induction with | |
| | mem x hx => exact β¨{x}, by simpa, TwoSidedIdeal.subset_span (by simp)β© | |
| | zero => exact β¨β , by simp, TwoSidedIdeal.zero_mem _β© | |
| | add x y hx hy ihx ihy => | |
| obtain β¨t, ht, hxtβ© := ihx | |
| obtain β¨u, hu, hyuβ© := ihy | |
| refine β¨t βͺ u, ?_, TwoSidedIdeal.add_mem _ ?_ ?_β© | |
| Β· simpa using Set.union_subset ht hu | |
| Β· exact TwoSidedIdeal.span_mono (by simp) hxt | |
| Β· exact TwoSidedIdeal.span_mono (by simp) hyu | |
| | neg x hx ih => | |
| obtain β¨t, ht, hxβ© := ih | |
| exact β¨t, ht, TwoSidedIdeal.neg_mem _ hxβ© | |
| | left_absorb a x hx ih => | |
| obtain β¨t, ht, hxβ© := ih | |
| exact β¨t, ht, TwoSidedIdeal.mul_mem_left _ _ _ hxβ© | |
| | right_absorb b x hx ih => | |
| obtain β¨t, ht, hxβ© := ih | |
| exact β¨t, ht, TwoSidedIdeal.mul_mem_right _ _ _ hxβ© | |
| end KirchbergRordam.GenericRW.Fullness | |
| end | |
| end OAI | |