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 ⌀ |
|---|---|---|---|---|---|---|
Subgroup.tendsto_coe_cofinite_of_discrete [T2Space G] (H : Subgroup G) [DiscreteTopology H] :
Tendsto ((↑) : H → G) cofinite (cocompact _) :=
IsClosed.tendsto_coe_cofinite_of_discreteTopology inferInstance inferInstance
@[to_additive] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.CompleteSeparated",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology... | Mathlib/Topology/Algebra/IsUniformGroup/Basic.lean | Subgroup.tendsto_coe_cofinite_of_discrete | null |
MonoidHom.tendsto_coe_cofinite_of_discrete [T2Space G] {H : Type*} [Group H] {f : H →* G}
(hf : Function.Injective f) (hf' : DiscreteTopology f.range) :
Tendsto f cofinite (cocompact _) := by
replace hf : Function.Injective f.rangeRestrict := by simpa
exact f.range.tendsto_coe_cofinite_of_discrete.comp hf.tendsto_cofinite | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.CompleteSeparated",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology... | Mathlib/Topology/Algebra/IsUniformGroup/Basic.lean | MonoidHom.tendsto_coe_cofinite_of_discrete | null |
@[to_additive]
tendstoUniformly_iff (F : ι → α → G) (f : α → G) (p : Filter ι)
(hu : IsTopologicalGroup.toUniformSpace G = u) :
TendstoUniformly F f p ↔ ∀ u ∈ 𝓝 (1 : G), ∀ᶠ i in p, ∀ a, F i a / f a ∈ u :=
hu ▸ ⟨fun h u hu => h _ ⟨u, hu, fun _ => id⟩,
fun h _ ⟨u, hu, hv⟩ => mem_of_superset (h u hu) fun _ hi a => hv (hi a)⟩
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.CompleteSeparated",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology... | Mathlib/Topology/Algebra/IsUniformGroup/Basic.lean | tendstoUniformly_iff | null |
tendstoUniformlyOn_iff (F : ι → α → G) (f : α → G) (p : Filter ι) (s : Set α)
(hu : IsTopologicalGroup.toUniformSpace G = u) :
TendstoUniformlyOn F f p s ↔ ∀ u ∈ 𝓝 (1 : G), ∀ᶠ i in p, ∀ a ∈ s, F i a / f a ∈ u :=
hu ▸ ⟨fun h u hu => h _ ⟨u, hu, fun _ => id⟩,
fun h _ ⟨u, hu, hv⟩ => mem_of_superset (h u hu) fun _ hi a ha => hv (hi a ha)⟩
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.CompleteSeparated",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology... | Mathlib/Topology/Algebra/IsUniformGroup/Basic.lean | tendstoUniformlyOn_iff | null |
tendstoLocallyUniformly_iff [TopologicalSpace α] (F : ι → α → G) (f : α → G)
(p : Filter ι) (hu : IsTopologicalGroup.toUniformSpace G = u) :
TendstoLocallyUniformly F f p ↔
∀ u ∈ 𝓝 (1 : G), ∀ (x : α), ∃ t ∈ 𝓝 x, ∀ᶠ i in p, ∀ a ∈ t, F i a / f a ∈ u :=
hu ▸ ⟨fun h u hu => h _ ⟨u, hu, fun _ => id⟩, fun h _ ⟨u, hu, hv⟩ x =>
Exists.imp (fun _ ⟨h, hp⟩ => ⟨h, mem_of_superset hp fun _ hi a ha => hv (hi a ha)⟩)
(h u hu x)⟩
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.CompleteSeparated",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology... | Mathlib/Topology/Algebra/IsUniformGroup/Basic.lean | tendstoLocallyUniformly_iff | null |
tendstoLocallyUniformlyOn_iff [TopologicalSpace α] (F : ι → α → G) (f : α → G)
(p : Filter ι) (s : Set α) (hu : IsTopologicalGroup.toUniformSpace G = u) :
TendstoLocallyUniformlyOn F f p s ↔
∀ u ∈ 𝓝 (1 : G), ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, ∀ᶠ i in p, ∀ a ∈ t, F i a / f a ∈ u :=
hu ▸ ⟨fun h u hu => h _ ⟨u, hu, fun _ => id⟩, fun h _ ⟨u, hu, hv⟩ x =>
(Exists.imp fun _ ⟨h, hp⟩ => ⟨h, mem_of_superset hp fun _ hi a ha => hv (hi a ha)⟩) ∘
h u hu x⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.CompleteSeparated",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology... | Mathlib/Topology/Algebra/IsUniformGroup/Basic.lean | tendstoLocallyUniformlyOn_iff | null |
private extend_Z_bilin_aux (x₀ : α) (y₁ : δ) : ∃ U₂ ∈ comap e (𝓝 x₀), ∀ x ∈ U₂, ∀ x' ∈ U₂,
(fun p : β × δ => φ p.1 p.2) (x' - x, y₁) ∈ W' := by
let Nx := 𝓝 x₀
let ee := fun u : β × β => (e u.1, e u.2)
have lim1 : Tendsto (fun a : β × β => (a.2 - a.1, y₁))
(comap e Nx ×ˢ comap e Nx) (𝓝 (0, y₁)) := by
have := Tendsto.prodMk (tendsto_sub_comap_self de x₀)
(tendsto_const_nhds : Tendsto (fun _ : β × β => y₁) (comap ee <| 𝓝 (x₀, x₀)) (𝓝 y₁))
rw [nhds_prod_eq, prod_comap_comap_eq, ← nhds_prod_eq]
exact (this :)
have lim2 : Tendsto (fun p : β × δ => φ p.1 p.2) (𝓝 (0, y₁)) (𝓝 0) := by
simpa using hφ.tendsto (0, y₁)
have lim := lim2.comp lim1
rw [tendsto_prod_self_iff] at lim
simp_rw [forall_mem_comm]
exact lim W' W'_nhds
variable [IsUniformAddGroup G]
include df W'_nhds in | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.CompleteSeparated",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology... | Mathlib/Topology/Algebra/IsUniformGroup/Basic.lean | extend_Z_bilin_aux | null |
private extend_Z_bilin_key (x₀ : α) (y₀ : γ) : ∃ U ∈ comap e (𝓝 x₀), ∃ V ∈ comap f (𝓝 y₀),
∀ x ∈ U, ∀ x' ∈ U, ∀ (y) (_ : y ∈ V) (y') (_ : y' ∈ V),
(fun p : β × δ => φ p.1 p.2) (x', y') - (fun p : β × δ => φ p.1 p.2) (x, y) ∈ W' := by
let ee := fun u : β × β => (e u.1, e u.2)
let ff := fun u : δ × δ => (f u.1, f u.2)
have lim_φ : Filter.Tendsto (fun p : β × δ => φ p.1 p.2) (𝓝 (0, 0)) (𝓝 0) := by
simpa using hφ.tendsto (0, 0)
have lim_φ_sub_sub :
Tendsto (fun p : (β × β) × δ × δ => (fun p : β × δ => φ p.1 p.2) (p.1.2 - p.1.1, p.2.2 - p.2.1))
((comap ee <| 𝓝 (x₀, x₀)) ×ˢ (comap ff <| 𝓝 (y₀, y₀))) (𝓝 0) := by
have lim_sub_sub :
Tendsto (fun p : (β × β) × δ × δ => (p.1.2 - p.1.1, p.2.2 - p.2.1))
(comap ee (𝓝 (x₀, x₀)) ×ˢ comap ff (𝓝 (y₀, y₀))) (𝓝 0 ×ˢ 𝓝 0) := by
have := Filter.prod_mono (tendsto_sub_comap_self de x₀) (tendsto_sub_comap_self df y₀)
rwa [prod_map_map_eq] at this
rw [← nhds_prod_eq] at lim_sub_sub
exact Tendsto.comp lim_φ lim_sub_sub
rcases exists_nhds_zero_quarter W'_nhds with ⟨W, W_nhds, W4⟩
have :
∃ U₁ ∈ comap e (𝓝 x₀), ∃ V₁ ∈ comap f (𝓝 y₀), ∀ (x) (_ : x ∈ U₁) (x') (_ : x' ∈ U₁),
∀ (y) (_ : y ∈ V₁) (y') (_ : y' ∈ V₁), (fun p : β × δ => φ p.1 p.2) (x' - x, y' - y) ∈ W := by
rcases tendsto_prod_iff.1 lim_φ_sub_sub W W_nhds with ⟨U, U_in, V, V_in, H⟩
rw [nhds_prod_eq, ← prod_comap_comap_eq, mem_prod_same_iff] at U_in V_in
rcases U_in with ⟨U₁, U₁_in, HU₁⟩
rcases V_in with ⟨V₁, V₁_in, HV₁⟩
exists U₁, U₁_in, V₁, V₁_in
intro x x_in x' x'_in y y_in y' y'_in
exact H _ _ (HU₁ (mk_mem_prod x_in x'_in)) (HV₁ (mk_mem_prod y_in y'_in))
rcases this with ⟨U₁, U₁_nhds, V₁, V₁_nhds, H⟩
obtain ⟨x₁, x₁_in⟩ : U₁.Nonempty := (de.comap_nhds_neBot _).nonempty_of_mem U₁_nhds
obtain ⟨y₁, y₁_in⟩ : V₁.Nonempty := (df.comap_nhds_neBot _).nonempty_of_mem V₁_nhds
have cont_flip : Continuous fun p : δ × β => φ.flip p.1 p.2 := by
change Continuous ((fun p : β × δ => φ p.1 p.2) ∘ Prod.swap)
exact hφ.comp continuous_swap
rcases extend_Z_bilin_aux de hφ W_nhds x₀ y₁ with ⟨U₂, U₂_nhds, HU⟩
rcases extend_Z_bilin_aux df cont_flip W_nhds y₀ x₁ with ⟨V₂, V₂_nhds, HV⟩
exists U₁ ∩ U₂, inter_mem U₁_nhds U₂_nhds, V₁ ∩ V₂, inter_mem V₁_nhds V₂_nhds
rintro x ⟨xU₁, xU₂⟩ x' ⟨x'U₁, x'U₂⟩ y ⟨yV₁, yV₂⟩ y' ⟨y'V₁, y'V₂⟩
have key_formula : φ x' y' - φ x y
= φ (x' - x) y₁ + φ (x' - x) (y' - y₁) + φ x₁ (y' - y) + φ (x - x₁) (y' - y) := by simp; abel
rw [key_formula]
have h₁ := HU x xU₂ x' x'U₂
have h₂ := H x xU₁ x' x'U₁ y₁ y₁_in y' y'V₁
have h₃ := HV y yV₂ y' y'V₂
have h₄ := H x₁ x₁_in x xU₁ y yV₁ y' y'V₁
exact W4 h₁ h₂ h₃ h₄
open IsDenseInducing
variable [T0Space G] [CompleteSpace G] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.CompleteSeparated",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology... | Mathlib/Topology/Algebra/IsUniformGroup/Basic.lean | extend_Z_bilin_key | null |
extend_Z_bilin : Continuous (extend (de.prodMap df) (fun p : β × δ => φ p.1 p.2)) := by
refine continuous_extend_of_cauchy _ ?_
rintro ⟨x₀, y₀⟩
constructor
· apply NeBot.map
apply comap_neBot
intro U h
rcases mem_closure_iff_nhds.1 ((de.prodMap df).dense (x₀, y₀)) U h with ⟨x, x_in, ⟨z, z_x⟩⟩
exists z
simp_all
· suffices map (fun p : (β × δ) × β × δ => (fun p : β × δ => φ p.1 p.2) p.2 -
(fun p : β × δ => φ p.1 p.2) p.1)
(comap (fun p : (β × δ) × β × δ => ((e p.1.1, f p.1.2), (e p.2.1, f p.2.2)))
(𝓝 (x₀, y₀) ×ˢ 𝓝 (x₀, y₀))) ≤ 𝓝 0 by
rwa [uniformity_eq_comap_nhds_zero G, prod_map_map_eq, ← map_le_iff_le_comap, Filter.map_map,
prod_comap_comap_eq]
intro W' W'_nhds
have key := extend_Z_bilin_key de df hφ W'_nhds x₀ y₀
rcases key with ⟨U, U_nhds, V, V_nhds, h⟩
rw [mem_comap] at U_nhds
rcases U_nhds with ⟨U', U'_nhds, U'_sub⟩
rw [mem_comap] at V_nhds
rcases V_nhds with ⟨V', V'_nhds, V'_sub⟩
rw [mem_map, mem_comap, nhds_prod_eq]
exists (U' ×ˢ V') ×ˢ U' ×ˢ V'
rw [mem_prod_same_iff]
have := prod_mem_prod U'_nhds V'_nhds
grind | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.CompleteSeparated",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology... | Mathlib/Topology/Algebra/IsUniformGroup/Basic.lean | extend_Z_bilin | Bourbaki GT III.6.5 Theorem I:
ℤ-bilinear continuous maps from dense images into a complete Hausdorff group extend by continuity.
Note: Bourbaki assumes that α and β are also complete Hausdorff, but this is not necessary. |
QuotientGroup.completeSpace' (G : Type u) [Group G] [TopologicalSpace G]
[IsTopologicalGroup G] [FirstCountableTopology G] (N : Subgroup G) [N.Normal]
[@CompleteSpace G (IsTopologicalGroup.toUniformSpace G)] :
@CompleteSpace (G ⧸ N) (IsTopologicalGroup.toUniformSpace (G ⧸ N)) := by
/- Since `G ⧸ N` is a topological group it is a uniform space, and since `G` is first countable
the uniformities of both `G` and `G ⧸ N` are countably generated. Moreover, we may choose a
sequential antitone neighborhood basis `u` for `𝓝 (1 : G)` so that `(u (n + 1)) ^ 2 ⊆ u n`, and
this descends to an antitone neighborhood basis `v` for `𝓝 (1 : G ⧸ N)`. Since `𝓤 (G ⧸ N)` is
countably generated, it suffices to show any Cauchy sequence `x` converges. -/
letI : UniformSpace (G ⧸ N) := IsTopologicalGroup.toUniformSpace (G ⧸ N)
letI : UniformSpace G := IsTopologicalGroup.toUniformSpace G
haveI : (𝓤 (G ⧸ N)).IsCountablyGenerated := comap.isCountablyGenerated _ _
obtain ⟨u, hu, u_mul⟩ := IsTopologicalGroup.exists_antitone_basis_nhds_one G
obtain ⟨hv, v_anti⟩ := hu.map ((↑) : G → G ⧸ N)
rw [← QuotientGroup.nhds_eq N 1, QuotientGroup.mk_one] at hv
refine UniformSpace.complete_of_cauchySeq_tendsto fun x hx => ?_
/- Given `n : ℕ`, for sufficiently large `a b : ℕ`, given any lift of `x b`, we can find a lift
of `x a` such that the quotient of the lifts lies in `u n`. -/
have key₀ : ∀ i j : ℕ, ∃ M : ℕ, j < M ∧ ∀ a b : ℕ, M ≤ a → M ≤ b →
∀ g : G, x b = g → ∃ g' : G, g / g' ∈ u i ∧ x a = g' := by
have h𝓤GN : (𝓤 (G ⧸ N)).HasBasis (fun _ ↦ True) fun i ↦ { x | x.snd / x.fst ∈ (↑) '' u i } := by
simpa [uniformity_eq_comap_nhds_one'] using hv.comap _
rw [h𝓤GN.cauchySeq_iff] at hx
simp only [mem_setOf_eq, forall_true_left, mem_image] at hx
intro i j
rcases hx i with ⟨M, hM⟩
refine ⟨max j M + 1, (le_max_left _ _).trans_lt (lt_add_one _), fun a b ha hb g hg => ?_⟩
obtain ⟨y, y_mem, hy⟩ :=
hM a (((le_max_right j _).trans (lt_add_one _).le).trans ha) b
(((le_max_right j _).trans (lt_add_one _).le).trans hb)
refine
⟨y⁻¹ * g, by
simpa only [div_eq_mul_inv, mul_inv_rev, inv_inv, mul_inv_cancel_left] using y_mem, ?_⟩
rw [QuotientGroup.mk_mul, QuotientGroup.mk_inv, hy, hg, inv_div, div_mul_cancel]
/- Inductively construct a subsequence `φ : ℕ → ℕ` using `key₀` so that if `a b : ℕ` exceed
`φ (n + 1)`, then we may find lifts whose quotients lie within `u n`. -/
set φ : ℕ → ℕ := fun n => Nat.recOn n (choose <| key₀ 0 0) fun k yk => choose <| key₀ (k + 1) yk
have hφ :
∀ n : ℕ,
φ n < φ (n + 1) ∧
∀ a b : ℕ,
φ (n + 1) ≤ a →
φ (n + 1) ≤ b → ∀ g : G, x b = g → ∃ g' : G, g / g' ∈ u (n + 1) ∧ x a = g' :=
fun n => choose_spec (key₀ (n + 1) (φ n))
/- Inductively construct a sequence `x' n : G` of lifts of `x (φ (n + 1))` such that quotients of
successive terms lie in `x' n / x' (n + 1) ∈ u (n + 1)`. We actually need the proofs that each
term is a lift to construct the next term, so we use a Σ-type. -/
set x' : ∀ n, PSigma fun g : G => x (φ (n + 1)) = g := fun n =>
Nat.recOn n
⟨choose (QuotientGroup.mk_surjective (x (φ 1))),
(choose_spec (QuotientGroup.mk_surjective (x (φ 1)))).symm⟩
... | instance | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.CompleteSeparated",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology... | Mathlib/Topology/Algebra/IsUniformGroup/Basic.lean | QuotientGroup.completeSpace' | null |
QuotientGroup.completeSpace (G : Type u) [Group G] [us : UniformSpace G] [IsUniformGroup G]
[FirstCountableTopology G] (N : Subgroup G) [N.Normal] [hG : CompleteSpace G] :
@CompleteSpace (G ⧸ N) (IsTopologicalGroup.toUniformSpace (G ⧸ N)) := by
rw [← @IsUniformGroup.toUniformSpace_eq _ us _ _] at hG
infer_instance | instance | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.CompleteSeparated",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology... | Mathlib/Topology/Algebra/IsUniformGroup/Basic.lean | QuotientGroup.completeSpace | null |
IsUniformGroup (α : Type*) [UniformSpace α] [Group α] : Prop where
uniformContinuous_div : UniformContinuous fun p : α × α => p.1 / p.2
@[deprecated (since := "2025-03-26")] alias UniformGroup := IsUniformGroup | class | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | IsUniformGroup | A uniform group is a group in which multiplication and inversion are uniformly continuous. |
IsUniformAddGroup (α : Type*) [UniformSpace α] [AddGroup α] : Prop where
uniformContinuous_sub : UniformContinuous fun p : α × α => p.1 - p.2
@[deprecated (since := "2025-03-26")] alias UniformAddGroup := IsUniformAddGroup
attribute [to_additive] IsUniformGroup
@[to_additive] | class | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | IsUniformAddGroup | A uniform additive group is an additive group in which addition
and negation are uniformly continuous. |
IsUniformGroup.mk' {α} [UniformSpace α] [Group α]
(h₁ : UniformContinuous fun p : α × α => p.1 * p.2) (h₂ : UniformContinuous fun p : α => p⁻¹) :
IsUniformGroup α :=
⟨by simpa only [div_eq_mul_inv] using
h₁.comp (uniformContinuous_fst.prodMk (h₂.comp uniformContinuous_snd))⟩
variable [UniformSpace α] [Group α] [IsUniformGroup α]
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | IsUniformGroup.mk' | null |
uniformContinuous_div : UniformContinuous fun p : α × α => p.1 / p.2 :=
IsUniformGroup.uniformContinuous_div
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | uniformContinuous_div | null |
UniformContinuous.div [UniformSpace β] {f : β → α} {g : β → α} (hf : UniformContinuous f)
(hg : UniformContinuous g) : UniformContinuous fun x => f x / g x :=
uniformContinuous_div.comp (hf.prodMk hg)
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | UniformContinuous.div | null |
UniformContinuous.inv [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
UniformContinuous fun x => (f x)⁻¹ := by
have : UniformContinuous fun x => 1 / f x := uniformContinuous_const.div hf
simp_all
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | UniformContinuous.inv | null |
uniformContinuous_inv : UniformContinuous fun x : α => x⁻¹ :=
uniformContinuous_id.inv
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | uniformContinuous_inv | null |
UniformContinuous.mul [UniformSpace β] {f : β → α} {g : β → α} (hf : UniformContinuous f)
(hg : UniformContinuous g) : UniformContinuous fun x => f x * g x := by
have : UniformContinuous fun x => f x / (g x)⁻¹ := hf.div hg.inv
simp_all
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | UniformContinuous.mul | null |
uniformContinuous_mul : UniformContinuous fun p : α × α => p.1 * p.2 :=
uniformContinuous_fst.mul uniformContinuous_snd
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | uniformContinuous_mul | null |
UniformContinuous.mul_const [UniformSpace β] {f : β → α} (hf : UniformContinuous f)
(a : α) : UniformContinuous fun x ↦ f x * a :=
hf.mul uniformContinuous_const
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | UniformContinuous.mul_const | null |
UniformContinuous.const_mul [UniformSpace β] {f : β → α} (hf : UniformContinuous f)
(a : α) : UniformContinuous fun x ↦ a * f x :=
uniformContinuous_const.mul hf
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | UniformContinuous.const_mul | null |
uniformContinuous_mul_left (a : α) : UniformContinuous fun b : α => a * b :=
uniformContinuous_id.const_mul _
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | uniformContinuous_mul_left | null |
uniformContinuous_mul_right (a : α) : UniformContinuous fun b : α => b * a :=
uniformContinuous_id.mul_const _
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | uniformContinuous_mul_right | null |
UniformContinuous.div_const [UniformSpace β] {f : β → α} (hf : UniformContinuous f)
(a : α) : UniformContinuous fun x ↦ f x / a :=
hf.div uniformContinuous_const
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | UniformContinuous.div_const | null |
uniformContinuous_div_const (a : α) : UniformContinuous fun b : α => b / a :=
uniformContinuous_id.div_const _
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | uniformContinuous_div_const | null |
Filter.Tendsto.uniformity_mul {ι : Type*} {f g : ι → α × α} {l : Filter ι}
(hf : Tendsto f l (𝓤 α)) (hg : Tendsto g l (𝓤 α)) :
Tendsto (f * g) l (𝓤 α) :=
have : Tendsto (fun (p : (α × α) × (α × α)) ↦ p.1 * p.2) (𝓤 α ×ˢ 𝓤 α) (𝓤 α) := by
simpa [UniformContinuous, uniformity_prod_eq_prod] using uniformContinuous_mul (α := α)
this.comp (hf.prodMk hg)
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | Filter.Tendsto.uniformity_mul | null |
Filter.Tendsto.uniformity_inv {ι : Type*} {f : ι → α × α} {l : Filter ι}
(hf : Tendsto f l (𝓤 α)) :
Tendsto (f⁻¹) l (𝓤 α) :=
have : Tendsto (· ⁻¹) (𝓤 α) (𝓤 α) := uniformContinuous_inv
this.comp hf
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | Filter.Tendsto.uniformity_inv | null |
Filter.Tendsto.uniformity_inv_iff {ι : Type*} {f : ι → α × α} {l : Filter ι} :
Tendsto (f⁻¹) l (𝓤 α) ↔ Tendsto f l (𝓤 α) :=
⟨fun H ↦ inv_inv f ▸ H.uniformity_inv, Filter.Tendsto.uniformity_inv⟩
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | Filter.Tendsto.uniformity_inv_iff | null |
Filter.Tendsto.uniformity_div {ι : Type*} {f g : ι → α × α} {l : Filter ι}
(hf : Tendsto f l (𝓤 α)) (hg : Tendsto g l (𝓤 α)) :
Tendsto (f / g) l (𝓤 α) := by
rw [div_eq_mul_inv]
exact hf.uniformity_mul hg.uniformity_inv | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | Filter.Tendsto.uniformity_div | null |
@[to_additive /-- If `f : ι → G × G` converges to the uniformity, then any `g : ι → G × G`
converges to the uniformity iff `f + g` does. This is often useful when `f` is valued in the
diagonal, in which case its convergence is automatic. -/]
Filter.Tendsto.uniformity_mul_iff_right {ι : Type*} {f g : ι → α × α} {l : Filter ι}
(hf : Tendsto f l (𝓤 α)) :
Tendsto (f * g) l (𝓤 α) ↔ Tendsto g l (𝓤 α) :=
⟨fun hfg ↦ by simpa using hf.uniformity_inv.uniformity_mul hfg, hf.uniformity_mul⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | Filter.Tendsto.uniformity_mul_iff_right | If `f : ι → G × G` converges to the uniformity, then any `g : ι → G × G` converges to the
uniformity iff `f * g` does. This is often useful when `f` is valued in the diagonal,
in which case its convergence is automatic. |
@[to_additive /-- If `g : ι → G × G` converges to the uniformity, then any `f : ι → G × G`
converges to the uniformity iff `f + g` does. This is often useful when `g` is valued in the
diagonal, in which case its convergence is automatic. -/]
Filter.Tendsto.uniformity_mul_iff_left {ι : Type*} {f g : ι → α × α} {l : Filter ι}
(hg : Tendsto g l (𝓤 α)) :
Tendsto (f * g) l (𝓤 α) ↔ Tendsto f l (𝓤 α) :=
⟨fun hfg ↦ by simpa using hfg.uniformity_mul hg.uniformity_inv, fun hf ↦ hf.uniformity_mul hg⟩
@[to_additive UniformContinuous.const_nsmul] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | Filter.Tendsto.uniformity_mul_iff_left | If `g : ι → G × G` converges to the uniformity, then any `f : ι → G × G` converges to the
uniformity iff `f * g` does. This is often useful when `g` is valued in the diagonal,
in which case its convergence is automatic. |
UniformContinuous.pow_const [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
∀ n : ℕ, UniformContinuous fun x => f x ^ n
| 0 => by
simp_rw [pow_zero]
exact uniformContinuous_const
| n + 1 => by
simp_rw [pow_succ']
exact hf.mul (hf.pow_const n)
@[to_additive uniformContinuous_const_nsmul] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | UniformContinuous.pow_const | null |
uniformContinuous_pow_const (n : ℕ) : UniformContinuous fun x : α => x ^ n :=
uniformContinuous_id.pow_const n
@[to_additive UniformContinuous.const_zsmul] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | uniformContinuous_pow_const | null |
UniformContinuous.zpow_const [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
∀ n : ℤ, UniformContinuous fun x => f x ^ n
| (n : ℕ) => by
simp_rw [zpow_natCast]
exact hf.pow_const _
| Int.negSucc n => by
simp_rw [zpow_negSucc]
exact (hf.pow_const _).inv
@[to_additive uniformContinuous_const_zsmul] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | UniformContinuous.zpow_const | null |
uniformContinuous_zpow_const (n : ℤ) : UniformContinuous fun x : α => x ^ n :=
uniformContinuous_id.zpow_const n
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | uniformContinuous_zpow_const | null |
@[to_additive]
Prod.instIsUniformGroup [UniformSpace β] [Group β] [IsUniformGroup β] :
IsUniformGroup (α × β) :=
⟨((uniformContinuous_fst.comp uniformContinuous_fst).div
(uniformContinuous_fst.comp uniformContinuous_snd)).prodMk
((uniformContinuous_snd.comp uniformContinuous_fst).div
(uniformContinuous_snd.comp uniformContinuous_snd))⟩
@[deprecated (since := "2025-03-31")] alias Prod.instUniformAddGroup :=
Prod.instIsUniformAddGroup
@[to_additive existing, deprecated
(since := "2025-03-31")] alias Prod.instUniformGroup := Prod.instIsUniformGroup
@[to_additive] | instance | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | Prod.instIsUniformGroup | null |
uniformity_translate_mul (a : α) : ((𝓤 α).map fun x : α × α => (x.1 * a, x.2 * a)) = 𝓤 α :=
le_antisymm (uniformContinuous_id.mul uniformContinuous_const)
(calc
𝓤 α =
((𝓤 α).map fun x : α × α => (x.1 * a⁻¹, x.2 * a⁻¹)).map fun x : α × α =>
(x.1 * a, x.2 * a) := by simp [Filter.map_map, Function.comp_def]
_ ≤ (𝓤 α).map fun x : α × α => (x.1 * a, x.2 * a) :=
Filter.map_mono (uniformContinuous_id.mul uniformContinuous_const)
) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | uniformity_translate_mul | null |
@[to_additive /-- An additive group homomorphism (a bundled morphism of a type that implements
`AddMonoidHomClass`) between two uniform additive groups is uniformly continuous provided that it
is continuous at zero. See also `continuous_of_continuousAt_zero`. -/]
uniformContinuous_of_continuousAt_one {hom : Type*} [UniformSpace β] [Group β]
[IsUniformGroup β] [FunLike hom α β] [MonoidHomClass hom α β]
(f : hom) (hf : ContinuousAt f 1) :
UniformContinuous f :=
uniformContinuous_of_tendsto_one (by simpa using hf.tendsto)
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | uniformContinuous_of_continuousAt_one | The discrete uniformity makes a group a `IsUniformGroup. -/
@[to_additive /-- The discrete uniformity makes an additive group a `IsUniformAddGroup`. -/]
instance [UniformSpace β] [Group β] [DiscreteUniformity β] : IsUniformGroup β where
uniformContinuous_div := DiscreteUniformity.uniformContinuous (β × β) fun p ↦ p.1 / p.2
namespace MulOpposite
@[to_additive]
instance : IsUniformGroup αᵐᵒᵖ :=
⟨uniformContinuous_op.comp
((uniformContinuous_unop.comp uniformContinuous_snd).inv.mul <|
uniformContinuous_unop.comp uniformContinuous_fst)⟩
end MulOpposite
section LatticeOps
variable [Group β]
@[to_additive]
theorem isUniformGroup_sInf {us : Set (UniformSpace β)} (h : ∀ u ∈ us, @IsUniformGroup β u _) :
@IsUniformGroup β (sInf us) _ :=
@IsUniformGroup.mk β (_) _ <|
uniformContinuous_sInf_rng.mpr fun u hu =>
uniformContinuous_sInf_dom₂ hu hu (@IsUniformGroup.uniformContinuous_div β u _ (h u hu))
@[deprecated (since := "2025-03-31")] alias uniformAddGroup_sInf := isUniformAddGroup_sInf
@[to_additive existing, deprecated
(since := "2025-03-31")] alias uniformGroup_sInf := isUniformGroup_sInf
@[to_additive]
theorem isUniformGroup_iInf {ι : Sort*} {us' : ι → UniformSpace β}
(h' : ∀ i, @IsUniformGroup β (us' i) _) : @IsUniformGroup β (⨅ i, us' i) _ := by
rw [← sInf_range]
exact isUniformGroup_sInf (Set.forall_mem_range.mpr h')
@[deprecated (since := "2025-03-31")] alias uniformAddGroup_iInf := isUniformAddGroup_iInf
@[to_additive existing, deprecated
(since := "2025-03-31")] alias uniformGroup_iInf := isUniformGroup_iInf
@[to_additive]
theorem isUniformGroup_inf {u₁ u₂ : UniformSpace β} (h₁ : @IsUniformGroup β u₁ _)
(h₂ : @IsUniformGroup β u₂ _) : @IsUniformGroup β (u₁ ⊓ u₂) _ := by
rw [inf_eq_iInf]
refine isUniformGroup_iInf fun b => ?_
cases b <;> assumption
@[deprecated (since := "2025-03-31")] alias uniformAddGroup_inf := isUniformAddGroup_inf
@[to_additive existing, deprecated
(since := "2025-03-31")] alias uniformGroup_inf := isUniformGroup_inf
end LatticeOps
section
variable (α)
@[to_additive]
theorem uniformity_eq_comap_nhds_one : 𝓤 α = comap (fun x : α × α => x.2 / x.1) (𝓝 (1 : α)) := by
refine eq_of_forall_le_iff fun 𝓕 ↦ ?_
rw [nhds_eq_comap_uniformity, comap_comap, ← tendsto_iff_comap,
← (tendsto_diag_uniformity Prod.fst 𝓕).uniformity_mul_iff_left, ← tendsto_id']
congrm Tendsto ?_ _ _
ext <;> simp
@[to_additive]
theorem uniformity_eq_comap_nhds_one_swapped :
𝓤 α = comap (fun x : α × α => x.1 / x.2) (𝓝 (1 : α)) := by
rw [← comap_swap_uniformity, uniformity_eq_comap_nhds_one, comap_comap]
rfl
@[to_additive]
theorem IsUniformGroup.ext {G : Type*} [Group G] {u v : UniformSpace G} (hu : @IsUniformGroup G u _)
(hv : @IsUniformGroup G v _)
(h : @nhds _ u.toTopologicalSpace 1 = @nhds _ v.toTopologicalSpace 1) : u = v :=
UniformSpace.ext <| by
rw [@uniformity_eq_comap_nhds_one _ u _ hu, @uniformity_eq_comap_nhds_one _ v _ hv, h]
@[deprecated (since := "2025-03-31")] alias UniformAddGroup.ext := IsUniformAddGroup.ext
@[to_additive existing UniformAddGroup.ext, deprecated (since := "2025-03-31")] alias
UniformGroup.ext := IsUniformGroup.ext
@[to_additive]
theorem IsUniformGroup.ext_iff {G : Type*} [Group G] {u v : UniformSpace G}
(hu : @IsUniformGroup G u _) (hv : @IsUniformGroup G v _) :
u = v ↔ @nhds _ u.toTopologicalSpace 1 = @nhds _ v.toTopologicalSpace 1 :=
⟨fun h => h ▸ rfl, hu.ext hv⟩
@[deprecated (since := "2025-03-31")] alias UniformAddGroup.ext_iff :=
IsUniformAddGroup.ext_iff
@[to_additive existing UniformAddGroup.ext_iff, deprecated (since := "2025-03-31")] alias
UniformGroup.ext_iff := IsUniformGroup.ext_iff
variable {α}
@[to_additive]
theorem IsUniformGroup.uniformity_countably_generated [(𝓝 (1 : α)).IsCountablyGenerated] :
(𝓤 α).IsCountablyGenerated := by
rw [uniformity_eq_comap_nhds_one]
exact Filter.comap.isCountablyGenerated _ _
@[deprecated (since := "2025-03-31")] alias UniformAddGroup.uniformity_countably_generated :=
IsUniformAddGroup.uniformity_countably_generated
@[to_additive existing UniformAddGroup.uniformity_countably_generated, deprecated
(since := "2025-03-31")] alias
UniformGroup.uniformity_countably_generated := IsUniformGroup.uniformity_countably_generated
open MulOpposite
@[to_additive]
theorem uniformity_eq_comap_inv_mul_nhds_one :
𝓤 α = comap (fun x : α × α => x.1⁻¹ * x.2) (𝓝 (1 : α)) := by
rw [← comap_uniformity_mulOpposite, uniformity_eq_comap_nhds_one, ← op_one, ← comap_unop_nhds,
comap_comap, comap_comap]
simp [Function.comp_def]
@[to_additive]
theorem uniformity_eq_comap_inv_mul_nhds_one_swapped :
𝓤 α = comap (fun x : α × α => x.2⁻¹ * x.1) (𝓝 (1 : α)) := by
rw [← comap_swap_uniformity, uniformity_eq_comap_inv_mul_nhds_one, comap_comap]
rfl
end
@[to_additive]
theorem Filter.HasBasis.uniformity_of_nhds_one {ι} {p : ι → Prop} {U : ι → Set α}
(h : (𝓝 (1 : α)).HasBasis p U) :
(𝓤 α).HasBasis p fun i => { x : α × α | x.2 / x.1 ∈ U i } := by
rw [uniformity_eq_comap_nhds_one]
exact h.comap _
@[to_additive]
theorem Filter.HasBasis.uniformity_of_nhds_one_inv_mul {ι} {p : ι → Prop} {U : ι → Set α}
(h : (𝓝 (1 : α)).HasBasis p U) :
(𝓤 α).HasBasis p fun i => { x : α × α | x.1⁻¹ * x.2 ∈ U i } := by
rw [uniformity_eq_comap_inv_mul_nhds_one]
exact h.comap _
@[to_additive]
theorem Filter.HasBasis.uniformity_of_nhds_one_swapped {ι} {p : ι → Prop} {U : ι → Set α}
(h : (𝓝 (1 : α)).HasBasis p U) :
(𝓤 α).HasBasis p fun i => { x : α × α | x.1 / x.2 ∈ U i } := by
rw [uniformity_eq_comap_nhds_one_swapped]
exact h.comap _
@[to_additive]
theorem Filter.HasBasis.uniformity_of_nhds_one_inv_mul_swapped {ι} {p : ι → Prop} {U : ι → Set α}
(h : (𝓝 (1 : α)).HasBasis p U) :
(𝓤 α).HasBasis p fun i => { x : α × α | x.2⁻¹ * x.1 ∈ U i } := by
rw [uniformity_eq_comap_inv_mul_nhds_one_swapped]
exact h.comap _
@[to_additive]
theorem uniformContinuous_of_tendsto_one {hom : Type*} [UniformSpace β] [Group β] [IsUniformGroup β]
[FunLike hom α β] [MonoidHomClass hom α β] {f : hom} (h : Tendsto f (𝓝 1) (𝓝 1)) :
UniformContinuous f := by
have :
((fun x : β × β => x.2 / x.1) ∘ fun x : α × α => (f x.1, f x.2)) = fun x : α × α =>
f (x.2 / x.1) := by ext; simp only [Function.comp_apply, map_div]
rw [UniformContinuous, uniformity_eq_comap_nhds_one α, uniformity_eq_comap_nhds_one β,
tendsto_comap_iff, this]
exact Tendsto.comp h tendsto_comap
/-- A group homomorphism (a bundled morphism of a type that implements `MonoidHomClass`) between
two uniform groups is uniformly continuous provided that it is continuous at one. See also
`continuous_of_continuousAt_one`. |
MonoidHom.uniformContinuous_of_continuousAt_one [UniformSpace β] [Group β]
[IsUniformGroup β] (f : α →* β) (hf : ContinuousAt f 1) : UniformContinuous f :=
_root_.uniformContinuous_of_continuousAt_one f hf | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | MonoidHom.uniformContinuous_of_continuousAt_one | null |
@[to_additive /-- A homomorphism from a uniform additive group to a discrete uniform additive group
is continuous if and only if its kernel is open. -/]
IsUniformGroup.uniformContinuous_iff_isOpen_ker {hom : Type*} [UniformSpace β]
[DiscreteTopology β] [Group β] [IsUniformGroup β] [FunLike hom α β] [MonoidHomClass hom α β]
{f : hom} :
UniformContinuous f ↔ IsOpen ((f : α →* β).ker : Set α) := by
refine ⟨fun hf => ?_, fun hf => ?_⟩
· apply (isOpen_discrete ({1} : Set β)).preimage hf.continuous
· apply uniformContinuous_of_continuousAt_one
rw [ContinuousAt, nhds_discrete β, map_one, tendsto_pure]
exact hf.mem_nhds (map_one f)
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | IsUniformGroup.uniformContinuous_iff_isOpen_ker | A homomorphism from a uniform group to a discrete uniform group is continuous if and only if
its kernel is open. |
uniformContinuous_monoidHom_of_continuous {hom : Type*} [UniformSpace β] [Group β]
[IsUniformGroup β] [FunLike hom α β] [MonoidHomClass hom α β] {f : hom} (h : Continuous f) :
UniformContinuous f :=
uniformContinuous_of_tendsto_one <|
suffices Tendsto f (𝓝 1) (𝓝 (f 1)) by rwa [map_one] at this
h.tendsto 1 | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | uniformContinuous_monoidHom_of_continuous | null |
@[to_additive /-- The right uniformity on a topological additive group (as opposed to the left
uniformity).
Warning: in general the right and left uniformities do not coincide and so one does not obtain a
`IsUniformAddGroup` structure. Two important special cases where they _do_ coincide are for
commutative additive groups (see `isUniformAddGroup_of_addCommGroup`) and for compact
additive groups (see `IsUniformAddGroup.of_compactSpace`). -/]
IsTopologicalGroup.toUniformSpace : UniformSpace G where
uniformity := comap (fun p : G × G => p.2 / p.1) (𝓝 1)
symm :=
have : Tendsto (fun p : G × G ↦ (p.2 / p.1)⁻¹) (comap (fun p : G × G ↦ p.2 / p.1) (𝓝 1))
(𝓝 1⁻¹) := tendsto_id.inv.comp tendsto_comap
by simpa [tendsto_comap_iff]
comp := Tendsto.le_comap fun U H ↦ by
rcases exists_nhds_one_split H with ⟨V, V_nhds, V_mul⟩
refine mem_map.2 (mem_of_superset (mem_lift' <| preimage_mem_comap V_nhds) ?_)
rintro ⟨x, y⟩ ⟨z, hz₁, hz₂⟩
simpa using V_mul _ hz₂ _ hz₁
nhds_eq_comap_uniformity _ := by simp only [comap_comap, Function.comp_def, nhds_translation_div]
attribute [local instance] IsTopologicalGroup.toUniformSpace
@[to_additive] | def | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | IsTopologicalGroup.toUniformSpace | The right uniformity on a topological group (as opposed to the left uniformity).
Warning: in general the right and left uniformities do not coincide and so one does not obtain a
`IsUniformGroup` structure. Two important special cases where they _do_ coincide are for
commutative groups (see `isUniformGroup_of_commGroup`) and for compact groups (see
`IsUniformGroup.of_compactSpace`). |
uniformity_eq_comap_nhds_one' : 𝓤 G = comap (fun p : G × G => p.2 / p.1) (𝓝 (1 : G)) :=
rfl | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | uniformity_eq_comap_nhds_one' | null |
@[to_additive]
isUniformGroup_of_commGroup : IsUniformGroup G := by
constructor
simp only [UniformContinuous, uniformity_prod_eq_prod, uniformity_eq_comap_nhds_one',
tendsto_comap_iff, tendsto_map'_iff, prod_comap_comap_eq, Function.comp_def,
div_div_div_comm _ (Prod.snd (Prod.snd _)), ← nhds_prod_eq]
exact (continuous_div'.tendsto' 1 1 (div_one 1)).comp tendsto_comap
alias comm_topologicalGroup_is_uniform := isUniformGroup_of_commGroup
@[deprecated (since := "2025-03-30")]
alias uniformAddGroup_of_addCommGroup := isUniformAddGroup_of_addCommGroup
@[to_additive existing, deprecated (since := "2025-03-30")]
alias uniformGroup_of_commGroup := isUniformGroup_of_commGroup
open Set | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | isUniformGroup_of_commGroup | null |
@[to_additive]
IsUniformGroup.toUniformSpace_eq {G : Type*} [u : UniformSpace G] [Group G]
[IsUniformGroup G] : IsTopologicalGroup.toUniformSpace G = u := by
ext : 1
rw [uniformity_eq_comap_nhds_one' G, uniformity_eq_comap_nhds_one G] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | IsUniformGroup.toUniformSpace_eq | null |
@[to_additive]
tendsto_div_comap_self (de : IsDenseInducing e) (x₀ : α) :
Tendsto (fun t : β × β => t.2 / t.1) ((comap fun p : β × β => (e p.1, e p.2)) <| 𝓝 (x₀, x₀))
(𝓝 1) := by
have comm : ((fun x : α × α => x.2 / x.1) ∘ fun t : β × β => (e t.1, e t.2)) =
e ∘ fun t : β × β => t.2 / t.1 := by
ext t
simp
have lim : Tendsto (fun x : α × α => x.2 / x.1) (𝓝 (x₀, x₀)) (𝓝 (e 1)) := by
simpa using (continuous_div'.comp (@continuous_swap α α _ _)).tendsto (x₀, x₀)
simpa using de.tendsto_comap_nhds_nhds lim comm | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | tendsto_div_comap_self | null |
private extend_Z_bilin_aux (x₀ : α) (y₁ : δ) : ∃ U₂ ∈ comap e (𝓝 x₀), ∀ x ∈ U₂, ∀ x' ∈ U₂,
(fun p : β × δ => φ p.1 p.2) (x' - x, y₁) ∈ W' := by
let Nx := 𝓝 x₀
let ee := fun u : β × β => (e u.1, e u.2)
have lim1 : Tendsto (fun a : β × β => (a.2 - a.1, y₁))
(comap e Nx ×ˢ comap e Nx) (𝓝 (0, y₁)) := by
have := (tendsto_sub_comap_self de x₀).prodMk
(tendsto_const_nhds : Tendsto (fun _ : β × β => y₁) (comap ee <| 𝓝 (x₀, x₀)) (𝓝 y₁))
rw [nhds_prod_eq, prod_comap_comap_eq, ← nhds_prod_eq]
exact (this :)
have lim2 : Tendsto (fun p : β × δ => φ p.1 p.2) (𝓝 (0, y₁)) (𝓝 0) := by
simpa using hφ.tendsto (0, y₁)
have lim := lim2.comp lim1
rw [tendsto_prod_self_iff] at lim
simp_rw [forall_mem_comm]
exact lim W' W'_nhds
variable [IsUniformAddGroup G]
include df W'_nhds in | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | extend_Z_bilin_aux | null |
private extend_Z_bilin_key (x₀ : α) (y₀ : γ) : ∃ U ∈ comap e (𝓝 x₀), ∃ V ∈ comap f (𝓝 y₀),
∀ x ∈ U, ∀ x' ∈ U, ∀ (y) (_ : y ∈ V) (y') (_ : y' ∈ V),
(fun p : β × δ => φ p.1 p.2) (x', y') - (fun p : β × δ => φ p.1 p.2) (x, y) ∈ W' := by
let ee := fun u : β × β => (e u.1, e u.2)
let ff := fun u : δ × δ => (f u.1, f u.2)
have lim_φ : Filter.Tendsto (fun p : β × δ => φ p.1 p.2) (𝓝 (0, 0)) (𝓝 0) := by
simpa using hφ.tendsto (0, 0)
have lim_φ_sub_sub :
Tendsto (fun p : (β × β) × δ × δ => (fun p : β × δ => φ p.1 p.2) (p.1.2 - p.1.1, p.2.2 - p.2.1))
((comap ee <| 𝓝 (x₀, x₀)) ×ˢ (comap ff <| 𝓝 (y₀, y₀))) (𝓝 0) := by
have lim_sub_sub :
Tendsto (fun p : (β × β) × δ × δ => (p.1.2 - p.1.1, p.2.2 - p.2.1))
(comap ee (𝓝 (x₀, x₀)) ×ˢ comap ff (𝓝 (y₀, y₀))) (𝓝 0 ×ˢ 𝓝 0) := by
have := Filter.prod_mono (tendsto_sub_comap_self de x₀) (tendsto_sub_comap_self df y₀)
rwa [prod_map_map_eq] at this
rw [← nhds_prod_eq] at lim_sub_sub
exact Tendsto.comp lim_φ lim_sub_sub
rcases exists_nhds_zero_quarter W'_nhds with ⟨W, W_nhds, W4⟩
have :
∃ U₁ ∈ comap e (𝓝 x₀), ∃ V₁ ∈ comap f (𝓝 y₀), ∀ (x) (_ : x ∈ U₁) (x') (_ : x' ∈ U₁),
∀ (y) (_ : y ∈ V₁) (y') (_ : y' ∈ V₁), (fun p : β × δ => φ p.1 p.2) (x' - x, y' - y) ∈ W := by
rcases tendsto_prod_iff.1 lim_φ_sub_sub W W_nhds with ⟨U, U_in, V, V_in, H⟩
rw [nhds_prod_eq, ← prod_comap_comap_eq, mem_prod_same_iff] at U_in V_in
rcases U_in with ⟨U₁, U₁_in, HU₁⟩
rcases V_in with ⟨V₁, V₁_in, HV₁⟩
exists U₁, U₁_in, V₁, V₁_in
intro x x_in x' x'_in y y_in y' y'_in
exact H _ _ (HU₁ (mk_mem_prod x_in x'_in)) (HV₁ (mk_mem_prod y_in y'_in))
rcases this with ⟨U₁, U₁_nhds, V₁, V₁_nhds, H⟩
obtain ⟨x₁, x₁_in⟩ : U₁.Nonempty := (de.comap_nhds_neBot _).nonempty_of_mem U₁_nhds
obtain ⟨y₁, y₁_in⟩ : V₁.Nonempty := (df.comap_nhds_neBot _).nonempty_of_mem V₁_nhds
have cont_flip : Continuous fun p : δ × β => φ.flip p.1 p.2 := by
change Continuous ((fun p : β × δ => φ p.1 p.2) ∘ Prod.swap)
exact hφ.comp continuous_swap
rcases extend_Z_bilin_aux de hφ W_nhds x₀ y₁ with ⟨U₂, U₂_nhds, HU⟩
rcases extend_Z_bilin_aux df cont_flip W_nhds y₀ x₁ with ⟨V₂, V₂_nhds, HV⟩
exists U₁ ∩ U₂, inter_mem U₁_nhds U₂_nhds, V₁ ∩ V₂, inter_mem V₁_nhds V₂_nhds
rintro x ⟨xU₁, xU₂⟩ x' ⟨x'U₁, x'U₂⟩ y ⟨yV₁, yV₂⟩ y' ⟨y'V₁, y'V₂⟩
have key_formula : φ x' y' - φ x y
= φ (x' - x) y₁ + φ (x' - x) (y' - y₁) + φ x₁ (y' - y) + φ (x - x₁) (y' - y) := by simp; abel
rw [key_formula]
have h₁ := HU x xU₂ x' x'U₂
have h₂ := H x xU₁ x' x'U₁ y₁ y₁_in y' y'V₁
have h₃ := HV y yV₂ y' y'V₂
have h₄ := H x₁ x₁_in x xU₁ y yV₁ y' y'V₁
exact W4 h₁ h₂ h₃ h₄ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.DiscreteUniformity",
"Mathlib.Topology.Algebra.Group.Basic"
] | Mathlib/Topology/Algebra/IsUniformGroup/Defs.lean | extend_Z_bilin_key | null |
TendstoUniformlyOn.eventually_forall_lt {u v : β} (huv : u < v)
(hf : TendstoUniformlyOn f g p K) (hg : ∀ x ∈ K, g x ≤ u) :
∀ᶠ i in p, ∀ x ∈ K, f i x < v := by
simp only [tendstoUniformlyOn_iff_tendsto, uniformity_eq_comap_neg_add_nhds_zero,
tendsto_iff_eventually, eventually_comap, Prod.forall] at *
conv at hf => enter [2]; rw [eventually_iff_exists_mem]
have hf2 := hf (fun x ↦ -x.1 + x.2 < -u + v) ⟨_, (isOpen_gt' (-u + v)).mem_nhds (by simp [huv]),
fun y hy a b hab ↦ (hab.symm ▸ hy :)⟩
filter_upwards [eventually_prod_principal_iff.mp hf2] with i hi x hx
simpa using add_lt_add_of_le_of_lt (hg x hx) (hi x hx) | lemma | Topology | [
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology.Order.Basic",
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/Algebra/IsUniformGroup/Order.lean | TendstoUniformlyOn.eventually_forall_lt | If a sequence of functions converges uniformly on a set to a function `g` which is bounded above
by a value `u`, then the sequence is strictly bounded by any `v` such that `u < v`. |
TendstoUniformlyOn.eventually_forall_le {u v : β} (huv : u < v)
(hf : TendstoUniformlyOn f g p K) (hg : ∀ x ∈ K, g x ≤ u) :
∀ᶠ i in p, ∀ x ∈ K, f i x ≤ v := by
filter_upwards [hf.eventually_forall_lt huv hg] with i hi x hx using (hi x hx).le | lemma | Topology | [
"Mathlib.Topology.Algebra.IsUniformGroup.Defs",
"Mathlib.Topology.Order.Basic",
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/Algebra/IsUniformGroup/Order.lean | TendstoUniformlyOn.eventually_forall_le | null |
LipschitzWith.cauchySeq_comp {f : α → β} (hf : LipschitzWith K f) {u : ℕ → α}
(hu : CauchySeq u) :
CauchySeq (f ∘ u) := by
rcases cauchySeq_iff_le_tendsto_0.1 hu with ⟨b, b_nonneg, hb, blim⟩
refine cauchySeq_iff_le_tendsto_0.2 ⟨fun n ↦ K * b n, ?_, ?_, ?_⟩
· exact fun n ↦ mul_nonneg (by positivity) (b_nonneg n)
· exact fun n m N hn hm ↦ hf.dist_le_mul_of_le (hb n m N hn hm)
· rw [← mul_zero (K : ℝ)]
exact blim.const_mul _ | lemma | Topology | [
"Mathlib.Topology.Algebra.Order.Field",
"Mathlib.Topology.MetricSpace.Lipschitz"
] | Mathlib/Topology/Algebra/MetricSpace/Lipschitz.lean | LipschitzWith.cauchySeq_comp | null |
LipschitzOnWith.cauchySeq_comp {s : Set α} {f : α → β} (hf : LipschitzOnWith K f s)
{u : ℕ → α} (hu : CauchySeq u) (h'u : range u ⊆ s) :
CauchySeq (f ∘ u) := by
rcases cauchySeq_iff_le_tendsto_0.1 hu with ⟨b, b_nonneg, hb, blim⟩
refine cauchySeq_iff_le_tendsto_0.2 ⟨fun n ↦ K * b n, ?_, ?_, ?_⟩
· exact fun n ↦ mul_nonneg (by positivity) (b_nonneg n)
· intro n m N hn hm
have A n : u n ∈ s := h'u (mem_range_self _)
apply (hf.dist_le_mul _ (A n) _ (A m)).trans
exact mul_le_mul_of_nonneg_left (hb n m N hn hm) K.2
· rw [← mul_zero (K : ℝ)]
exact blim.const_mul _ | lemma | Topology | [
"Mathlib.Topology.Algebra.Order.Field",
"Mathlib.Topology.MetricSpace.Lipschitz"
] | Mathlib/Topology/Algebra/MetricSpace/Lipschitz.lean | LipschitzOnWith.cauchySeq_comp | null |
continuousAt_of_locally_lipschitz {f : α → β} {x : α} {r : ℝ} (hr : 0 < r) (K : ℝ)
(h : ∀ y, dist y x < r → dist (f y) (f x) ≤ K * dist y x) : ContinuousAt f x := by
refine tendsto_iff_dist_tendsto_zero.2 (squeeze_zero' (Eventually.of_forall fun _ => dist_nonneg)
(mem_of_superset (ball_mem_nhds _ hr) h) ?_)
refine (continuous_const.mul (continuous_id.dist continuous_const)).tendsto' _ _ ?_
simp | theorem | Topology | [
"Mathlib.Topology.Algebra.Order.Field",
"Mathlib.Topology.MetricSpace.Lipschitz"
] | Mathlib/Topology/Algebra/MetricSpace/Lipschitz.lean | continuousAt_of_locally_lipschitz | If a function is locally Lipschitz around a point, then it is continuous at this point. |
ContinuousSMul.of_nhds_zero [IsTopologicalRing R] [IsTopologicalAddGroup M]
(hmul : Tendsto (fun p : R × M => p.1 • p.2) (𝓝 0 ×ˢ 𝓝 0) (𝓝 0))
(hmulleft : ∀ m : M, Tendsto (fun a : R => a • m) (𝓝 0) (𝓝 0))
(hmulright : ∀ a : R, Tendsto (fun m : M => a • m) (𝓝 0) (𝓝 0)) : ContinuousSMul R M where
continuous_smul := by
rw [← nhds_prod_eq] at hmul
refine continuous_of_continuousAt_zero₂ (AddMonoidHom.smul : R →+ M →+ M) ?_ ?_ ?_ <;>
simpa [ContinuousAt]
variable (R M) in
omit [TopologicalSpace R] in | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | ContinuousSMul.of_nhds_zero | null |
ContinuousNeg.of_continuousConstSMul [ContinuousConstSMul R M] : ContinuousNeg M where
continuous_neg := by simpa using continuous_const_smul (T := M) (-1 : R) | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | ContinuousNeg.of_continuousConstSMul | A topological module over a ring has continuous negation.
This cannot be an instance, because it would cause search for `[Module ?R M]` with unknown `R`. |
Submodule.eq_top_of_nonempty_interior' [NeBot (𝓝[{ x : R | IsUnit x }] 0)]
(s : Submodule R M) (hs : (interior (s : Set M)).Nonempty) : s = ⊤ := by
rcases hs with ⟨y, hy⟩
refine Submodule.eq_top_iff'.2 fun x => ?_
rw [mem_interior_iff_mem_nhds] at hy
have : Tendsto (fun c : R => y + c • x) (𝓝[{ x : R | IsUnit x }] 0) (𝓝 (y + (0 : R) • x)) :=
tendsto_const_nhds.add ((tendsto_nhdsWithin_of_tendsto_nhds tendsto_id).smul tendsto_const_nhds)
rw [zero_smul, add_zero] at this
obtain ⟨_, hu : y + _ • _ ∈ s, u, rfl⟩ :=
nonempty_of_mem (inter_mem (Filter.mem_map.1 (this hy)) self_mem_nhdsWithin)
have hy' : y ∈ ↑s := mem_of_mem_nhds hy
rwa [s.add_mem_iff_right hy', ← Units.smul_def, s.smul_mem_iff' u] at hu
variable (R M) | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.eq_top_of_nonempty_interior' | If `M` is a topological module over `R` and `0` is a limit of invertible elements of `R`, then
`⊤` is the only submodule of `M` with a nonempty interior.
This is the case, e.g., if `R` is a nontrivially normed field. |
Module.punctured_nhds_neBot [Nontrivial M] [NeBot (𝓝[≠] (0 : R))] [NoZeroSMulDivisors R M]
(x : M) : NeBot (𝓝[≠] x) := by
rcases exists_ne (0 : M) with ⟨y, hy⟩
suffices Tendsto (fun c : R => x + c • y) (𝓝[≠] 0) (𝓝[≠] x) from this.neBot
refine Tendsto.inf ?_ (tendsto_principal_principal.2 <| ?_)
· convert tendsto_const_nhds.add ((@tendsto_id R _).smul_const y)
rw [zero_smul, add_zero]
· intro c hc
simpa [hy] using hc | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Module.punctured_nhds_neBot | Let `R` be a topological ring such that zero is not an isolated point (e.g., a nontrivially
normed field, see `NormedField.punctured_nhds_neBot`). Let `M` be a nontrivial module over `R`
such that `c • x = 0` implies `c = 0 ∨ x = 0`. Then `M` has no isolated points. We formulate this
using `NeBot (𝓝[≠] x)`.
This lemma is not an instance because Lean would need to find `[ContinuousSMul ?m_1 M]` with
unknown `?m_1`. We register this as an instance for `R = ℝ` in `Real.punctured_nhds_module_neBot`.
One can also use `haveI := Module.punctured_nhds_neBot R M` in a proof. |
continuousSMul_induced : @ContinuousSMul R M₁ _ u (t.induced f) :=
let _ : TopologicalSpace M₁ := t.induced f
IsInducing.continuousSMul ⟨rfl⟩ continuous_id (map_smul f _ _) | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | continuousSMul_induced | null |
TopologicalSpace.IsSeparable.span {R M : Type*} [AddCommMonoid M] [Semiring R] [Module R M]
[TopologicalSpace M] [TopologicalSpace R] [SeparableSpace R]
[ContinuousAdd M] [ContinuousSMul R M] {s : Set M} (hs : IsSeparable s) :
IsSeparable (Submodule.span R s : Set M) := by
rw [Submodule.span_eq_iUnion_nat]
refine .iUnion fun n ↦ .image ?_ ?_
· have : IsSeparable {f : Fin n → R × M | ∀ (i : Fin n), f i ∈ Set.univ ×ˢ s} := by
apply isSeparable_pi (fun i ↦ .prod (.of_separableSpace Set.univ) hs)
rwa [Set.univ_prod] at this
· apply continuous_finset_sum _ (fun i _ ↦ ?_)
exact (continuous_fst.comp (continuous_apply i)).smul (continuous_snd.comp (continuous_apply i)) | lemma | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | TopologicalSpace.IsSeparable.span | The span of a separable subset with respect to a separable scalar ring is again separable. |
topologicalAddGroup {R M : Type*} [Ring R] [AddCommGroup M] [Module R M]
[TopologicalSpace M] [IsTopologicalAddGroup M] (S : Submodule R M) : IsTopologicalAddGroup S :=
inferInstanceAs (IsTopologicalAddGroup S.toAddSubgroup) | instance | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | topologicalAddGroup | null |
Submodule.mapsTo_smul_closure (s : Submodule R M) (c : R) :
Set.MapsTo (c • ·) (closure s : Set M) (closure s) :=
have : Set.MapsTo (c • ·) (s : Set M) s := fun _ h ↦ s.smul_mem c h
this.closure (continuous_const_smul c) | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.mapsTo_smul_closure | null |
Submodule.smul_closure_subset (s : Submodule R M) (c : R) :
c • closure (s : Set M) ⊆ closure (s : Set M) :=
(s.mapsTo_smul_closure c).image_subset
variable [ContinuousAdd M] | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.smul_closure_subset | null |
Submodule.topologicalClosure (s : Submodule R M) : Submodule R M :=
{ s.toAddSubmonoid.topologicalClosure with
smul_mem' := s.mapsTo_smul_closure }
@[simp, norm_cast] | def | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.topologicalClosure | The (topological-space) closure of a submodule of a topological `R`-module `M` is itself
a submodule. |
Submodule.topologicalClosure_coe (s : Submodule R M) :
(s.topologicalClosure : Set M) = closure (s : Set M) :=
rfl | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.topologicalClosure_coe | null |
Submodule.le_topologicalClosure (s : Submodule R M) : s ≤ s.topologicalClosure :=
subset_closure | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.le_topologicalClosure | null |
Submodule.closure_subset_topologicalClosure_span (s : Set M) :
closure s ⊆ (span R s).topologicalClosure := by
rw [Submodule.topologicalClosure_coe]
exact closure_mono subset_span | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.closure_subset_topologicalClosure_span | null |
Submodule.isClosed_topologicalClosure (s : Submodule R M) :
IsClosed (s.topologicalClosure : Set M) := isClosed_closure | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.isClosed_topologicalClosure | null |
Submodule.topologicalClosure_minimal (s : Submodule R M) {t : Submodule R M} (h : s ≤ t)
(ht : IsClosed (t : Set M)) : s.topologicalClosure ≤ t :=
closure_minimal h ht | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.topologicalClosure_minimal | null |
Submodule.topologicalClosure_mono {s : Submodule R M} {t : Submodule R M} (h : s ≤ t) :
s.topologicalClosure ≤ t.topologicalClosure :=
closure_mono h | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.topologicalClosure_mono | null |
IsClosed.submodule_topologicalClosure_eq {s : Submodule R M} (hs : IsClosed (s : Set M)) :
s.topologicalClosure = s :=
SetLike.ext' hs.closure_eq | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | IsClosed.submodule_topologicalClosure_eq | The topological closure of a closed submodule `s` is equal to `s`. |
Submodule.dense_iff_topologicalClosure_eq_top {s : Submodule R M} :
Dense (s : Set M) ↔ s.topologicalClosure = ⊤ := by
rw [← SetLike.coe_set_eq, dense_iff_closure_eq]
simp | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.dense_iff_topologicalClosure_eq_top | A subspace is dense iff its topological closure is the entire space. |
Submodule.topologicalClosure.completeSpace {M' : Type*} [AddCommMonoid M'] [Module R M']
[UniformSpace M'] [ContinuousAdd M'] [ContinuousConstSMul R M'] [CompleteSpace M']
(U : Submodule R M') : CompleteSpace U.topologicalClosure :=
isClosed_closure.completeSpace_coe | instance | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.topologicalClosure.completeSpace | null |
Submodule.isClosed_or_dense_of_isCoatom (s : Submodule R M) (hs : IsCoatom s) :
IsClosed (s : Set M) ∨ Dense (s : Set M) := by
refine (hs.le_iff.mp s.le_topologicalClosure).symm.imp ?_ dense_iff_topologicalClosure_eq_top.mpr
exact fun h ↦ h ▸ isClosed_closure | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | Submodule.isClosed_or_dense_of_isCoatom | A maximal proper subspace of a topological module (i.e a `Submodule` satisfying `IsCoatom`)
is either closed or dense. |
closure_coe_iSup_map_single (s : ∀ i, Submodule R (M i)) :
closure (↑(⨆ i, (s i).map (LinearMap.single R M i)) : Set (∀ i, M i)) =
Set.univ.pi fun i ↦ closure (s i) := by
rw [← closure_pi_set]
refine (closure_mono ?_).antisymm <| closure_minimal ?_ isClosed_closure
· exact SetLike.coe_mono <| iSup_map_single_le
· simp only [Set.subset_def, mem_closure_iff]
intro x hx U hU hxU
rcases isOpen_pi_iff.mp hU x hxU with ⟨t, V, hV, hVU⟩
refine ⟨∑ i ∈ t, Pi.single i (x i), hVU ?_, ?_⟩
· simp_all [Finset.sum_pi_single]
· exact sum_mem fun i hi ↦ mem_iSup_of_mem i <| mem_map_of_mem <| hx _ <| Set.mem_univ _ | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | closure_coe_iSup_map_single | If `s i` is a family of submodules, each is in its module,
then the closure of their span in the indexed product of the modules
is the product of their closures.
In case of a finite index type, this statement immediately follows from `Submodule.iSup_map_single`.
However, the statement is true for an infinite index type as well. |
topologicalClosure_iSup_map_single [∀ i, ContinuousAdd (M i)]
[∀ i, ContinuousConstSMul R (M i)] (s : ∀ i, Submodule R (M i)) :
topologicalClosure (⨆ i, (s i).map (LinearMap.single R M i)) =
pi Set.univ fun i ↦ (s i).topologicalClosure :=
SetLike.coe_injective <| closure_coe_iSup_map_single _ | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | topologicalClosure_iSup_map_single | If `s i` is a family of submodules, each is in its module,
then the closure of their span in the indexed product of the modules
is the product of their closures.
In case of a finite index type, this statement immediately follows from `Submodule.iSup_map_single`.
However, the statement is true for an infinite index type as well.
This version is stated in terms of `Submodule.topologicalClosure`,
thus assumes that `M i`s are topological modules over `R`.
However, the statement is true without assuming continuity of the operations,
see `Submodule.closure_coe_iSup_map_single` above. |
LinearMap.continuous_on_pi {ι : Type*} {R : Type*} {M : Type*} [Finite ι] [Semiring R]
[TopologicalSpace R] [AddCommMonoid M] [Module R M] [TopologicalSpace M] [ContinuousAdd M]
[ContinuousSMul R M] (f : (ι → R) →ₗ[R] M) : Continuous f := by
cases nonempty_fintype ι
classical
have : (f : (ι → R) → M) = fun x => ∑ i : ι, x i • f fun j => if i = j then 1 else 0 := by
ext x
exact f.pi_apply_eq_sum_univ x
rw [this]
refine continuous_finset_sum _ fun i _ => ?_
exact (continuous_apply i).smul continuous_const | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | LinearMap.continuous_on_pi | null |
@[simps -fullyApplied]
linearMapOfMemClosureRangeCoe (f : M₁ → M₂)
(hf : f ∈ closure (Set.range ((↑) : (M₁ →ₛₗ[σ] M₂) → M₁ → M₂))) : M₁ →ₛₗ[σ] M₂ :=
{ addMonoidHomOfMemClosureRangeCoe f hf with
map_smul' := (isClosed_setOf_map_smul M₁ M₂ σ).closure_subset_iff.2
(Set.range_subset_iff.2 LinearMap.map_smulₛₗ) hf } | def | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | linearMapOfMemClosureRangeCoe | Constructs a bundled linear map from a function and a proof that this function belongs to the
closure of the set of linear maps. |
@[simps! -fullyApplied]
linearMapOfTendsto (f : M₁ → M₂) (g : α → M₁ →ₛₗ[σ] M₂) [l.NeBot]
(h : Tendsto (fun a x => g a x) l (𝓝 f)) : M₁ →ₛₗ[σ] M₂ :=
linearMapOfMemClosureRangeCoe f <|
mem_closure_of_tendsto h <| Eventually.of_forall fun _ => Set.mem_range_self _
variable (M₁ M₂ σ) | def | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | linearMapOfTendsto | Construct a bundled linear map from a pointwise limit of linear maps |
LinearMap.isClosed_range_coe : IsClosed (Set.range ((↑) : (M₁ →ₛₗ[σ] M₂) → M₁ → M₂)) :=
isClosed_of_closure_subset fun f hf => ⟨linearMapOfMemClosureRangeCoe f hf, rfl⟩ | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | LinearMap.isClosed_range_coe | null |
_root_.QuotientModule.Quotient.topologicalSpace : TopologicalSpace (M ⧸ S) :=
inferInstanceAs (TopologicalSpace (Quotient S.quotientRel)) | instance | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | _root_.QuotientModule.Quotient.topologicalSpace | null |
isOpenMap_mkQ [ContinuousAdd M] : IsOpenMap S.mkQ :=
QuotientAddGroup.isOpenMap_coe | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | isOpenMap_mkQ | null |
isOpenQuotientMap_mkQ [ContinuousAdd M] : IsOpenQuotientMap S.mkQ :=
QuotientAddGroup.isOpenQuotientMap_mk | theorem | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | isOpenQuotientMap_mkQ | null |
topologicalAddGroup_quotient [IsTopologicalAddGroup M] : IsTopologicalAddGroup (M ⧸ S) :=
inferInstanceAs <| IsTopologicalAddGroup (M ⧸ S.toAddSubgroup) | instance | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | topologicalAddGroup_quotient | null |
continuousSMul_quotient [TopologicalSpace R] [IsTopologicalAddGroup M]
[ContinuousSMul R M] : ContinuousSMul R (M ⧸ S) where
continuous_smul := by
rw [← (IsOpenQuotientMap.id.prodMap S.isOpenQuotientMap_mkQ).continuous_comp_iff]
exact continuous_quot_mk.comp continuous_smul | instance | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | continuousSMul_quotient | null |
t3_quotient_of_isClosed [IsTopologicalAddGroup M] [IsClosed (S : Set M)] :
T3Space (M ⧸ S) :=
letI : IsClosed (S.toAddSubgroup : Set M) := ‹_›
QuotientAddGroup.instT3Space S.toAddSubgroup | instance | Topology | [
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Topology.Algebra.Group.Quotient",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/Topology/Algebra/Module/Basic.lean | t3_quotient_of_isClosed | null |
continuum_le_cardinal_of_nontriviallyNormedField
(𝕜 : Type*) [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] : 𝔠 ≤ #𝕜 := by
suffices ∃ f : (ℕ → Bool) → 𝕜, range f ⊆ univ ∧ Continuous f ∧ Injective f by
rcases this with ⟨f, -, -, f_inj⟩
simpa using lift_mk_le_lift_mk_of_injective f_inj
apply Perfect.exists_nat_bool_injection _ univ_nonempty
refine ⟨isClosed_univ, preperfect_iff_nhds.2 (fun x _ U hU ↦ ?_)⟩
rcases NormedField.exists_norm_lt_one 𝕜 with ⟨c, c_pos, hc⟩
have A : Tendsto (fun n ↦ x + c^n) atTop (𝓝 (x + 0)) :=
tendsto_const_nhds.add (tendsto_pow_atTop_nhds_zero_of_norm_lt_one hc)
rw [add_zero] at A
have B : ∀ᶠ n in atTop, x + c^n ∈ U := tendsto_def.1 A U hU
rcases B.exists with ⟨n, hn⟩
refine ⟨x + c^n, by simpa using hn, ?_⟩
simp only [add_ne_left]
apply pow_ne_zero
simpa using c_pos | theorem | Topology | [
"Mathlib.Algebra.Module.Card",
"Mathlib.Analysis.SpecificLimits.Normed",
"Mathlib.SetTheory.Cardinal.Continuum",
"Mathlib.SetTheory.Cardinal.CountableCover",
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.Topology.MetricSpace.Perfect"
] | Mathlib/Topology/Algebra/Module/Cardinality.lean | continuum_le_cardinal_of_nontriviallyNormedField | A complete nontrivially normed field has cardinality at least continuum. |
continuum_le_cardinal_of_module
(𝕜 : Type u) (E : Type v) [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜]
[AddCommGroup E] [Module 𝕜 E] [Nontrivial E] : 𝔠 ≤ #E := by
have A : lift.{v} (𝔠 : Cardinal.{u}) ≤ lift.{v} (#𝕜) := by
simpa using continuum_le_cardinal_of_nontriviallyNormedField 𝕜
simpa using A.trans (Cardinal.mk_le_of_module 𝕜 E) | theorem | Topology | [
"Mathlib.Algebra.Module.Card",
"Mathlib.Analysis.SpecificLimits.Normed",
"Mathlib.SetTheory.Cardinal.Continuum",
"Mathlib.SetTheory.Cardinal.CountableCover",
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.Topology.MetricSpace.Perfect"
] | Mathlib/Topology/Algebra/Module/Cardinality.lean | continuum_le_cardinal_of_module | A nontrivial module over a complete nontrivially normed field has cardinality at least
continuum. |
cardinal_eq_of_mem_nhds_zero
{E : Type*} (𝕜 : Type*) [NontriviallyNormedField 𝕜] [Zero E] [MulActionWithZero 𝕜 E]
[TopologicalSpace E] [ContinuousSMul 𝕜 E] {s : Set E} (hs : s ∈ 𝓝 (0 : E)) : #s = #E := by
/- As `s` is a neighborhood of `0`, the space is covered by the rescaled sets `c^n • s`,
where `c` is any element of `𝕜` with norm `> 1`. All these sets are in bijection and have
therefore the same cardinality. The conclusion follows. -/
obtain ⟨c, hc⟩ : ∃ x : 𝕜, 1 < ‖x‖ := NormedField.exists_lt_norm 𝕜 1
have cn_ne : ∀ n, c^n ≠ 0 := by
intro n
apply pow_ne_zero
rintro rfl
simp only [norm_zero] at hc
exact lt_irrefl _ (hc.trans zero_lt_one)
have A : ∀ (x : E), ∀ᶠ n in (atTop : Filter ℕ), x ∈ c^n • s := by
intro x
have : Tendsto (fun n ↦ (c^n) ⁻¹ • x) atTop (𝓝 ((0 : 𝕜) • x)) := by
have : Tendsto (fun n ↦ (c^n)⁻¹) atTop (𝓝 0) := by
simp_rw [← inv_pow]
apply tendsto_pow_atTop_nhds_zero_of_norm_lt_one
rw [norm_inv]
exact inv_lt_one_of_one_lt₀ hc
exact Tendsto.smul_const this x
rw [zero_smul] at this
filter_upwards [this hs] with n (hn : (c ^ n)⁻¹ • x ∈ s)
exact (mem_smul_set_iff_inv_smul_mem₀ (cn_ne n) _ _).2 hn
have B : ∀ n, #(c^n • s :) = #s := by
intro n
have : (c^n • s :) ≃ s :=
{ toFun := fun x ↦ ⟨(c^n)⁻¹ • x.1, (mem_smul_set_iff_inv_smul_mem₀ (cn_ne n) _ _).1 x.2⟩
invFun := fun x ↦ ⟨(c^n) • x.1, smul_mem_smul_set x.2⟩
left_inv := fun x ↦ by simp [smul_smul, mul_inv_cancel₀ (cn_ne n)]
right_inv := fun x ↦ by simp [smul_smul, inv_mul_cancel₀ (cn_ne n)] }
exact Cardinal.mk_congr this
apply (Cardinal.mk_of_countable_eventually_mem A B).symm | lemma | Topology | [
"Mathlib.Algebra.Module.Card",
"Mathlib.Analysis.SpecificLimits.Normed",
"Mathlib.SetTheory.Cardinal.Continuum",
"Mathlib.SetTheory.Cardinal.CountableCover",
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.Topology.MetricSpace.Perfect"
] | Mathlib/Topology/Algebra/Module/Cardinality.lean | cardinal_eq_of_mem_nhds_zero | In a topological vector space over a nontrivially normed field, any neighborhood of zero has
the same cardinality as the whole space.
See also `cardinal_eq_of_mem_nhds`. |
cardinal_eq_of_mem_nhds
{E : Type*} (𝕜 : Type*) [NontriviallyNormedField 𝕜] [AddGroup E] [MulActionWithZero 𝕜 E]
[TopologicalSpace E] [ContinuousAdd E] [ContinuousSMul 𝕜 E]
{s : Set E} {x : E} (hs : s ∈ 𝓝 x) : #s = #E := by
let g := Homeomorph.addLeft x
let t := g ⁻¹' s
have : t ∈ 𝓝 0 := g.continuous.continuousAt.preimage_mem_nhds (by simpa [g] using hs)
have A : #t = #E := cardinal_eq_of_mem_nhds_zero 𝕜 this
have B : #t = #s := Cardinal.mk_subtype_of_equiv s g.toEquiv
rwa [B] at A | theorem | Topology | [
"Mathlib.Algebra.Module.Card",
"Mathlib.Analysis.SpecificLimits.Normed",
"Mathlib.SetTheory.Cardinal.Continuum",
"Mathlib.SetTheory.Cardinal.CountableCover",
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.Topology.MetricSpace.Perfect"
] | Mathlib/Topology/Algebra/Module/Cardinality.lean | cardinal_eq_of_mem_nhds | In a topological vector space over a nontrivially normed field, any neighborhood of a point has
the same cardinality as the whole space. |
cardinal_eq_of_isOpen
{E : Type*} (𝕜 : Type*) [NontriviallyNormedField 𝕜] [AddGroup E] [MulActionWithZero 𝕜 E]
[TopologicalSpace E] [ContinuousAdd E] [ContinuousSMul 𝕜 E] {s : Set E}
(hs : IsOpen s) (h's : s.Nonempty) : #s = #E := by
rcases h's with ⟨x, hx⟩
exact cardinal_eq_of_mem_nhds 𝕜 (hs.mem_nhds hx) | theorem | Topology | [
"Mathlib.Algebra.Module.Card",
"Mathlib.Analysis.SpecificLimits.Normed",
"Mathlib.SetTheory.Cardinal.Continuum",
"Mathlib.SetTheory.Cardinal.CountableCover",
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.Topology.MetricSpace.Perfect"
] | Mathlib/Topology/Algebra/Module/Cardinality.lean | cardinal_eq_of_isOpen | In a topological vector space over a nontrivially normed field, any nonempty open set has
the same cardinality as the whole space. |
continuum_le_cardinal_of_isOpen
{E : Type*} (𝕜 : Type*) [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [AddCommGroup E]
[Module 𝕜 E] [Nontrivial E] [TopologicalSpace E] [ContinuousAdd E] [ContinuousSMul 𝕜 E]
{s : Set E} (hs : IsOpen s) (h's : s.Nonempty) : 𝔠 ≤ #s := by
simpa [cardinal_eq_of_isOpen 𝕜 hs h's] using continuum_le_cardinal_of_module 𝕜 E | theorem | Topology | [
"Mathlib.Algebra.Module.Card",
"Mathlib.Analysis.SpecificLimits.Normed",
"Mathlib.SetTheory.Cardinal.Continuum",
"Mathlib.SetTheory.Cardinal.CountableCover",
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.Topology.MetricSpace.Perfect"
] | Mathlib/Topology/Algebra/Module/Cardinality.lean | continuum_le_cardinal_of_isOpen | In a nontrivial topological vector space over a complete nontrivially normed field, any nonempty
open set has cardinality at least continuum. |
Set.Countable.dense_compl
{E : Type u} (𝕜 : Type*) [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [AddCommGroup E]
[Module 𝕜 E] [Nontrivial E] [TopologicalSpace E] [ContinuousAdd E] [ContinuousSMul 𝕜 E]
{s : Set E} (hs : s.Countable) : Dense sᶜ := by
rw [← interior_eq_empty_iff_dense_compl]
by_contra H
apply lt_irrefl (ℵ₀ : Cardinal.{u})
calc
(ℵ₀ : Cardinal.{u}) < 𝔠 := aleph0_lt_continuum
_ ≤ #(interior s) :=
continuum_le_cardinal_of_isOpen 𝕜 isOpen_interior (notMem_singleton_empty.1 H)
_ ≤ #s := mk_le_mk_of_subset interior_subset
_ ≤ ℵ₀ := le_aleph0 hs | theorem | Topology | [
"Mathlib.Algebra.Module.Card",
"Mathlib.Analysis.SpecificLimits.Normed",
"Mathlib.SetTheory.Cardinal.Continuum",
"Mathlib.SetTheory.Cardinal.CountableCover",
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.Topology.MetricSpace.Perfect"
] | Mathlib/Topology/Algebra/Module/Cardinality.lean | Set.Countable.dense_compl | In a nontrivial topological vector space over a complete nontrivially normed field, any
countable set has dense complement. |
characterSpace (𝕜 : Type*) (A : Type*) [CommSemiring 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜]
[ContinuousConstSMul 𝕜 𝕜] [NonUnitalNonAssocSemiring A] [TopologicalSpace A] [Module 𝕜 A] :=
{φ : WeakDual 𝕜 A | φ ≠ 0 ∧ ∀ x y : A, φ (x * y) = φ x * φ y}
variable {𝕜 : Type*} {A : Type*} | def | Topology | [
"Mathlib.Topology.Algebra.Module.WeakDual",
"Mathlib.Algebra.Algebra.Spectrum.Basic",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Data.Set.Lattice"
] | Mathlib/Topology/Algebra/Module/CharacterSpace.lean | characterSpace | The character space of a topological algebra is the subset of elements of the weak dual that
are also algebra homomorphisms. |
instFunLike : FunLike (characterSpace 𝕜 A) A 𝕜 where
coe φ := ((φ : WeakDual 𝕜 A) : A → 𝕜)
coe_injective' φ ψ h := by ext1; apply DFunLike.ext; exact congr_fun h | instance | Topology | [
"Mathlib.Topology.Algebra.Module.WeakDual",
"Mathlib.Algebra.Algebra.Spectrum.Basic",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Data.Set.Lattice"
] | Mathlib/Topology/Algebra/Module/CharacterSpace.lean | instFunLike | null |
instContinuousLinearMapClass : ContinuousLinearMapClass (characterSpace 𝕜 A) 𝕜 A 𝕜 where
map_smulₛₗ φ := (φ : WeakDual 𝕜 A).map_smul
map_add φ := (φ : WeakDual 𝕜 A).map_add
map_continuous φ := (φ : WeakDual 𝕜 A).cont | instance | Topology | [
"Mathlib.Topology.Algebra.Module.WeakDual",
"Mathlib.Algebra.Algebra.Spectrum.Basic",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Data.Set.Lattice"
] | Mathlib/Topology/Algebra/Module/CharacterSpace.lean | instContinuousLinearMapClass | Elements of the character space are continuous linear maps. |
@[simp, norm_cast]
protected coe_coe (φ : characterSpace 𝕜 A) : ⇑(φ : WeakDual 𝕜 A) = (φ : A → 𝕜) :=
rfl
@[ext] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.WeakDual",
"Mathlib.Algebra.Algebra.Spectrum.Basic",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Data.Set.Lattice"
] | Mathlib/Topology/Algebra/Module/CharacterSpace.lean | coe_coe | This has to come after `WeakDual.CharacterSpace.instFunLike`, otherwise the right-hand side
gets coerced via `Subtype.val` instead of directly via `DFunLike`. |
ext {φ ψ : characterSpace 𝕜 A} (h : ∀ x, φ x = ψ x) : φ = ψ :=
DFunLike.ext _ _ h | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.WeakDual",
"Mathlib.Algebra.Algebra.Spectrum.Basic",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Data.Set.Lattice"
] | Mathlib/Topology/Algebra/Module/CharacterSpace.lean | ext | null |
toCLM (φ : characterSpace 𝕜 A) : A →L[𝕜] 𝕜 :=
(φ : WeakDual 𝕜 A)
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.WeakDual",
"Mathlib.Algebra.Algebra.Spectrum.Basic",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Data.Set.Lattice"
] | Mathlib/Topology/Algebra/Module/CharacterSpace.lean | toCLM | An element of the character space, as a continuous linear map. |
coe_toCLM (φ : characterSpace 𝕜 A) : ⇑(toCLM φ) = φ :=
rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.WeakDual",
"Mathlib.Algebra.Algebra.Spectrum.Basic",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Data.Set.Lattice"
] | Mathlib/Topology/Algebra/Module/CharacterSpace.lean | coe_toCLM | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.