fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
idealOf_compl_singleton_isMaximal (x : X) : (idealOfSet 𝕜 ({x}ᶜ : Set X)).IsMaximal :=
(idealOfSet_isMaximal_iff 𝕜 (Closeds.singleton x).compl).mpr <| Opens.isCoatom_iff.mpr ⟨x, rfl⟩
variable {𝕜} | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.UrysohnsLemma",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Analysis.Normed.Ring.Units",
"Mathlib.Topology.Algebra.Module.CharacterSpace"
] | Mathlib/Topology/ContinuousMap/Ideals.lean | idealOf_compl_singleton_isMaximal | null |
setOfIdeal_eq_compl_singleton (I : Ideal C(X, 𝕜)) [hI : I.IsMaximal] :
∃ x : X, setOfIdeal I = {x}ᶜ := by
have h : (idealOfSet 𝕜 (setOfIdeal I)).IsMaximal :=
(idealOfSet_ofIdeal_isClosed (inferInstance : IsClosed (I : Set C(X, 𝕜)))).symm ▸ hI
obtain ⟨x, hx⟩ := Opens.isCoatom_iff.1 ((idealOfSet_isMaximal_iff 𝕜 (opensOfIdeal I)).1 h)
exact ⟨x, congr_arg (fun (s : Opens X) => (s : Set X)) hx⟩ | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.UrysohnsLemma",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Analysis.Normed.Ring.Units",
"Mathlib.Topology.Algebra.Module.CharacterSpace"
] | Mathlib/Topology/ContinuousMap/Ideals.lean | setOfIdeal_eq_compl_singleton | null |
ideal_isMaximal_iff (I : Ideal C(X, 𝕜)) [hI : IsClosed (I : Set C(X, 𝕜))] :
I.IsMaximal ↔ ∃ x : X, idealOfSet 𝕜 {x}ᶜ = I := by
refine
⟨?_, fun h =>
let ⟨x, hx⟩ := h
hx ▸ idealOf_compl_singleton_isMaximal 𝕜 x⟩
intro hI'
obtain ⟨x, hx⟩ := setOfIdeal_eq_compl_singleton I
exact
⟨x, by
simpa only [idealOfSet_ofIdeal_eq_closure, I.closure_eq_of_isClosed hI] using
congr_arg (idealOfSet 𝕜) hx.symm⟩ | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.UrysohnsLemma",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Analysis.Normed.Ring.Units",
"Mathlib.Topology.Algebra.Module.CharacterSpace"
] | Mathlib/Topology/ContinuousMap/Ideals.lean | ideal_isMaximal_iff | null |
continuousMapEval : C(X, characterSpace 𝕜 C(X, 𝕜)) where
toFun x :=
⟨{ toFun := fun f => f x
map_add' := fun _ _ => rfl
map_smul' := fun _ _ => rfl
cont := continuous_eval_const x }, by
rw [CharacterSpace.eq_set_map_one_map_mul]; exact ⟨rfl, fun f g => rfl⟩⟩
continuous_toFun := by
exact Continuous.subtype_mk (continuous_of_continuous_eval map_continuous) _
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.UrysohnsLemma",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Analysis.Normed.Ring.Units",
"Mathlib.Topology.Algebra.Module.CharacterSpace"
] | Mathlib/Topology/ContinuousMap/Ideals.lean | continuousMapEval | The natural continuous map from a locally compact topological space `X` to the
`WeakDual.characterSpace 𝕜 C(X, 𝕜)` which sends `x : X` to point evaluation at `x`. |
continuousMapEval_apply_apply (x : X) (f : C(X, 𝕜)) : continuousMapEval X 𝕜 x f = f x :=
rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.UrysohnsLemma",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Analysis.Normed.Ring.Units",
"Mathlib.Topology.Algebra.Module.CharacterSpace"
] | Mathlib/Topology/ContinuousMap/Ideals.lean | continuousMapEval_apply_apply | null |
continuousMapEval_bijective : Bijective (continuousMapEval X 𝕜) := by
refine ⟨fun x y hxy => ?_, fun φ => ?_⟩
· contrapose! hxy
rcases exists_continuous_zero_one_of_isClosed (isClosed_singleton : _root_.IsClosed {x})
(isClosed_singleton : _root_.IsClosed {y}) (Set.disjoint_singleton.mpr hxy) with
⟨f, fx, fy, -⟩
rw [DFunLike.ne_iff]
use (⟨fun (x : ℝ) => (x : 𝕜), RCLike.continuous_ofReal⟩ : C(ℝ, 𝕜)).comp f
simpa only [continuousMapEval_apply_apply, ContinuousMap.comp_apply, coe_mk, Ne,
RCLike.ofReal_inj] using
((fx (Set.mem_singleton x)).symm ▸ (fy (Set.mem_singleton y)).symm ▸ zero_ne_one : f x ≠ f y)
· obtain ⟨x, hx⟩ := (ideal_isMaximal_iff (RingHom.ker φ)).mp inferInstance
refine ⟨x, CharacterSpace.ext_ker <| Ideal.ext fun f => ?_⟩
simpa only [RingHom.mem_ker, continuousMapEval_apply_apply, mem_idealOfSet_compl_singleton,
RingHom.mem_ker] using SetLike.ext_iff.mp hx f | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.UrysohnsLemma",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Analysis.Normed.Ring.Units",
"Mathlib.Topology.Algebra.Module.CharacterSpace"
] | Mathlib/Topology/ContinuousMap/Ideals.lean | continuousMapEval_bijective | null |
noncomputable homeoEval : X ≃ₜ characterSpace 𝕜 C(X, 𝕜) :=
@Continuous.homeoOfEquivCompactToT2 _ _ _ _ _ _
{ Equiv.ofBijective _ (continuousMapEval_bijective X 𝕜) with toFun := continuousMapEval X 𝕜 }
(map_continuous (continuousMapEval X 𝕜)) | def | Topology | [
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.ContinuousMap.Compact",
"Mathlib.Topology.UrysohnsLemma",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Analysis.Normed.Ring.Units",
"Mathlib.Topology.Algebra.Module.CharacterSpace"
] | Mathlib/Topology/ContinuousMap/Ideals.lean | homeoEval | This is the natural homeomorphism between a compact Hausdorff space `X` and the
`WeakDual.characterSpace 𝕜 C(X, 𝕜)`. |
IccInclusionLeft : C(Icc a b, Icc a c) :=
.inclusion <| Icc_subset_Icc le_rfl Fact.out | def | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | IccInclusionLeft | The embedding into an interval from a sub-interval lying on the left, as a `ContinuousMap`. |
IccInclusionRight : C(Icc b c, Icc a c) :=
.inclusion <| Icc_subset_Icc Fact.out le_rfl | def | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | IccInclusionRight | The embedding into an interval from a sub-interval lying on the right, as a `ContinuousMap`. |
projIccCM : C(α, Icc a b) :=
⟨projIcc a b Fact.out, continuous_projIcc⟩ | def | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | projIccCM | The map `projIcc` from `α` onto an interval in `α`, as a `ContinuousMap`. |
IccExtendCM : C(C(Icc a b, E), C(α, E)) where
toFun f := f.comp projIccCM
continuous_toFun := continuous_precomp projIccCM
@[simp] | def | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | IccExtendCM | The extension operation from continuous maps on an interval to continuous maps on the whole
type, as a `ContinuousMap`. |
IccExtendCM_of_mem {f : C(Icc a b, E)} {x : α} (hx : x ∈ Icc a b) :
IccExtendCM f x = f ⟨x, hx⟩ := by
simp [IccExtendCM, projIccCM, projIcc, hx.1, hx.2] | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | IccExtendCM_of_mem | null |
noncomputable concat (f : C(Icc a b, E)) (g : C(Icc b c, E)) :
C(Icc a c, E) := by
by_cases hb : f ⊤ = g ⊥
· let h (t : α) : E := if t ≤ b then IccExtendCM f t else IccExtendCM g t
suffices Continuous h from ⟨fun t => h t, by fun_prop⟩
apply Continuous.if_le (by fun_prop) (by fun_prop) continuous_id continuous_const
rintro x rfl
simpa [IccExtendCM, projIccCM]
· exact .const _ (f ⊥) -- junk value
variable {f : C(Icc a b, E)} {g : C(Icc b c, E)} | def | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | concat | The concatenation of two continuous maps defined on adjacent intervals. If the values of the
functions on the common bound do not agree, this is defined as an arbitrarily chosen constant
map. See `concatCM` for the corresponding map on the subtype of compatible function pairs. |
concat_comp_IccInclusionLeft (hb : f ⊤ = g ⊥) :
(concat f g).comp IccInclusionLeft = f := by
ext x
simp [concat, IccExtendCM, hb, IccInclusionLeft, projIccCM, inclusion, x.2.2] | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | concat_comp_IccInclusionLeft | null |
concat_comp_IccInclusionRight (hb : f ⊤ = g ⊥) :
(concat f g).comp IccInclusionRight = g := by
ext ⟨x, hx⟩
obtain rfl | hxb := eq_or_ne x b
· simpa [concat, IccInclusionRight, IccExtendCM, projIccCM, inclusion, hb]
· have h : ¬ x ≤ b := lt_of_le_of_ne hx.1 (Ne.symm hxb) |>.not_ge
simp [concat, hb, IccInclusionRight, h, IccExtendCM, projIccCM, projIcc, inclusion, hx.2, hx.1]
@[simp] | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | concat_comp_IccInclusionRight | null |
concat_left (hb : f ⊤ = g ⊥) {t : Icc a c} (ht : t ≤ b) :
concat f g t = f ⟨t, t.2.1, ht⟩ := by
nth_rewrite 2 [← concat_comp_IccInclusionLeft hb]
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | concat_left | null |
concat_right (hb : f ⊤ = g ⊥) {t : Icc a c} (ht : b ≤ t) :
concat f g t = g ⟨t, ht, t.2.2⟩ := by
nth_rewrite 2 [← concat_comp_IccInclusionRight hb]
rfl | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | concat_right | null |
tendsto_concat {ι : Type*} {p : Filter ι} {F : ι → C(Icc a b, E)} {G : ι → C(Icc b c, E)}
(hfg : ∀ᶠ i in p, (F i) ⊤ = (G i) ⊥) (hfg' : f ⊤ = g ⊥)
(hf : Tendsto F p (𝓝 f)) (hg : Tendsto G p (𝓝 g)) :
Tendsto (fun i => concat (F i) (G i)) p (𝓝 (concat f g)) := by
rw [tendsto_nhds_compactOpen] at hf hg ⊢
rintro K hK U hU hfgU
have h : b ∈ Icc a c := ⟨Fact.out, Fact.out⟩
let K₁ : Set (Icc a b) := projIccCM '' (Subtype.val '' (K ∩ Iic ⟨b, h⟩))
let K₂ : Set (Icc b c) := projIccCM '' (Subtype.val '' (K ∩ Ici ⟨b, h⟩))
have hK₁ : IsCompact K₁ :=
hK.inter_right isClosed_Iic |>.image continuous_subtype_val |>.image projIccCM.continuous
have hK₂ : IsCompact K₂ :=
hK.inter_right isClosed_Ici |>.image continuous_subtype_val |>.image projIccCM.continuous
have hfU : MapsTo f K₁ U := by
rw [← concat_comp_IccInclusionLeft hfg']
apply hfgU.comp
rintro x ⟨y, ⟨⟨z, hz⟩, ⟨h1, (h2 : z ≤ b)⟩, rfl⟩, rfl⟩
simpa [projIccCM, projIcc, h2, hz.1] using h1
have hgU : MapsTo g K₂ U := by
rw [← concat_comp_IccInclusionRight hfg']
apply hfgU.comp
rintro x ⟨y, ⟨⟨z, hz⟩, ⟨h1, (h2 : b ≤ z)⟩, rfl⟩, rfl⟩
simpa [projIccCM, projIcc, h2, hz.2] using h1
filter_upwards [hf K₁ hK₁ U hU hfU, hg K₂ hK₂ U hU hgU, hfg] with i hf hg hfg x hx
by_cases hxb : x ≤ b
· rw [concat_left hfg hxb]
refine hf ⟨x, ⟨x, ⟨hx, hxb⟩, rfl⟩, ?_⟩
simp [projIccCM, projIcc, hxb, x.2.1]
· replace hxb : b ≤ x := lt_of_not_ge hxb |>.le
rw [concat_right hfg hxb]
refine hg ⟨x, ⟨x, ⟨hx, hxb⟩, rfl⟩, ?_⟩
simp [projIccCM, projIcc, hxb, x.2.2] | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | tendsto_concat | null |
noncomputable concatCM :
C({fg : C(Icc a b, E) × C(Icc b c, E) // fg.1 ⊤ = fg.2 ⊥}, C(Icc a c, E)) where
toFun fg := concat fg.val.1 fg.val.2
continuous_toFun := by
let S : Set (C(Icc a b, E) × C(Icc b c, E)) := {fg | fg.1 ⊤ = fg.2 ⊥}
change Continuous (S.restrict concat.uncurry)
refine continuousOn_iff_continuous_restrict.mp (fun fg hfg => ?_)
refine tendsto_concat ?_ hfg ?_ ?_
· exact eventually_nhdsWithin_of_forall (fun _ => id)
· exact tendsto_nhdsWithin_of_tendsto_nhds continuousAt_fst
· exact tendsto_nhdsWithin_of_tendsto_nhds continuousAt_snd
@[simp] | def | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | concatCM | The concatenation of compatible pairs of continuous maps on adjacent intervals, defined as a
`ContinuousMap` on a subtype of the product. |
concatCM_left {x : Icc a c} (hx : x ≤ b)
{fg : {fg : C(Icc a b, E) × C(Icc b c, E) // fg.1 ⊤ = fg.2 ⊥}} :
concatCM fg x = fg.1.1 ⟨x.1, x.2.1, hx⟩ := by
exact concat_left fg.2 hx
@[simp] | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | concatCM_left | null |
concatCM_right {x : Icc a c} (hx : b ≤ x)
{fg : {fg : C(Icc a b, E) × C(Icc b c, E) // fg.1 ⊤ = fg.2 ⊥}} :
concatCM fg x = fg.1.2 ⟨x.1, hx, x.2.2⟩ :=
concat_right fg.2 hx | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Order.ProjIcc"
] | Mathlib/Topology/ContinuousMap/Interval.lean | concatCM_right | null |
@[to_additive (attr := simp, norm_cast)]
coe_mabs (f : C(α, β)) : ⇑|f|ₘ = |⇑f|ₘ := rfl
@[to_additive (attr := simp)] | lemma | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.Order.Group.Lattice",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.ContinuousMap.Ordered"
] | Mathlib/Topology/ContinuousMap/Lattice.lean | coe_mabs | null |
mabs_apply (f : C(α, β)) (x : α) : |f|ₘ x = |f x|ₘ := rfl | lemma | Topology | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Algebra.Order.Group.Lattice",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.ContinuousMap.Ordered"
] | Mathlib/Topology/ContinuousMap/Lattice.lean | mabs_apply | null |
@[to_additive (attr := simps) /-- The inclusion of locally-constant functions into continuous
functions as an additive monoid hom. -/]
toContinuousMapMonoidHom [Monoid Y] [ContinuousMul Y] : LocallyConstant X Y →* C(X, Y) where
toFun := (↑)
map_one' := by
ext
simp
map_mul' x y := by
ext
simp | def | Topology | [
"Mathlib.Topology.LocallyConstant.Algebra",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/LocallyConstant.lean | toContinuousMapMonoidHom | The inclusion of locally-constant functions into continuous functions as a multiplicative
monoid hom. |
@[simps]
toContinuousMapLinearMap (R : Type*) [Semiring R] [AddCommMonoid Y] [Module R Y]
[ContinuousAdd Y] [ContinuousConstSMul R Y] : LocallyConstant X Y →ₗ[R] C(X, Y) where
toFun := (↑)
map_add' x y := by
ext
simp
map_smul' x y := by
ext
simp | def | Topology | [
"Mathlib.Topology.LocallyConstant.Algebra",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/LocallyConstant.lean | toContinuousMapLinearMap | The inclusion of locally-constant functions into continuous functions as a linear map. |
@[simps]
toContinuousMapAlgHom (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y]
[IsTopologicalSemiring Y] : LocallyConstant X Y →ₐ[R] C(X, Y) where
toFun := (↑)
map_one' := by
ext
simp
map_mul' x y := by
ext
simp
map_zero' := by
ext
simp
map_add' x y := by
ext
simp
commutes' r := by
ext x
simp [Algebra.smul_def] | def | Topology | [
"Mathlib.Topology.LocallyConstant.Algebra",
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/LocallyConstant.lean | toContinuousMapAlgHom | The inclusion of locally-constant functions into continuous functions as an algebra map. |
ContinuousMap.instLocallyConvexSpace {X 𝕜 E : Type*}
[TopologicalSpace X]
[Semiring 𝕜] [PartialOrder 𝕜]
[AddCommGroup E] [Module 𝕜 E] [TopologicalSpace E] [LocallyConvexSpace 𝕜 E]
[IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E] :
LocallyConvexSpace 𝕜 C(X, E) :=
.ofBasisZero _ _ _ _ (LocallyConvexSpace.convex_basis_zero 𝕜 E).nhds_continuousMapConst <| by
rintro ⟨K, U⟩ ⟨hK, hU₀, hUc⟩ f hf g hg a b ha hb hab x hx
exact hUc (hf hx) (hg hx) ha hb hab | instance | Topology | [
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Algebra.Module.LocallyConvex"
] | Mathlib/Topology/ContinuousMap/LocallyConvex.lean | ContinuousMap.instLocallyConvexSpace | null |
partialOrder [PartialOrder β] : PartialOrder C(α, β) :=
PartialOrder.lift (fun f => f.toFun) (fun f g _ => by aesop) | instance | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | partialOrder | null |
le_def [PartialOrder β] {f g : C(α, β)} : f ≤ g ↔ ∀ a, f a ≤ g a :=
Pi.le_def | theorem | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | le_def | null |
lt_def [PartialOrder β] {f g : C(α, β)} : f < g ↔ (∀ a, f a ≤ g a) ∧ ∃ a, f a < g a :=
Pi.lt_def | theorem | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | lt_def | null |
sup : Max C(α, β) where max f g := { toFun := fun a ↦ f a ⊔ g a }
@[simp, norm_cast] lemma coe_sup (f g : C(α, β)) : ⇑(f ⊔ g) = ⇑f ⊔ g := rfl
@[simp] lemma sup_apply (f g : C(α, β)) (a : α) : (f ⊔ g) a = f a ⊔ g a := rfl | instance | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | sup | null |
semilatticeSup : SemilatticeSup C(α, β) :=
DFunLike.coe_injective.semilatticeSup _ fun _ _ ↦ rfl | instance | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | semilatticeSup | null |
sup'_apply {ι : Type*} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β)) (a : α) :
s.sup' H f a = s.sup' H fun i ↦ f i a :=
Finset.comp_sup'_eq_sup'_comp H (fun g : C(α, β) ↦ g a) fun _ _ ↦ rfl
@[simp, norm_cast] | lemma | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | sup'_apply | null |
coe_sup' {ι : Type*} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β)) :
⇑(s.sup' H f) = s.sup' H fun i ↦ ⇑(f i) := by ext; simp [sup'_apply] | lemma | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | coe_sup' | null |
inf : Min C(α, β) where min f g := { toFun := fun a ↦ f a ⊓ g a }
@[simp, norm_cast] lemma coe_inf (f g : C(α, β)) : ⇑(f ⊓ g) = ⇑f ⊓ g := rfl
@[simp] lemma inf_apply (f g : C(α, β)) (a : α) : (f ⊓ g) a = f a ⊓ g a := rfl | instance | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | inf | null |
semilatticeInf : SemilatticeInf C(α, β) :=
DFunLike.coe_injective.semilatticeInf _ fun _ _ ↦ rfl | instance | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | semilatticeInf | null |
inf'_apply {ι : Type*} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β)) (a : α) :
s.inf' H f a = s.inf' H fun i ↦ f i a :=
Finset.comp_inf'_eq_inf'_comp H (fun g : C(α, β) ↦ g a) fun _ _ ↦ rfl
@[simp, norm_cast] | lemma | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | inf'_apply | null |
coe_inf' {ι : Type*} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β)) :
⇑(s.inf' H f) = s.inf' H fun i ↦ ⇑(f i) := by ext; simp [inf'_apply] | lemma | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | coe_inf' | null |
IccExtend (f : C(Set.Icc a b, β)) : C(α, β) where
toFun := Set.IccExtend h f
@[simp] | def | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | IccExtend | Extend a continuous function `f : C(Set.Icc a b, β)` to a function `f : C(α, β)`. |
coe_IccExtend (f : C(Set.Icc a b, β)) :
((IccExtend h f : C(α, β)) : α → β) = Set.IccExtend h f :=
rfl | theorem | Topology | [
"Mathlib.Topology.Order.Lattice",
"Mathlib.Topology.Order.ProjIcc",
"Mathlib.Topology.ContinuousMap.Defs"
] | Mathlib/Topology/ContinuousMap/Ordered.lean | coe_IccExtend | null |
periodic_tsum_comp_add_zsmul [AddCommGroup X] [ContinuousAdd X] [AddCommMonoid Y]
[ContinuousAdd Y] [T2Space Y] (f : C(X, Y)) (p : X) :
Function.Periodic (⇑(∑' n : ℤ, f.comp (ContinuousMap.addRight (n • p)))) p := by
intro x
by_cases h : Summable fun n : ℤ => f.comp (ContinuousMap.addRight (n • p))
· convert congr_arg (fun f : C(X, Y) => f x) ((Equiv.addRight (1 : ℤ)).tsum_eq _) using 1
have : Summable fun (c : ℤ) => f.comp (ContinuousMap.addRight (Equiv.addRight 1 c • p)) :=
(Equiv.addRight (1 : ℤ)).summable_iff.mpr h
simp_rw [← tsum_apply h, ← tsum_apply this]
simp [Equiv.coe_addRight, comp_apply, add_one_zsmul, add_comm (_ • p) p, ← add_assoc]
· rw [tsum_eq_zero_of_not_summable h]
simp only [coe_zero, Pi.zero_apply] | theorem | Topology | [
"Mathlib.Algebra.Ring.Periodic",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Periodic.lean | periodic_tsum_comp_add_zsmul | Summing the translates of `f` by `ℤ • p` gives a map which is periodic with period `p`.
(This is true without any convergence conditions, since if the sum doesn't converge it is taken to
be the zero map, which is periodic.) |
@[simps]
toContinuousMap (p : R[X]) : C(R, R) :=
⟨fun x : R => p.eval x, by fun_prop⟩
open ContinuousMap in | def | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | toContinuousMap | Every polynomial with coefficients in a topological semiring gives a (bundled) continuous function. |
toContinuousMap_X_eq_id : X.toContinuousMap = .id R := by
ext; simp | lemma | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | toContinuousMap_X_eq_id | null |
@[simps]
toContinuousMapOn (p : R[X]) (X : Set R) : C(X, R) :=
⟨fun x : X => p.toContinuousMap x, by fun_prop⟩
open ContinuousMap in | def | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | toContinuousMapOn | A polynomial as a continuous function,
with domain restricted to some subset of the semiring of coefficients.
(This is particularly useful when restricting to compact sets, e.g. `[0,1]`.) |
toContinuousMapOn_X_eq_restrict_id (s : Set R) :
X.toContinuousMapOn s = restrict s (.id R) := by
ext; simp | lemma | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | toContinuousMapOn_X_eq_restrict_id | null |
@[simp]
aeval_continuousMap_apply (g : R[X]) (f : C(α, R)) (x : α) :
((Polynomial.aeval f) g) x = g.eval (f x) := by
refine Polynomial.induction_on' g ?_ ?_
· intro p q hp hq
simp [hp, hq]
· intro n a
simp | theorem | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | aeval_continuousMap_apply | null |
@[simps]
toContinuousMapAlgHom : R[X] →ₐ[R] C(R, R) where
toFun p := p.toContinuousMap
map_zero' := by
ext
simp
map_add' _ _ := by
ext
simp
map_one' := by
ext
simp
map_mul' _ _ := by
ext
simp
commutes' _ := by
ext
simp [Algebra.algebraMap_eq_smul_one] | def | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | toContinuousMapAlgHom | The algebra map from `R[X]` to continuous functions `C(R, R)`. |
@[simps]
toContinuousMapOnAlgHom (X : Set R) : R[X] →ₐ[R] C(X, R) where
toFun p := p.toContinuousMapOn X
map_zero' := by
ext
simp
map_add' _ _ := by
ext
simp
map_one' := by
ext
simp
map_mul' _ _ := by
ext
simp
commutes' _ := by
ext
simp [Algebra.algebraMap_eq_smul_one] | def | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | toContinuousMapOnAlgHom | The algebra map from `R[X]` to continuous functions `C(X, R)`, for any subset `X` of `R`. |
noncomputable
polynomialFunctions (X : Set R) : Subalgebra R C(X, R) :=
(⊤ : Subalgebra R R[X]).map (Polynomial.toContinuousMapOnAlgHom X)
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | polynomialFunctions | The subalgebra of polynomial functions in `C(X, R)`, for `X` a subset of some topological semiring
`R`. |
polynomialFunctions_coe (X : Set R) :
(polynomialFunctions X : Set C(X, R)) = Set.range (Polynomial.toContinuousMapOnAlgHom X) := by
ext
simp [polynomialFunctions] | theorem | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | polynomialFunctions_coe | null |
polynomialFunctions_separatesPoints (X : Set R) : (polynomialFunctions X).SeparatesPoints :=
fun x y h => by
refine ⟨_, ⟨⟨_, ⟨⟨Polynomial.X, ⟨Algebra.mem_top, rfl⟩⟩, rfl⟩⟩, ?_⟩⟩
dsimp; simp only [Polynomial.eval_X]
exact fun h' => h (Subtype.ext h')
open unitInterval
open ContinuousMap | theorem | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | polynomialFunctions_separatesPoints | null |
polynomialFunctions.comap_compRightAlgHom_iccHomeoI (a b : ℝ) (h : a < b) :
(polynomialFunctions I).comap (compRightAlgHom ℝ ℝ (iccHomeoI a b h).symm) =
polynomialFunctions (Set.Icc a b) := by
ext f
fconstructor
· rintro ⟨p, ⟨-, w⟩⟩
rw [DFunLike.ext_iff] at w
dsimp at w
let q := p.comp ((b - a)⁻¹ • Polynomial.X + Polynomial.C (-a * (b - a)⁻¹))
refine ⟨q, ⟨?_, ?_⟩⟩
· simp
· ext x
simp only [q, neg_mul, RingHom.map_neg, RingHom.map_mul, AlgHom.coe_toRingHom,
Polynomial.eval_X, Polynomial.eval_neg, Polynomial.eval_C, Polynomial.eval_smul,
smul_eq_mul, Polynomial.eval_mul, Polynomial.eval_add,
Polynomial.eval_comp, Polynomial.toContinuousMapOnAlgHom_apply,
Polynomial.toContinuousMapOn_apply, Polynomial.toContinuousMap_apply]
convert w ⟨_, _⟩
· ext
simp only [iccHomeoI_symm_apply_coe]
replace h : b - a ≠ 0 := sub_ne_zero_of_ne h.ne.symm
field_simp
ring
· change _ + _ ∈ I
rw [mul_comm (b - a)⁻¹, ← neg_mul, ← add_mul, ← sub_eq_add_neg]
have w₁ : 0 < (b - a)⁻¹ := inv_pos.mpr (sub_pos.mpr h)
have w₂ : 0 ≤ (x : ℝ) - a := sub_nonneg.mpr x.2.1
have w₃ : (x : ℝ) - a ≤ b - a := sub_le_sub_right x.2.2 a
fconstructor
· exact mul_nonneg w₂ (le_of_lt w₁)
· rw [← div_eq_mul_inv, div_le_one (sub_pos.mpr h)]
exact w₃
· rintro ⟨p, ⟨-, rfl⟩⟩
let q := p.comp ((b - a) • Polynomial.X + Polynomial.C a)
refine ⟨q, ⟨?_, ?_⟩⟩
· simp
· ext x
simp [q, mul_comm] | theorem | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | polynomialFunctions.comap_compRightAlgHom_iccHomeoI | The preimage of polynomials on `[0,1]` under the pullback map by `x ↦ (b-a) * x + a`
is the polynomials on `[a,b]`. |
polynomialFunctions.eq_adjoin_X (s : Set R) :
polynomialFunctions s = Algebra.adjoin R {toContinuousMapOnAlgHom s X} := by
refine le_antisymm ?_
(Algebra.adjoin_le fun _ h => ⟨X, trivial, (Set.mem_singleton_iff.1 h).symm⟩)
rintro - ⟨p, -, rfl⟩
rw [AlgHom.coe_toRingHom]
refine p.induction_on (fun r => ?_) (fun f g hf hg => ?_) fun n r hn => ?_
· rw [Polynomial.C_eq_algebraMap, AlgHomClass.commutes]
exact Subalgebra.algebraMap_mem _ r
· rw [map_add]
exact add_mem hf hg
· rw [pow_succ, ← mul_assoc, map_mul]
exact mul_mem hn (Algebra.subset_adjoin <| Set.mem_singleton _) | theorem | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | polynomialFunctions.eq_adjoin_X | null |
polynomialFunctions.le_equalizer {A : Type*} [Semiring A] [Algebra R A] (s : Set R)
(φ ψ : C(s, R) →ₐ[R] A)
(h : φ (toContinuousMapOnAlgHom s X) = ψ (toContinuousMapOnAlgHom s X)) :
polynomialFunctions s ≤ AlgHom.equalizer φ ψ := by
rw [polynomialFunctions.eq_adjoin_X s]
exact φ.adjoin_le_equalizer ψ fun x hx => (Set.mem_singleton_iff.1 hx).symm ▸ h
open StarAlgebra | theorem | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | polynomialFunctions.le_equalizer | null |
polynomialFunctions.starClosure_eq_adjoin_X [StarRing R] [ContinuousStar R] (s : Set R) :
(polynomialFunctions s).starClosure = adjoin R {toContinuousMapOnAlgHom s X} := by
rw [polynomialFunctions.eq_adjoin_X s, adjoin_eq_starClosure_adjoin] | theorem | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | polynomialFunctions.starClosure_eq_adjoin_X | null |
polynomialFunctions.starClosure_le_equalizer {A : Type*} [StarRing R] [ContinuousStar R]
[Semiring A] [StarRing A] [Algebra R A] (s : Set R) (φ ψ : C(s, R) →⋆ₐ[R] A)
(h : φ (toContinuousMapOnAlgHom s X) = ψ (toContinuousMapOnAlgHom s X)) :
(polynomialFunctions s).starClosure ≤ StarAlgHom.equalizer φ ψ := by
rw [polynomialFunctions.starClosure_eq_adjoin_X s]
exact StarAlgHom.adjoin_le_equalizer φ ψ fun x hx => (Set.mem_singleton_iff.1 hx).symm ▸ h | theorem | Topology | [
"Mathlib.Topology.Algebra.Polynomial",
"Mathlib.Topology.ContinuousMap.Star",
"Mathlib.Topology.UnitInterval",
"Mathlib.Algebra.Star.Subalgebra"
] | Mathlib/Topology/ContinuousMap/Polynomial.lean | polynomialFunctions.starClosure_le_equalizer | null |
compactOpen_eq_generateFrom {S : Set (Set X)} {T : Set (Set Y)}
(hS₁ : ∀ K ∈ S, IsCompact K) (hT : IsTopologicalBasis T)
(hS₂ : ∀ f : C(X, Y), ∀ x, ∀ V ∈ T, f x ∈ V → ∃ K ∈ S, K ∈ 𝓝 x ∧ MapsTo f K V) :
compactOpen = .generateFrom (.image2 (fun K t ↦
{f : C(X, Y) | MapsTo f K (⋃₀ t)}) S {t : Set (Set Y) | t.Finite ∧ t ⊆ T}) := by
apply le_antisymm
· apply_rules [generateFrom_anti, image2_subset_iff.mpr]
intro K hK t ht
exact mem_image2_of_mem (hS₁ K hK) (isOpen_sUnion fun _ h ↦ hT.isOpen <| ht.2 h)
· refine le_of_nhds_le_nhds fun f ↦ ?_
simp only [nhds_compactOpen, le_iInf_iff, le_principal_iff]
intro K (hK : IsCompact K) U (hU : IsOpen U) hfKU
simp only [TopologicalSpace.nhds_generateFrom]
obtain ⟨t, htT, htf, hTU, hKT⟩ : ∃ t ⊆ T, t.Finite ∧ (∀ V ∈ t, V ⊆ U) ∧ f '' K ⊆ ⋃₀ t := by
rw [hT.open_eq_sUnion' hU, mapsTo_iff_image_subset, sUnion_eq_biUnion] at hfKU
obtain ⟨t, ht, hfin, htK⟩ :=
(hK.image (map_continuous f)).elim_finite_subcover_image (fun V hV ↦ hT.isOpen hV.1) hfKU
refine ⟨t, fun _ h ↦ (ht h).1, hfin, fun _ h ↦ (ht h).2, ?_⟩
rwa [sUnion_eq_biUnion]
rw [image_subset_iff] at hKT
obtain ⟨s, hsS, hsf, hKs, hst⟩ : ∃ s ⊆ S, s.Finite ∧ K ⊆ ⋃₀ s ∧ MapsTo f (⋃₀ s) (⋃₀ t) := by
have : ∀ x ∈ K, ∃ L ∈ S, L ∈ 𝓝 x ∧ MapsTo f L (⋃₀ t) := by
intro x hx
rcases hKT hx with ⟨V, hVt, hxV⟩
rcases hS₂ f x V (htT hVt) hxV with ⟨L, hLS, hLx, hLV⟩
exact ⟨L, hLS, hLx, hLV.mono_right <| subset_sUnion_of_mem hVt⟩
choose! L hLS hLmem hLt using this
rcases hK.elim_nhds_subcover L hLmem with ⟨s, hsK, hs⟩
refine ⟨L '' s, image_subset_iff.2 fun x hx ↦ hLS x <| hsK x hx, s.finite_toSet.image _,
by rwa [sUnion_image], ?_⟩
rw [mapsTo_sUnion, forall_mem_image]
exact fun x hx ↦ hLt x <| hsK x hx
have hsub : (⋂ L ∈ s, {g : C(X, Y) | MapsTo g L (⋃₀ t)}) ⊆ {g | MapsTo g K U} := by
simp only [← setOf_forall, ← mapsTo_iUnion, ← sUnion_eq_biUnion]
exact fun g hg ↦ hg.mono hKs (sUnion_subset hTU)
refine mem_of_superset ((biInter_mem hsf).2 fun L hL ↦ ?_) hsub
refine mem_iInf_of_mem _ <| mem_iInf_of_mem ?_ <| mem_principal_self _
exact ⟨hst.mono_left (subset_sUnion_of_mem hL), mem_image2_of_mem (hsS hL) ⟨htf, htT⟩⟩ | theorem | Topology | [
"Mathlib.Topology.CompactOpen"
] | Mathlib/Topology/ContinuousMap/SecondCountableSpace.lean | compactOpen_eq_generateFrom | null |
secondCountableTopology [SecondCountableTopology Y]
(hX : ∃ S : Set (Set X), S.Countable ∧ (∀ K ∈ S, IsCompact K) ∧
∀ f : C(X, Y), ∀ V, IsOpen V → ∀ x ∈ f ⁻¹' V, ∃ K ∈ S, K ∈ 𝓝 x ∧ MapsTo f K V) :
SecondCountableTopology C(X, Y) where
is_open_generated_countable := by
rcases hX with ⟨S, hScount, hScomp, hS⟩
refine ⟨_, ?_, compactOpen_eq_generateFrom (S := S) hScomp (isBasis_countableBasis _) ?_⟩
· exact .image2 hScount (countable_setOf_finite_subset (countable_countableBasis Y)) _
· intro f x V hV hx
apply hS
exacts [isOpen_of_mem_countableBasis hV, hx] | theorem | Topology | [
"Mathlib.Topology.CompactOpen"
] | Mathlib/Topology/ContinuousMap/SecondCountableSpace.lean | secondCountableTopology | A version of `instSecondCountableTopology` with a technical assumption
instead of `[SecondCountableTopology X] [LocallyCompactSpace X]`.
It is here as a reminder of what could be an intermediate goal,
if someone tries to weaken the assumptions in the instance
(e.g., from `[LocallyCompactSpace X]` to `[LocallyCompactPair X Y]` - not sure if it's true). |
instSecondCountableTopology [SecondCountableTopology X] [LocallyCompactSpace X]
[SecondCountableTopology Y] : SecondCountableTopology C(X, Y) := by
apply secondCountableTopology
have (U : countableBasis X) : LocallyCompactSpace U.1 :=
(isOpen_of_mem_countableBasis U.2).locallyCompactSpace
set K := fun U : countableBasis X ↦ CompactExhaustion.choice U.1
use ⋃ U : countableBasis X, Set.range fun n ↦ K U n
refine ⟨countable_iUnion fun _ ↦ countable_range _, ?_, ?_⟩
· simp only [mem_iUnion, mem_range]
rintro K ⟨U, n, rfl⟩
exact ((K U).isCompact _).image continuous_subtype_val
· intro f V hVo x hxV
obtain ⟨U, hU, hxU, hUV⟩ : ∃ U ∈ countableBasis X, x ∈ U ∧ U ⊆ f ⁻¹' V := by
rw [← (isBasis_countableBasis _).mem_nhds_iff]
exact (hVo.preimage (map_continuous f)).mem_nhds hxV
lift x to U using hxU
lift U to countableBasis X using hU
rcases (K U).exists_mem_nhds x with ⟨n, hn⟩
refine ⟨K U n, mem_iUnion.2 ⟨U, mem_range_self _⟩, ?_, ?_⟩
· rw [← map_nhds_subtype_coe_eq_nhds x.2]
exacts [image_mem_map hn, (isOpen_of_mem_countableBasis U.2).mem_nhds x.2]
· rw [mapsTo_image_iff]
exact fun y _ ↦ hUV y.2 | instance | Topology | [
"Mathlib.Topology.CompactOpen"
] | Mathlib/Topology/ContinuousMap/SecondCountableSpace.lean | instSecondCountableTopology | null |
instSeparableSpace [SecondCountableTopology X] [LocallyCompactSpace X]
[SecondCountableTopology Y] : SeparableSpace C(X, Y) :=
inferInstance | instance | Topology | [
"Mathlib.Topology.CompactOpen"
] | Mathlib/Topology/ContinuousMap/SecondCountableSpace.lean | instSeparableSpace | null |
isEmbedding_sigmaMk_comp [Nonempty X] :
IsEmbedding (fun g : Σ i, C(X, Y i) ↦ (sigmaMk g.1).comp g.2) where
toIsInducing := inducing_sigma.2
⟨fun i ↦ (sigmaMk i).isInducing_postcomp IsEmbedding.sigmaMk.isInducing, fun i ↦
let ⟨x⟩ := ‹Nonempty X›
⟨_, (isOpen_sigma_fst_preimage {i}).preimage (continuous_eval_const x), fun _ ↦ Iff.rfl⟩⟩
injective := by
rintro ⟨i, g⟩ ⟨i', g'⟩ h
obtain ⟨rfl, hg⟩ : i = i' ∧ ⇑g ≍ ⇑g' :=
Function.eq_of_sigmaMk_comp <| congr_arg DFunLike.coe h
simpa using hg | theorem | Topology | [
"Mathlib.Topology.CompactOpen"
] | Mathlib/Topology/ContinuousMap/Sigma.lean | isEmbedding_sigmaMk_comp | null |
exists_lift_sigma (f : C(X, Σ i, Y i)) : ∃ i g, f = (sigmaMk i).comp g :=
let ⟨i, g, hg, hfg⟩ := (map_continuous f).exists_lift_sigma
⟨i, ⟨g, hg⟩, DFunLike.ext' hfg⟩
variable (X Y) | theorem | Topology | [
"Mathlib.Topology.CompactOpen"
] | Mathlib/Topology/ContinuousMap/Sigma.lean | exists_lift_sigma | Every continuous map from a connected topological space to the disjoint union of a family of
topological spaces is a composition of the embedding `ContinuousMap.sigmaMk i : C(Y i, Σ i, Y i)`
for some `i` and a continuous map `g : C(X, Y i)`. See also `Continuous.exists_lift_sigma` for a
version with unbundled functions and `ContinuousMap.sigmaCodHomeomorph` for a homeomorphism defined
using this fact. |
@[simps! symm_apply]
sigmaCodHomeomorph : C(X, Σ i, Y i) ≃ₜ Σ i, C(X, Y i) :=
.symm <| Equiv.toHomeomorphOfIsInducing
(.ofBijective _ ⟨isEmbedding_sigmaMk_comp.injective, fun f ↦
let ⟨i, g, hg⟩ := f.exists_lift_sigma; ⟨⟨i, g⟩, hg.symm⟩⟩)
isEmbedding_sigmaMk_comp.isInducing | def | Topology | [
"Mathlib.Topology.CompactOpen"
] | Mathlib/Topology/ContinuousMap/Sigma.lean | sigmaCodHomeomorph | Homeomorphism between the type `C(X, Σ i, Y i)` of continuous maps from a connected topological
space to the disjoint union of a family of topological spaces and the disjoint union of the types of
continuous maps `C(X, Y i)`.
The inverse map sends `⟨i, g⟩` to `ContinuousMap.comp (ContinuousMap.sigmaMk i) g`. |
@[simp]
coe_star (f : C(α, β)) : ⇑(star f) = star (⇑f) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | coe_star | null |
star_apply (f : C(α, β)) (x : α) : star f x = star (f x) :=
rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | star_apply | null |
instTrivialStar [TrivialStar β] : TrivialStar C(α, β) where
star_trivial _ := ext fun _ => star_trivial _ | instance | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | instTrivialStar | null |
starAddMonoid [AddMonoid β] [ContinuousAdd β] [StarAddMonoid β] [ContinuousStar β] :
StarAddMonoid C(α, β) where
star_add _ _ := ext fun _ => star_add _ _ | instance | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | starAddMonoid | null |
starMul [Mul β] [ContinuousMul β] [StarMul β] [ContinuousStar β] :
StarMul C(α, β) where
star_mul _ _ := ext fun _ => star_mul _ _ | instance | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | starMul | null |
@[simps]
compStarAlgHom' (f : C(X, Y)) : C(Y, A) →⋆ₐ[𝕜] C(X, A) where
toFun g := g.comp f
map_one' := one_comp _
map_mul' _ _ := rfl
map_zero' := zero_comp f
map_add' _ _ := rfl
commutes' _ := rfl
map_star' _ := rfl | def | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | compStarAlgHom' | The functorial map taking `f : C(X, Y)` to `C(Y, A) →⋆ₐ[𝕜] C(X, A)` given by pre-composition
with the continuous function `f`. See `ContinuousMap.compMonoidHom'` and
`ContinuousMap.compAddMonoidHom'`, `ContinuousMap.compRightAlgHom` for bundlings of
pre-composition into a `MonoidHom`, an `AddMonoidHom` and an `AlgHom`, respectively, under
suitable assumptions on `A`. |
compStarAlgHom'_id : compStarAlgHom' 𝕜 A (ContinuousMap.id X) = StarAlgHom.id 𝕜 C(X, A) :=
StarAlgHom.ext fun _ => ContinuousMap.ext fun _ => rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | compStarAlgHom'_id | `ContinuousMap.compStarAlgHom'` sends the identity continuous map to the identity
`StarAlgHom` |
compStarAlgHom'_comp (g : C(Y, Z)) (f : C(X, Y)) :
compStarAlgHom' 𝕜 A (g.comp f) = (compStarAlgHom' 𝕜 A f).comp (compStarAlgHom' 𝕜 A g) :=
StarAlgHom.ext fun _ => ContinuousMap.ext fun _ => rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | compStarAlgHom'_comp | `ContinuousMap.compStarAlgHom'` is functorial. |
@[simps]
compStarAlgHom (φ : A →⋆ₐ[𝕜] B) (hφ : Continuous φ) :
C(X, A) →⋆ₐ[𝕜] C(X, B) where
toFun f := (⟨φ, hφ⟩ : C(A, B)).comp f
map_one' := ext fun _ => map_one φ
map_mul' f g := ext fun x => map_mul φ (f x) (g x)
map_zero' := ext fun _ => map_zero φ
map_add' f g := ext fun x => map_add φ (f x) (g x)
commutes' r := ext fun _x => AlgHomClass.commutes φ r
map_star' f := ext fun x => map_star φ (f x) | def | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | compStarAlgHom | Post-composition with a continuous star algebra homomorphism is a star algebra homomorphism
between spaces of continuous maps. |
compStarAlgHom_id : compStarAlgHom X (.id 𝕜 A) continuous_id = .id 𝕜 C(X, A) := rfl | lemma | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | compStarAlgHom_id | `ContinuousMap.compStarAlgHom` sends the identity `StarAlgHom` on `A` to the identity
`StarAlgHom` on `C(X, A)`. |
compStarAlgHom_comp (φ : A →⋆ₐ[𝕜] B) (ψ : B →⋆ₐ[𝕜] C) (hφ : Continuous φ)
(hψ : Continuous ψ) : compStarAlgHom X (ψ.comp φ) (hψ.comp hφ) =
(compStarAlgHom X ψ hψ).comp (compStarAlgHom X φ hφ) :=
rfl | lemma | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | compStarAlgHom_comp | `ContinuousMap.compStarAlgHom` is functorial. |
@[simps]
compStarAlgEquiv' (f : X ≃ₜ Y) : C(Y, A) ≃⋆ₐ[𝕜] C(X, A) :=
{ (f : C(X, Y)).compStarAlgHom' 𝕜 A with
toFun := (f : C(X, Y)).compStarAlgHom' 𝕜 A
invFun := (f.symm : C(Y, X)).compStarAlgHom' 𝕜 A
left_inv := fun g => by
simp only [ContinuousMap.compStarAlgHom'_apply, ContinuousMap.comp_assoc,
toContinuousMap_comp_symm, ContinuousMap.comp_id]
right_inv := fun g => by
simp only [ContinuousMap.compStarAlgHom'_apply, ContinuousMap.comp_assoc,
symm_comp_toContinuousMap, ContinuousMap.comp_id]
map_smul' := fun k a => map_smul ((f : C(X, Y)).compStarAlgHom' 𝕜 A) k a } | def | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | compStarAlgEquiv' | `ContinuousMap.compStarAlgHom'` as a `StarAlgEquiv` when the continuous map `f` is
actually a homeomorphism. |
@[simps!]
ContinuousMap.evalStarAlgHom [StarRing R] [ContinuousStar R] (x : X) :
C(X, R) →⋆ₐ[S] R :=
{ ContinuousMap.evalAlgHom S R x with
map_star' := fun _ => rfl } | def | Topology | [
"Mathlib.Topology.Algebra.Star",
"Mathlib.Algebra.Star.StarAlgHom",
"Mathlib.Topology.ContinuousMap.Algebra"
] | Mathlib/Topology/ContinuousMap/Star.lean | ContinuousMap.evalStarAlgHom | Evaluation of continuous maps at a point, bundled as a star algebra homomorphism. |
ContinuousSqrt (R : Type*) [LE R] [NonUnitalSemiring R] [TopologicalSpace R] where
/-- `sqrt (a, b)` returns a value `s` such that `b = a + s * s` when `a ≤ b`. -/
protected sqrt : R × R → R
protected continuousOn_sqrt : ContinuousOn sqrt {x | x.1 ≤ x.2}
protected sqrt_nonneg (x : R × R) : x.1 ≤ x.2 → 0 ≤ sqrt x
protected sqrt_mul_sqrt (x : R × R) : x.1 ≤ x.2 → x.2 = x.1 + sqrt x * sqrt x | class | Topology | [
"Mathlib.Algebra.Order.Star.Basic",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Ordered"
] | Mathlib/Topology/ContinuousMap/StarOrdered.lean | ContinuousSqrt | A type class encoding the property that there is a continuous square root function on
nonnegative elements. This holds for `ℝ≥0`, `ℝ` and `ℂ` (as well as any C⋆-algebra), and this
allows us to derive an instance of `StarOrderedRing C(α, R)` under appropriate hypotheses.
In order for this to work on `ℝ≥0`, we actually must force our square root function to be defined
on and well-behaved for pairs `x : R × R` with `x.1 ≤ x.2`. |
instStarOrderedRing {R : Type*}
[TopologicalSpace R] [CommSemiring R] [PartialOrder R] [NoZeroDivisors R] [StarRing R]
[StarOrderedRing R] [IsTopologicalSemiring R] [ContinuousStar R] [StarOrderedRing C(α, R)] :
StarOrderedRing C(α, R)₀ where
le_iff f g := by
constructor
· rw [le_def, ← ContinuousMap.coe_coe, ← ContinuousMap.coe_coe g, ← ContinuousMap.le_def,
StarOrderedRing.le_iff]
rintro ⟨p, hp_mem, hp⟩
induction hp_mem using AddSubmonoid.closure_induction_left generalizing f g with
| zero => exact ⟨0, zero_mem _, by ext x; congrm($(hp) x)⟩
| add_left s s_mem p p_mem hp' =>
obtain ⟨s, rfl⟩ := s_mem
simp only at *
have h₀ : (star s * s + p) 0 = 0 := by simpa using congr($(hp) 0).symm
rw [← add_assoc] at hp
have p'₀ : 0 ≤ p 0 := by rw [← StarOrderedRing.nonneg_iff] at p_mem; exact p_mem 0
have s₉ : (star s * s) 0 = 0 := le_antisymm ((le_add_of_nonneg_right p'₀).trans_eq h₀)
(star_mul_self_nonneg (s 0))
have s₀' : s 0 = 0 := by aesop
let s' : C(α, R)₀ := ⟨s, s₀'⟩
obtain ⟨p', hp'_mem, rfl⟩ := hp' (f + star s' * s') g hp
refine ⟨star s' * s' + p', ?_, by rw [add_assoc]⟩
exact add_mem (AddSubmonoid.subset_closure ⟨s', rfl⟩) hp'_mem
· rintro ⟨p, hp, rfl⟩
induction hp using AddSubmonoid.closure_induction generalizing f with
| mem s s_mem =>
obtain ⟨s, rfl⟩ := s_mem
exact fun x ↦ le_add_of_nonneg_right (star_mul_self_nonneg (s x))
| zero => simp
| add g₁ g₂ _ _ h₁ h₂ => calc
f ≤ f + g₁ := h₁ f
_ ≤ (f + g₁) + g₂ := h₂ (f + g₁)
_ = f + (g₁ + g₂) := add_assoc _ _ _ | instance | Topology | [
"Mathlib.Algebra.Order.Star.Basic",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Ordered"
] | Mathlib/Topology/ContinuousMap/StarOrdered.lean | instStarOrderedRing | null |
attachBound (f : C(X, ℝ)) : C(X, Set.Icc (-‖f‖) ‖f‖) where
toFun x := ⟨f x, ⟨neg_norm_le_apply f x, apply_le_norm f x⟩⟩
@[simp] | def | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | attachBound | Turn a function `f : C(X, ℝ)` into a continuous map into `Set.Icc (-‖f‖) (‖f‖)`,
thereby explicitly attaching bounds. |
attachBound_apply_coe (f : C(X, ℝ)) (x : X) : ((attachBound f) x : ℝ) = f x :=
rfl | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | attachBound_apply_coe | null |
polynomial_comp_attachBound (A : Subalgebra ℝ C(X, ℝ)) (f : A) (g : ℝ[X]) :
(g.toContinuousMapOn (Set.Icc (-‖f‖) ‖f‖)).comp (f : C(X, ℝ)).attachBound =
Polynomial.aeval f g := by
ext
simp only [Polynomial.aeval_subalgebra_coe, Polynomial.aeval_continuousMap_apply]
simp | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | polynomial_comp_attachBound | null |
polynomial_comp_attachBound_mem (A : Subalgebra ℝ C(X, ℝ)) (f : A) (g : ℝ[X]) :
(g.toContinuousMapOn (Set.Icc (-‖f‖) ‖f‖)).comp (f : C(X, ℝ)).attachBound ∈ A := by
rw [polynomial_comp_attachBound]
apply SetLike.coe_mem | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | polynomial_comp_attachBound_mem | Given a continuous function `f` in a subalgebra of `C(X, ℝ)`, postcomposing by a polynomial
gives another function in `A`.
This lemma proves something slightly more subtle than this:
we take `f`, and think of it as a function into the restricted target `Set.Icc (-‖f‖) ‖f‖)`,
and then postcompose with a polynomial function on that interval.
This is in fact the same situation as above, and so also gives a function in `A`. |
comp_attachBound_mem_closure (A : Subalgebra ℝ C(X, ℝ)) (f : A)
(p : C(Set.Icc (-‖f‖) ‖f‖, ℝ)) : p.comp (attachBound (f : C(X, ℝ))) ∈ A.topologicalClosure := by
have mem_closure : p ∈ (polynomialFunctions (Set.Icc (-‖f‖) ‖f‖)).topologicalClosure :=
continuousMap_mem_polynomialFunctions_closure _ _ p
have frequently_mem_polynomials := mem_closure_iff_frequently.mp mem_closure
apply mem_closure_iff_frequently.mpr
refine
((compRightContinuousMap ℝ (attachBound (f : C(X, ℝ)))).continuousAt
p).tendsto.frequently_map
_ ?_ frequently_mem_polynomials
rintro _ ⟨g, ⟨-, rfl⟩⟩
simp only [SetLike.mem_coe, AlgHom.coe_toRingHom, compRightContinuousMap_apply,
Polynomial.toContinuousMapOnAlgHom_apply]
apply polynomial_comp_attachBound_mem | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | comp_attachBound_mem_closure | null |
abs_mem_subalgebra_closure (A : Subalgebra ℝ C(X, ℝ)) (f : A) :
|(f : C(X, ℝ))| ∈ A.topologicalClosure := by
let f' := attachBound (f : C(X, ℝ))
let abs : C(Set.Icc (-‖f‖) ‖f‖, ℝ) := { toFun := fun x : Set.Icc (-‖f‖) ‖f‖ => |(x : ℝ)| }
change abs.comp f' ∈ A.topologicalClosure
apply comp_attachBound_mem_closure | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | abs_mem_subalgebra_closure | null |
inf_mem_subalgebra_closure (A : Subalgebra ℝ C(X, ℝ)) (f g : A) :
(f : C(X, ℝ)) ⊓ (g : C(X, ℝ)) ∈ A.topologicalClosure := by
rw [inf_eq_half_smul_add_sub_abs_sub' ℝ]
refine
A.topologicalClosure.smul_mem
(A.topologicalClosure.sub_mem
(A.topologicalClosure.add_mem (A.le_topologicalClosure f.property)
(A.le_topologicalClosure g.property))
?_)
_
exact mod_cast abs_mem_subalgebra_closure A _ | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | inf_mem_subalgebra_closure | null |
inf_mem_closed_subalgebra (A : Subalgebra ℝ C(X, ℝ)) (h : IsClosed (A : Set C(X, ℝ)))
(f g : A) : (f : C(X, ℝ)) ⊓ (g : C(X, ℝ)) ∈ A := by
convert inf_mem_subalgebra_closure A f g
apply SetLike.ext'
symm
rw [Subalgebra.topologicalClosure_coe, closure_eq_iff_isClosed]
exact h | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | inf_mem_closed_subalgebra | null |
sup_mem_subalgebra_closure (A : Subalgebra ℝ C(X, ℝ)) (f g : A) :
(f : C(X, ℝ)) ⊔ (g : C(X, ℝ)) ∈ A.topologicalClosure := by
rw [sup_eq_half_smul_add_add_abs_sub' ℝ]
refine
A.topologicalClosure.smul_mem
(A.topologicalClosure.add_mem
(A.topologicalClosure.add_mem (A.le_topologicalClosure f.property)
(A.le_topologicalClosure g.property))
?_)
_
exact mod_cast abs_mem_subalgebra_closure A _ | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | sup_mem_subalgebra_closure | null |
sup_mem_closed_subalgebra (A : Subalgebra ℝ C(X, ℝ)) (h : IsClosed (A : Set C(X, ℝ)))
(f g : A) : (f : C(X, ℝ)) ⊔ (g : C(X, ℝ)) ∈ A := by
convert sup_mem_subalgebra_closure A f g
apply SetLike.ext'
symm
dsimp
rw [closure_eq_iff_isClosed]
exact h
open scoped Topology | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | sup_mem_closed_subalgebra | null |
sublattice_closure_eq_top (L : Set C(X, ℝ)) (nA : L.Nonempty)
(inf_mem : ∀ᵉ (f ∈ L) (g ∈ L), f ⊓ g ∈ L)
(sup_mem : ∀ᵉ (f ∈ L) (g ∈ L), f ⊔ g ∈ L) (sep : L.SeparatesPointsStrongly) :
closure L = ⊤ := by
rw [eq_top_iff]
rintro f -
refine
Filter.Frequently.mem_closure
((Filter.HasBasis.frequently_iff Metric.nhds_basis_ball).mpr fun ε pos => ?_)
simp only [Metric.mem_ball]
by_cases nX : Nonempty X
swap
· exact ⟨nA.some, (dist_lt_iff pos).mpr fun x => False.elim (nX ⟨x⟩), nA.choose_spec⟩
/-
The strategy now is to pick a family of continuous functions `g x y` in `A`
with the property that `g x y x = f x` and `g x y y = f y`
(this is immediate from `h : SeparatesPointsStrongly`)
then use continuity to see that `g x y` is close to `f` near both `x` and `y`,
and finally using compactness to produce the desired function `h`
as a maximum over finitely many `x` of a minimum over finitely many `y` of the `g x y`.
-/
dsimp only [Set.SeparatesPointsStrongly] at sep
choose g hg w₁ w₂ using sep f
let U : X → X → Set X := fun x y => {z | f z - ε < g x y z}
have U_nhds_y : ∀ x y, U x y ∈ 𝓝 y := by
intro x y
refine IsOpen.mem_nhds ?_ ?_
· apply isOpen_lt <;> fun_prop
· rw [Set.mem_setOf_eq, w₂]
exact sub_lt_self _ pos
let ys : X → Finset X := fun x => (CompactSpace.elim_nhds_subcover (U x) (U_nhds_y x)).choose
let ys_w : ∀ x, ⋃ y ∈ ys x, U x y = ⊤ := fun x =>
(CompactSpace.elim_nhds_subcover (U x) (U_nhds_y x)).choose_spec
have ys_nonempty : ∀ x, (ys x).Nonempty := fun x =>
Set.nonempty_of_union_eq_top_of_nonempty _ _ nX (ys_w x)
let h : X → L := fun x =>
⟨(ys x).sup' (ys_nonempty x) fun y => (g x y : C(X, ℝ)),
Finset.sup'_mem _ sup_mem _ _ _ fun y _ => hg x y⟩
have lt_h : ∀ x z, f z - ε < (h x : X → ℝ) z := by
intro x z
obtain ⟨y, ym, zm⟩ := Set.exists_set_mem_of_union_eq_top _ _ (ys_w x) z
dsimp [h]
simp only [coe_sup', Finset.sup'_apply, Finset.lt_sup'_iff]
exact ⟨y, ym, zm⟩
have h_eq : ∀ x, (h x : X → ℝ) x = f x := by intro x; simp [h, w₁]
let W : X → Set X := fun x => {z | (h x : X → ℝ) z < f z + ε}
have W_nhds : ∀ x, W x ∈ 𝓝 x := by
intro x
refine IsOpen.mem_nhds ?_ ?_
· apply isOpen_lt <;> fun_prop
· dsimp only [W, Set.mem_setOf_eq]
... | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | sublattice_closure_eq_top | null |
subalgebra_topologicalClosure_eq_top_of_separatesPoints (A : Subalgebra ℝ C(X, ℝ))
(w : A.SeparatesPoints) : A.topologicalClosure = ⊤ := by
apply SetLike.ext'
let L := A.topologicalClosure
have n : Set.Nonempty (L : Set C(X, ℝ)) := ⟨(1 : C(X, ℝ)), A.le_topologicalClosure A.one_mem⟩
convert
sublattice_closure_eq_top (L : Set C(X, ℝ)) n
(fun f fm g gm => inf_mem_closed_subalgebra L A.isClosed_topologicalClosure ⟨f, fm⟩ ⟨g, gm⟩)
(fun f fm g gm => sup_mem_closed_subalgebra L A.isClosed_topologicalClosure ⟨f, fm⟩ ⟨g, gm⟩)
(Subalgebra.SeparatesPoints.strongly
(Subalgebra.separatesPoints_monotone A.le_topologicalClosure w))
simp [L] | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | subalgebra_topologicalClosure_eq_top_of_separatesPoints | The **Stone-Weierstrass Approximation Theorem**,
that a subalgebra `A` of `C(X, ℝ)`, where `X` is a compact topological space,
is dense if it separates points. |
continuousMap_mem_subalgebra_closure_of_separatesPoints (A : Subalgebra ℝ C(X, ℝ))
(w : A.SeparatesPoints) (f : C(X, ℝ)) : f ∈ A.topologicalClosure := by
rw [subalgebra_topologicalClosure_eq_top_of_separatesPoints A w]
simp | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | continuousMap_mem_subalgebra_closure_of_separatesPoints | An alternative statement of the Stone-Weierstrass theorem.
If `A` is a subalgebra of `C(X, ℝ)` which separates points (and `X` is compact),
every real-valued continuous function on `X` is a uniform limit of elements of `A`. |
exists_mem_subalgebra_near_continuousMap_of_separatesPoints (A : Subalgebra ℝ C(X, ℝ))
(w : A.SeparatesPoints) (f : C(X, ℝ)) (ε : ℝ) (pos : 0 < ε) :
∃ g : A, ‖(g : C(X, ℝ)) - f‖ < ε := by
have w :=
mem_closure_iff_frequently.mp (continuousMap_mem_subalgebra_closure_of_separatesPoints A w f)
rw [Metric.nhds_basis_ball.frequently_iff] at w
obtain ⟨g, H, m⟩ := w ε pos
rw [Metric.mem_ball, dist_eq_norm] at H
exact ⟨⟨g, m⟩, H⟩ | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | exists_mem_subalgebra_near_continuousMap_of_separatesPoints | An alternative statement of the Stone-Weierstrass theorem,
for those who like their epsilons.
If `A` is a subalgebra of `C(X, ℝ)` which separates points (and `X` is compact),
every real-valued continuous function on `X` is within any `ε > 0` of some element of `A`. |
exists_mem_subalgebra_near_continuous_of_separatesPoints (A : Subalgebra ℝ C(X, ℝ))
(w : A.SeparatesPoints) (f : X → ℝ) (c : Continuous f) (ε : ℝ) (pos : 0 < ε) :
∃ g : A, ∀ x, ‖(g : X → ℝ) x - f x‖ < ε := by
obtain ⟨g, b⟩ := exists_mem_subalgebra_near_continuousMap_of_separatesPoints A w ⟨f, c⟩ ε pos
use g
rwa [norm_lt_iff _ pos] at b | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | exists_mem_subalgebra_near_continuous_of_separatesPoints | An alternative statement of the Stone-Weierstrass theorem,
for those who like their epsilons and don't like bundled continuous functions.
If `A` is a subalgebra of `C(X, ℝ)` which separates points (and `X` is compact),
every real-valued continuous function on `X` is within any `ε > 0` of some element of `A`. |
exists_mem_subalgebra_near_continuous_of_isCompact_of_separatesPoints
{X : Type*} [TopologicalSpace X] {A : Subalgebra ℝ C(X, ℝ)} (hA : A.SeparatesPoints)
(f : C(X, ℝ)) {K : Set X} (hK : IsCompact K) {ε : ℝ} (pos : 0 < ε) :
∃ g ∈ A, ∀ x ∈ K, ‖(g : X → ℝ) x - f x‖ < ε := by
let restrict_on_K : C(X, ℝ) →⋆ₐ[ℝ] C(K, ℝ) :=
ContinuousMap.compStarAlgHom' ℝ ℝ ⟨(Subtype.val), continuous_subtype_val⟩
let AK : Subalgebra ℝ C(K, ℝ) := Subalgebra.map (restrict_on_K) A
have hsep : AK.SeparatesPoints := by
intro x y hxy
obtain ⟨_, ⟨g, hg1, hg2⟩, hg_sep⟩ := hA (Subtype.coe_ne_coe.mpr hxy)
simp only [Set.mem_image, SetLike.mem_coe, exists_exists_and_eq_and]
use restrict_on_K g
refine ⟨Subalgebra.mem_map.mpr ?_,
by simpa only [compStarAlgHom'_apply, comp_apply, coe_mk, ne_eq, restrict_on_K, hg2]⟩
use g, hg1
simp [AlgHom.coe_coe]
obtain ⟨⟨gK, hgKAK⟩, hgapprox⟩ :=
@ContinuousMap.exists_mem_subalgebra_near_continuous_of_separatesPoints _ _
(isCompact_iff_compactSpace.mp hK) AK hsep (K.restrict f)
(ContinuousOn.restrict (Continuous.continuousOn f.continuous)) ε pos
obtain ⟨g, hgA, hgKAK⟩ := Subalgebra.mem_map.mp hgKAK
use g, hgA
intro x hxK
have eqg : g x = gK ⟨x, hxK⟩ := by
rw [← hgKAK]; rfl
rw [eqg]
exact hgapprox ⟨x, hxK⟩ | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | exists_mem_subalgebra_near_continuous_of_isCompact_of_separatesPoints | A variant of the Stone-Weierstrass theorem where `X` need not be compact:
If `A` is a subalgebra of `C(X, ℝ)` which separates points, then, for any compact set `K ⊆ X`,
every real-valued continuous function on `X` is within any `ε > 0` of some element of `A` on `K`. |
Subalgebra.SeparatesPoints.rclike_to_real {A : StarSubalgebra 𝕜 C(X, 𝕜)}
(hA : A.SeparatesPoints) :
((A.restrictScalars ℝ).comap
(ofRealAm.compLeftContinuous ℝ continuous_ofReal)).SeparatesPoints := by
intro x₁ x₂ hx
obtain ⟨_, ⟨f, hfA, rfl⟩, hf⟩ := hA hx
let F : C(X, 𝕜) := f - const _ (f x₂)
have hFA : F ∈ A := by
refine A.sub_mem hfA (@Eq.subst _ (· ∈ A) _ _ ?_ <| A.smul_mem A.one_mem <| f x₂)
ext1
simp only [smul_apply, one_apply, Algebra.id.smul_eq_mul, mul_one,
const_apply]
refine ⟨_, ⟨⟨(‖F ·‖ ^ 2), by fun_prop⟩, ?_, rfl⟩, ?_⟩
· -- This is also an element of the subalgebra, and takes only real values
rw [SetLike.mem_coe, Subalgebra.mem_comap]
convert (A.restrictScalars ℝ).mul_mem hFA (star_mem hFA : star F ∈ A)
ext1
simp [← RCLike.mul_conj]
· -- And it also separates the points `x₁`, `x₂`
simpa [F] using sub_ne_zero.mpr hf
variable [CompactSpace X] | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | Subalgebra.SeparatesPoints.rclike_to_real | If a star subalgebra of `C(X, 𝕜)` separates points, then the real subalgebra
of its purely real-valued elements also separates points. |
ContinuousMap.starSubalgebra_topologicalClosure_eq_top_of_separatesPoints
(A : StarSubalgebra 𝕜 C(X, 𝕜)) (hA : A.SeparatesPoints) : A.topologicalClosure = ⊤ := by
rw [StarSubalgebra.eq_top_iff]
let I : C(X, ℝ) →L[ℝ] C(X, 𝕜) := ofRealCLM.compLeftContinuous ℝ X
have key : LinearMap.range I ≤ (A.toSubmodule.restrictScalars ℝ).topologicalClosure := by
let A₀ : Submodule ℝ C(X, ℝ) := (A.toSubmodule.restrictScalars ℝ).comap I
have SW : A₀.topologicalClosure = ⊤ :=
haveI := subalgebra_topologicalClosure_eq_top_of_separatesPoints _ hA.rclike_to_real
congr_arg Subalgebra.toSubmodule this
rw [← Submodule.map_top, ← SW]
have h₁ := A₀.topologicalClosure_map I
have h₂ := (A.toSubmodule.restrictScalars ℝ).map_comap_le I
exact h₁.trans (Submodule.topologicalClosure_mono h₂)
intro f
let f_re : C(X, ℝ) := (⟨RCLike.re, RCLike.reCLM.continuous⟩ : C(𝕜, ℝ)).comp f
let f_im : C(X, ℝ) := (⟨RCLike.im, RCLike.imCLM.continuous⟩ : C(𝕜, ℝ)).comp f
have h_f_re : I f_re ∈ A.topologicalClosure := key ⟨f_re, rfl⟩
have h_f_im : I f_im ∈ A.topologicalClosure := key ⟨f_im, rfl⟩
have := A.topologicalClosure.add_mem h_f_re (A.topologicalClosure.smul_mem h_f_im RCLike.I)
rw [StarSubalgebra.mem_toSubalgebra] at this
convert this
ext
apply Eq.symm
simp [I, f_re, f_im, mul_comm RCLike.I _] | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | ContinuousMap.starSubalgebra_topologicalClosure_eq_top_of_separatesPoints | The Stone-Weierstrass approximation theorem, `RCLike` version, that a star subalgebra `A` of
`C(X, 𝕜)`, where `X` is a compact topological space and `RCLike 𝕜`, is dense if it separates
points. |
polynomialFunctions.topologicalClosure (s : Set ℝ)
[CompactSpace s] : (polynomialFunctions s).topologicalClosure = ⊤ :=
ContinuousMap.subalgebra_topologicalClosure_eq_top_of_separatesPoints _
(polynomialFunctions_separatesPoints s) | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | polynomialFunctions.topologicalClosure | Polynomial functions in are dense in `C(s, ℝ)` when `s` is compact.
See `polynomialFunctions_closure_eq_top` for the special case `s = Set.Icc a b` which does not use
the full Stone-Weierstrass theorem. Of course, that version could be used to prove this one as
well. |
polynomialFunctions.starClosure_topologicalClosure {𝕜 : Type*} [RCLike 𝕜] (s : Set 𝕜)
[CompactSpace s] : (polynomialFunctions s).starClosure.topologicalClosure = ⊤ :=
ContinuousMap.starSubalgebra_topologicalClosure_eq_top_of_separatesPoints _
(Subalgebra.separatesPoints_monotone le_sup_left (polynomialFunctions_separatesPoints s))
open StarAlgebra in | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | polynomialFunctions.starClosure_topologicalClosure | The star subalgebra generated by polynomials functions is dense in `C(s, 𝕜)` when `s` is
compact and `𝕜` is either `ℝ` or `ℂ`. |
ContinuousMap.elemental_id_eq_top {𝕜 : Type*} [RCLike 𝕜] (s : Set 𝕜) [CompactSpace s] :
elemental 𝕜 (ContinuousMap.restrict s (.id 𝕜)) = ⊤ := by
rw [StarAlgebra.elemental, ← polynomialFunctions.starClosure_topologicalClosure,
polynomialFunctions.starClosure_eq_adjoin_X]
congr
exact Polynomial.toContinuousMap_X_eq_id.symm | lemma | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | ContinuousMap.elemental_id_eq_top | null |
@[elab_as_elim]
ContinuousMap.induction_on {𝕜 : Type*} [RCLike 𝕜] {s : Set 𝕜}
{p : C(s, 𝕜) → Prop} (const : ∀ r, p (.const s r)) (id : p (.restrict s <| .id 𝕜))
(star_id : p (star (.restrict s <| .id 𝕜)))
(add : ∀ f g, p f → p g → p (f + g)) (mul : ∀ f g, p f → p g → p (f * g))
(closure : (∀ f ∈ (polynomialFunctions s).starClosure, p f) → ∀ f, p f) (f : C(s, 𝕜)) :
p f := by
refine closure (fun f hf => ?_) f
rw [polynomialFunctions.starClosure_eq_adjoin_X] at hf
induction hf using Algebra.adjoin_induction with
| mem f hf =>
simp only [Set.mem_union, Set.mem_singleton_iff, Set.mem_star] at hf
rw [star_eq_iff_star_eq, eq_comm (b := f)] at hf
obtain (rfl | rfl) := hf
all_goals simpa only [toContinuousMapOnAlgHom_apply, toContinuousMapOn_X_eq_restrict_id]
| algebraMap r => exact const r
| add _ _ _ _ hf hg => exact add _ _ hf hg
| mul _ _ _ _ hf hg => exact mul _ _ hf hg
open Topology in
@[elab_as_elim] | theorem | Topology | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Analysis.RCLike.Basic",
"Mathlib.Topology.Algebra.Star.Real",
"Mathlib.Topology.Algebra.StarSubalgebra",
"Mathlib.Topology.Algebra.NonUnitalStarAlgebra",
"Mathlib.Topology.ContinuousMap.ContinuousMapZero",
"Mathlib.Topology.ContinuousMap.Lattice",
"... | Mathlib/Topology/ContinuousMap/StoneWeierstrass.lean | ContinuousMap.induction_on | An induction principle for `C(s, 𝕜)`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.