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 ⌀ |
|---|---|---|---|---|---|---|
self_comp_symm (e : M ≃ₜ* N) : e ∘ e.symm = id :=
funext e.apply_symm_apply
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | self_comp_symm | null |
apply_eq_iff_symm_apply (e : M ≃ₜ* N) {x : M} {y : N} : e x = y ↔ x = e.symm y :=
e.toEquiv.apply_eq_iff_eq_symm_apply
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | apply_eq_iff_symm_apply | null |
symm_apply_eq (e : M ≃ₜ* N) {x y} : e.symm x = y ↔ x = e y :=
e.toEquiv.symm_apply_eq
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | symm_apply_eq | null |
eq_symm_apply (e : M ≃ₜ* N) {x y} : y = e.symm x ↔ e y = x :=
e.toEquiv.eq_symm_apply
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | eq_symm_apply | null |
eq_comp_symm {α : Type*} (e : M ≃ₜ* N) (f : N → α) (g : M → α) :
f = g ∘ e.symm ↔ f ∘ e = g :=
e.toEquiv.eq_comp_symm f g
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | eq_comp_symm | null |
comp_symm_eq {α : Type*} (e : M ≃ₜ* N) (f : N → α) (g : M → α) :
g ∘ e.symm = f ↔ g = f ∘ e :=
e.toEquiv.comp_symm_eq f g
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | comp_symm_eq | null |
eq_symm_comp {α : Type*} (e : M ≃ₜ* N) (f : α → M) (g : α → N) :
f = e.symm ∘ g ↔ e ∘ f = g :=
e.toEquiv.eq_symm_comp f g
@[to_additive] | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | eq_symm_comp | null |
symm_comp_eq {α : Type*} (e : M ≃ₜ* N) (f : α → M) (g : α → N) :
e.symm ∘ g = f ↔ g = e ∘ f :=
e.toEquiv.symm_comp_eq f g | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | symm_comp_eq | null |
@[to_additive /-- The composition of two ContinuousAddEquiv. -/]
trans (cme1 : M ≃ₜ* N) (cme2 : N ≃ₜ* L) : M ≃ₜ* L where
__ := cme1.toMulEquiv.trans cme2.toMulEquiv
continuous_toFun := by convert Continuous.comp cme2.continuous_toFun cme1.continuous_toFun
continuous_invFun := by convert Continuous.comp cme1.continuous_invFun cme2.continuous_invFun
@[to_additive (attr := simp)] | def | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | trans | The composition of two ContinuousMulEquiv. |
coe_trans (e₁ : M ≃ₜ* N) (e₂ : N ≃ₜ* L) : ↑(e₁.trans e₂) = e₂ ∘ e₁ := rfl
@[to_additive (attr := simp)] | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | coe_trans | null |
trans_apply (e₁ : M ≃ₜ* N) (e₂ : N ≃ₜ* L) (m : M) : e₁.trans e₂ m = e₂ (e₁ m) := rfl
@[to_additive (attr := simp)] | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | trans_apply | null |
symm_trans_apply (e₁ : M ≃ₜ* N) (e₂ : N ≃ₜ* L) (l : L) :
(e₁.trans e₂).symm l = e₁.symm (e₂.symm l) := rfl
@[to_additive (attr := simp)] | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | symm_trans_apply | null |
symm_trans_self (e : M ≃ₜ* N) : e.symm.trans e = refl N :=
DFunLike.ext _ _ e.apply_symm_apply
@[to_additive (attr := simp)] | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | symm_trans_self | null |
self_trans_symm (e : M ≃ₜ* N) : e.trans e.symm = refl M :=
DFunLike.ext _ _ e.symm_apply_apply | theorem | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | self_trans_symm | null |
@[to_additive /-- The `AddEquiv` between two `AddMonoid`s with a unique element. -/]
ofUnique {M N} [Unique M] [Unique N] [Mul M] [Mul N]
[TopologicalSpace M] [TopologicalSpace N] : M ≃ₜ* N where
__ := MulEquiv.ofUnique
continuous_toFun := by continuity
continuous_invFun := by continuity | def | Topology | [
"Mathlib.Algebra.Group.Equiv.Basic",
"Mathlib.Topology.Algebra.Group.Defs"
] | Mathlib/Topology/Algebra/ContinuousMonoidHom.lean | ofUnique | The `MulEquiv` between two monoids with a unique element. |
@[to_additive]
equicontinuous_of_equicontinuousAt_one {ι G M hom : Type*} [TopologicalSpace G]
[UniformSpace M] [Group G] [Group M] [IsTopologicalGroup G] [IsUniformGroup M]
[FunLike hom G M] [MonoidHomClass hom G M] (F : ι → hom)
(hf : EquicontinuousAt ((↑) ∘ F) (1 : G)) :
Equicontinuous ((↑) ∘ F) := by
rw [equicontinuous_iff_continuous]
rw [equicontinuousAt_iff_continuousAt] at hf
let φ : G →* (ι →ᵤ M) :=
{ toFun := swap ((↑) ∘ F)
map_one' := by dsimp [UniformFun]; ext; exact map_one _
map_mul' := fun a b => by dsimp [UniformFun]; ext; exact map_mul _ _ _ }
exact continuous_of_continuousAt_one φ hf
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity"
] | Mathlib/Topology/Algebra/Equicontinuity.lean | equicontinuous_of_equicontinuousAt_one | null |
uniformEquicontinuous_of_equicontinuousAt_one {ι G M hom : Type*} [UniformSpace G]
[UniformSpace M] [Group G] [Group M] [IsUniformGroup G] [IsUniformGroup M]
[FunLike hom G M] [MonoidHomClass hom G M]
(F : ι → hom) (hf : EquicontinuousAt ((↑) ∘ F) (1 : G)) :
UniformEquicontinuous ((↑) ∘ F) := by
rw [uniformEquicontinuous_iff_uniformContinuous]
rw [equicontinuousAt_iff_continuousAt] at hf
let φ : G →* (ι →ᵤ M) :=
{ toFun := swap ((↑) ∘ F)
map_one' := by dsimp [UniformFun]; ext; exact map_one _
map_mul' := fun a b => by dsimp [UniformFun]; ext; exact map_mul _ _ _ }
exact uniformContinuous_of_continuousAt_one φ hf | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity"
] | Mathlib/Topology/Algebra/Equicontinuity.lean | uniformEquicontinuous_of_equicontinuousAt_one | null |
Filter.tendsto_cocompact_mul_left₀ [ContinuousMul K] {a : K} (ha : a ≠ 0) :
Filter.Tendsto (fun x : K => a * x) (Filter.cocompact K) (Filter.cocompact K) :=
Filter.tendsto_cocompact_mul_left (inv_mul_cancel₀ ha) | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | Filter.tendsto_cocompact_mul_left₀ | Left-multiplication by a nonzero element of a topological division ring is proper, i.e.,
inverse images of compact sets are compact. |
Filter.tendsto_cocompact_mul_right₀ [ContinuousMul K] {a : K} (ha : a ≠ 0) :
Filter.Tendsto (fun x : K => x * a) (Filter.cocompact K) (Filter.cocompact K) :=
Filter.tendsto_cocompact_mul_right (mul_inv_cancel₀ ha) | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | Filter.tendsto_cocompact_mul_right₀ | Right-multiplication by a nonzero element of a topological division ring is proper, i.e.,
inverse images of compact sets are compact. |
DivisionRing.finite_of_compactSpace_of_t2Space {K} [DivisionRing K] [TopologicalSpace K]
[IsTopologicalRing K] [CompactSpace K] [T2Space K] : Finite K := by
suffices DiscreteTopology K by
exact finite_of_compact_of_discrete
rw [discreteTopology_iff_isOpen_singleton_zero]
exact GroupWithZero.isOpen_singleton_zero
variable (K) | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | DivisionRing.finite_of_compactSpace_of_t2Space | Compact Hausdorff topological fields are finite. This is not an instance, as it would apply to
every `Finite` goal, causing slowly failing typeclass search in some cases. |
IsTopologicalDivisionRing : Prop extends IsTopologicalRing K, ContinuousInv₀ K
@[deprecated (since := "2025-03-25")] alias TopologicalDivisionRing := IsTopologicalDivisionRing | class | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | IsTopologicalDivisionRing | A topological division ring is a division ring with a topology where all operations are
continuous, including inversion. |
Subfield.topologicalClosure (K : Subfield α) : Subfield α :=
{ K.toSubring.topologicalClosure with
carrier := _root_.closure (K : Set α)
inv_mem' := fun x hx => by
rcases eq_or_ne x 0 with (rfl | h)
· rwa [inv_zero]
· rw [← inv_coe_set, ← Set.image_inv_eq_inv]
exact mem_closure_image (continuousAt_inv₀ h) hx } | def | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | Subfield.topologicalClosure | The (topological-space) closure of a subfield of a topological field is
itself a subfield. |
Subfield.le_topologicalClosure (s : Subfield α) : s ≤ s.topologicalClosure :=
_root_.subset_closure | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | Subfield.le_topologicalClosure | null |
Subfield.isClosed_topologicalClosure (s : Subfield α) :
IsClosed (s.topologicalClosure : Set α) :=
isClosed_closure | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | Subfield.isClosed_topologicalClosure | null |
Subfield.topologicalClosure_minimal (s : Subfield α) {t : Subfield α} (h : s ≤ t)
(ht : IsClosed (t : Set α)) : s.topologicalClosure ≤ t :=
closure_minimal h ht | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | Subfield.topologicalClosure_minimal | null |
@[simps]
affineHomeomorph (a b : 𝕜) (h : a ≠ 0) : 𝕜 ≃ₜ 𝕜 where
toFun x := a * x + b
invFun y := (y - b) / a
left_inv x := by
simp only [add_sub_cancel_right]
exact mul_div_cancel_left₀ x h
right_inv y := by simp [mul_div_cancel₀ _ h] | def | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | affineHomeomorph | The map `fun x => a * x + b`, as a homeomorphism from `𝕜` (a topological field) to itself,
when `a ≠ 0`. |
affineHomeomorph_image_Icc {𝕜 : Type*}
[Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [TopologicalSpace 𝕜]
[IsTopologicalRing 𝕜] (a b c d : 𝕜) (h : 0 < a) :
affineHomeomorph a b h.ne' '' Set.Icc c d = Set.Icc (a * c + b) (a * d + b) := by
simp [h] | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | affineHomeomorph_image_Icc | null |
affineHomeomorph_image_Ico {𝕜 : Type*}
[Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [TopologicalSpace 𝕜]
[IsTopologicalRing 𝕜] (a b c d : 𝕜) (h : 0 < a) :
affineHomeomorph a b h.ne' '' Set.Ico c d = Set.Ico (a * c + b) (a * d + b) := by
simp [h] | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | affineHomeomorph_image_Ico | null |
affineHomeomorph_image_Ioc {𝕜 : Type*}
[Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [TopologicalSpace 𝕜]
[IsTopologicalRing 𝕜] (a b c d : 𝕜) (h : 0 < a) :
affineHomeomorph a b h.ne' '' Set.Ioc c d = Set.Ioc (a * c + b) (a * d + b) := by
simp [h] | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | affineHomeomorph_image_Ioc | null |
affineHomeomorph_image_Ioo {𝕜 : Type*}
[Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [TopologicalSpace 𝕜]
[IsTopologicalRing 𝕜] (a b c d : 𝕜) (h : 0 < a) :
affineHomeomorph a b h.ne' '' Set.Ioo c d = Set.Ioo (a * c + b) (a * d + b) := by
simp [h] | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | affineHomeomorph_image_Ioo | null |
IsLocalMin.inv {f : α → β} {a : α} (h1 : IsLocalMin f a) (h2 : ∀ᶠ z in 𝓝 a, 0 < f z) :
IsLocalMax f⁻¹ a := by
filter_upwards [h1, h2] with z h3 h4 using(inv_le_inv₀ h4 h2.self_of_nhds).mpr h3 | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | IsLocalMin.inv | null |
IsPreconnected.eq_one_or_eq_neg_one_of_sq_eq [Ring 𝕜] [NoZeroDivisors 𝕜]
(hS : IsPreconnected S) (hf : ContinuousOn f S) (hsq : EqOn (f ^ 2) 1 S) :
EqOn f 1 S ∨ EqOn f (-1) S := by
have : DiscreteTopology ({1, -1} : Set 𝕜) := Finite.instDiscreteTopology
have hmaps : MapsTo f S {1, -1} := by
simpa only [EqOn, Pi.one_apply, Pi.pow_apply, sq_eq_one_iff] using hsq
simpa using hS.eqOn_const_of_mapsTo hf hmaps | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | IsPreconnected.eq_one_or_eq_neg_one_of_sq_eq | If `f` is a function `α → 𝕜` which is continuous on a preconnected set `S`, and
`f ^ 2 = 1` on `S`, then either `f = 1` on `S`, or `f = -1` on `S`. |
IsPreconnected.eq_or_eq_neg_of_sq_eq [Field 𝕜] [ContinuousInv₀ 𝕜] [ContinuousMul 𝕜]
(hS : IsPreconnected S) (hf : ContinuousOn f S) (hg : ContinuousOn g S)
(hsq : EqOn (f ^ 2) (g ^ 2) S) (hg_ne : ∀ {x : α}, x ∈ S → g x ≠ 0) :
EqOn f g S ∨ EqOn f (-g) S := by
have hsq : EqOn ((f / g) ^ 2) 1 S := fun x hx => by
simpa [div_eq_one_iff_eq (pow_ne_zero _ (hg_ne hx)), div_pow] using hsq hx
simpa +contextual [EqOn, div_eq_iff (hg_ne _)]
using hS.eq_one_or_eq_neg_one_of_sq_eq (hf.div hg fun z => hg_ne) hsq | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | IsPreconnected.eq_or_eq_neg_of_sq_eq | If `f, g` are functions `α → 𝕜`, both continuous on a preconnected set `S`, with
`f ^ 2 = g ^ 2` on `S`, and `g z ≠ 0` all `z ∈ S`, then either `f = g` or `f = -g` on
`S`. |
IsPreconnected.eq_of_sq_eq [Field 𝕜] [ContinuousInv₀ 𝕜] [ContinuousMul 𝕜]
(hS : IsPreconnected S) (hf : ContinuousOn f S) (hg : ContinuousOn g S)
(hsq : EqOn (f ^ 2) (g ^ 2) S) (hg_ne : ∀ {x : α}, x ∈ S → g x ≠ 0) {y : α} (hy : y ∈ S)
(hy' : f y = g y) : EqOn f g S := fun x hx => by
rcases hS.eq_or_eq_neg_of_sq_eq hf hg @hsq @hg_ne with (h | h)
· exact h hx
· rw [h _, Pi.neg_apply, neg_eq_iff_add_eq_zero, ← two_mul, mul_eq_zero,
(iff_of_eq (iff_false _)).2 (hg_ne _)] at hy' ⊢ <;> assumption | theorem | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | IsPreconnected.eq_of_sq_eq | If `f, g` are functions `α → 𝕜`, both continuous on a preconnected set `S`, with
`f ^ 2 = g ^ 2` on `S`, and `g z ≠ 0` all `z ∈ S`, then as soon as `f = g` holds at
one point of `S` it holds for all points. |
Subfield.continuousSMul (M : Subfield F) : ContinuousSMul M X :=
Subring.continuousSMul M.toSubring X | instance | Topology | [
"Mathlib.Algebra.Field.Subfield.Defs",
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Algebra.Order.Group.Pointwise.Interval",
"Mathlib.Topology.Algebra.GroupWithZero",
"Mathlib.Topology.Algebra.Ring.Basic",
"Mathlib.Topology.Order.LocalExtr"
] | Mathlib/Topology/Algebra/Field.lean | Subfield.continuousSMul | null |
GroupFilterBasis (G : Type u) [Group G] extends FilterBasis G where
one' : ∀ {U}, U ∈ sets → (1 : G) ∈ U
mul' : ∀ {U}, U ∈ sets → ∃ V ∈ sets, V * V ⊆ U
inv' : ∀ {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x ↦ x⁻¹) ⁻¹' U
conj' : ∀ x₀, ∀ {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x ↦ x₀ * x * x₀⁻¹) ⁻¹' U | class | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | GroupFilterBasis | A `GroupFilterBasis` on a group is a `FilterBasis` satisfying some additional axioms.
Example : if `G` is a topological group then the neighbourhoods of the identity are a
`GroupFilterBasis`. Conversely given a `GroupFilterBasis` one can define a topology
compatible with the group structure on `G`. |
AddGroupFilterBasis (A : Type u) [AddGroup A] extends FilterBasis A where
zero' : ∀ {U}, U ∈ sets → (0 : A) ∈ U
add' : ∀ {U}, U ∈ sets → ∃ V ∈ sets, V + V ⊆ U
neg' : ∀ {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x ↦ -x) ⁻¹' U
conj' : ∀ x₀, ∀ {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x ↦ x₀ + x + -x₀) ⁻¹' U
attribute [to_additive] GroupFilterBasis | class | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | AddGroupFilterBasis | An `AddGroupFilterBasis` on an additive group is a `FilterBasis` satisfying some additional
axioms. Example : if `G` is a topological group then the neighbourhoods of the identity are an
`AddGroupFilterBasis`. Conversely given an `AddGroupFilterBasis` one can define a topology
compatible with the group structure on `G`. |
@[to_additive /-- `AddGroupFilterBasis` constructor in the additive commutative group case. -/]
groupFilterBasisOfComm {G : Type*} [CommGroup G] (sets : Set (Set G))
(nonempty : sets.Nonempty) (inter_sets : ∀ x y, x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y)
(one : ∀ U ∈ sets, (1 : G) ∈ U) (mul : ∀ U ∈ sets, ∃ V ∈ sets, V * V ⊆ U)
(inv : ∀ U ∈ sets, ∃ V ∈ sets, V ⊆ (fun x ↦ x⁻¹) ⁻¹' U) : GroupFilterBasis G :=
{ sets := sets
nonempty := nonempty
inter_sets := inter_sets _ _
one' := one _
mul' := mul _
inv' := inv _
conj' := fun x U U_in ↦ ⟨U, U_in, by simp only [mul_inv_cancel_comm, preimage_id']; rfl⟩ } | def | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | groupFilterBasisOfComm | `GroupFilterBasis` constructor in the commutative group case. |
@[to_additive]
one {U : Set G} : U ∈ B → (1 : G) ∈ U :=
GroupFilterBasis.one'
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | one | null |
mul {U : Set G} : U ∈ B → ∃ V ∈ B, V * V ⊆ U :=
GroupFilterBasis.mul'
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | mul | null |
inv {U : Set G} : U ∈ B → ∃ V ∈ B, V ⊆ (fun x ↦ x⁻¹) ⁻¹' U :=
GroupFilterBasis.inv'
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | inv | null |
conj : ∀ x₀, ∀ {U}, U ∈ B → ∃ V ∈ B, V ⊆ (fun x ↦ x₀ * x * x₀⁻¹) ⁻¹' U :=
GroupFilterBasis.conj' | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | conj | null |
@[to_additive /-- The neighborhood function of an `AddGroupFilterBasis`. -/]
N (B : GroupFilterBasis G) : G → Filter G :=
fun x ↦ map (fun y ↦ x * y) B.toFilterBasis.filter
@[to_additive (attr := simp)] | def | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | N | The trivial group filter basis consists of `{1}` only. The associated topology
is discrete. -/
@[to_additive /-- The trivial additive group filter basis consists of `{0}` only. The associated
topology is discrete. -/]
instance : Inhabited (GroupFilterBasis G) where
default := {
sets := {{1}}
nonempty := singleton_nonempty _
inter_sets := by simp
one' := by simp
mul' := by simp
inv' := by simp
conj' := by simp }
@[to_additive]
theorem subset_mul_self (B : GroupFilterBasis G) {U : Set G} (h : U ∈ B) : U ⊆ U * U :=
fun x x_in ↦ ⟨1, one h, x, x_in, one_mul x⟩
/-- The neighborhood function of a `GroupFilterBasis`. |
N_one (B : GroupFilterBasis G) : B.N 1 = B.toFilterBasis.filter := by
simp only [N, one_mul, map_id']
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | N_one | null |
protected hasBasis (B : GroupFilterBasis G) (x : G) :
HasBasis (B.N x) (fun V : Set G ↦ V ∈ B) fun V ↦ (fun y ↦ x * y) '' V :=
HasBasis.map (fun y ↦ x * y) toFilterBasis.hasBasis | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | hasBasis | null |
@[to_additive /-- The topological space structure coming from an additive group filter basis. -/]
topology (B : GroupFilterBasis G) : TopologicalSpace G :=
TopologicalSpace.mkOfNhds B.N
@[to_additive] | def | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | topology | The topological space structure coming from a group filter basis. |
nhds_eq (B : GroupFilterBasis G) {x₀ : G} : @nhds G B.topology x₀ = B.N x₀ := by
apply TopologicalSpace.nhds_mkOfNhds_of_hasBasis (fun x ↦ (FilterBasis.hasBasis _).map _)
· intro a U U_in
exact ⟨1, B.one U_in, mul_one a⟩
· intro a U U_in
rcases GroupFilterBasis.mul U_in with ⟨V, V_in, hVU⟩
filter_upwards [image_mem_map (B.mem_filter_of_mem V_in)]
rintro _ ⟨x, hx, rfl⟩
calc
(a * x) • V ∈ (a * x) • B.filter := smul_set_mem_smul_filter <| B.mem_filter_of_mem V_in
_ = a • x • V := smul_smul .. |>.symm
_ ⊆ a • (V * V) := smul_set_mono <| smul_set_subset_smul hx
_ ⊆ a • U := smul_set_mono hVU
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | nhds_eq | null |
nhds_one_eq (B : GroupFilterBasis G) :
@nhds G B.topology (1 : G) = B.toFilterBasis.filter := by
rw [B.nhds_eq]
simp only [N, one_mul]
exact map_id
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | nhds_one_eq | null |
nhds_hasBasis (B : GroupFilterBasis G) (x₀ : G) :
HasBasis (@nhds G B.topology x₀) (fun V : Set G ↦ V ∈ B) fun V ↦ (fun y ↦ x₀ * y) '' V := by
rw [B.nhds_eq]
apply B.hasBasis
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | nhds_hasBasis | null |
nhds_one_hasBasis (B : GroupFilterBasis G) :
HasBasis (@nhds G B.topology 1) (fun V : Set G ↦ V ∈ B) id := by
rw [B.nhds_one_eq]
exact B.toFilterBasis.hasBasis
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | nhds_one_hasBasis | null |
mem_nhds_one (B : GroupFilterBasis G) {U : Set G} (hU : U ∈ B) :
U ∈ @nhds G B.topology 1 := by
rw [B.nhds_one_hasBasis.mem_iff]
exact ⟨U, hU, rfl.subset⟩ | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | mem_nhds_one | null |
RingFilterBasis (R : Type u) [Ring R] extends AddGroupFilterBasis R where
mul' : ∀ {U}, U ∈ sets → ∃ V ∈ sets, V * V ⊆ U
mul_left' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x ↦ x₀ * x) ⁻¹' U
mul_right' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x ↦ x * x₀) ⁻¹' U | class | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | RingFilterBasis | If a group is endowed with a topological structure coming from a group filter basis then, it's a
topological group. -/
@[to_additive /-- If an additive group is endowed with a topological structure coming from an
additive group filter basis, then it's an additive topological group. -/]
instance (priority := 100) isTopologicalGroup (B : GroupFilterBasis G) :
@IsTopologicalGroup G B.topology _ := by
letI := B.topology
have basis := B.nhds_one_hasBasis
have basis' := basis.prod basis
refine IsTopologicalGroup.of_nhds_one ?_ ?_ ?_ ?_
· rw [basis'.tendsto_iff basis]
suffices ∀ U ∈ B, ∃ V W, (V ∈ B ∧ W ∈ B) ∧ ∀ a b, a ∈ V → b ∈ W → a * b ∈ U by simpa
intro U U_in
rcases mul U_in with ⟨V, V_in, hV⟩
refine ⟨V, V, ⟨V_in, V_in⟩, ?_⟩
intro a b a_in b_in
exact hV <| mul_mem_mul a_in b_in
· rw [basis.tendsto_iff basis]
intro U U_in
simpa using inv U_in
· intro x₀
rw [nhds_eq, nhds_one_eq]
rfl
· intro x₀
rw [basis.tendsto_iff basis]
intro U U_in
exact conj x₀ U_in
end GroupFilterBasis
/-- A `RingFilterBasis` on a ring is a `FilterBasis` satisfying some additional axioms.
Example : if `R` is a topological ring then the neighbourhoods of the identity are a
`RingFilterBasis`. Conversely given a `RingFilterBasis` on a ring `R`, one can define a
topology on `R` which is compatible with the ring structure. |
mul {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V * V ⊆ U :=
mul' hU | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | mul | null |
mul_left (x₀ : R) {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x ↦ x₀ * x) ⁻¹' U :=
mul_left' x₀ hU | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | mul_left | null |
mul_right (x₀ : R) {U : Set R} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x ↦ x * x₀) ⁻¹' U :=
mul_right' x₀ hU | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | mul_right | null |
topology : TopologicalSpace R :=
B.toAddGroupFilterBasis.topology | def | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | topology | The topology associated to a ring filter basis.
It has the given basis as a basis of neighborhoods of zero. |
ModuleFilterBasis (R M : Type*) [CommRing R] [TopologicalSpace R] [AddCommGroup M]
[Module R M] extends AddGroupFilterBasis M where
smul' : ∀ {U}, U ∈ sets → ∃ V ∈ 𝓝 (0 : R), ∃ W ∈ sets, V • W ⊆ U
smul_left' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x ↦ x₀ • x) ⁻¹' U
smul_right' : ∀ (m₀ : M) {U}, U ∈ sets → ∀ᶠ x in 𝓝 (0 : R), x • m₀ ∈ U | structure | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | ModuleFilterBasis | If a ring is endowed with a topological structure coming from
a ring filter basis then it's a topological ring. -/
instance (priority := 100) isTopologicalRing {R : Type u} [Ring R] (B : RingFilterBasis R) :
@IsTopologicalRing R B.topology _ := by
let B' := B.toAddGroupFilterBasis
letI := B'.topology
have basis := B'.nhds_zero_hasBasis
have basis' := basis.prod basis
haveI := B'.isTopologicalAddGroup
apply IsTopologicalRing.of_addGroup_of_nhds_zero
· rw [basis'.tendsto_iff basis]
suffices ∀ U ∈ B', ∃ V W, (V ∈ B' ∧ W ∈ B') ∧ ∀ a b, a ∈ V → b ∈ W → a * b ∈ U by simpa
intro U U_in
rcases B.mul U_in with ⟨V, V_in, hV⟩
refine ⟨V, V, ⟨V_in, V_in⟩, ?_⟩
intro a b a_in b_in
exact hV <| mul_mem_mul a_in b_in
· intro x₀
rw [basis.tendsto_iff basis]
intro U
simpa using B.mul_left x₀
· intro x₀
rw [basis.tendsto_iff basis]
intro U
simpa using B.mul_right x₀
end RingFilterBasis
/-- A `ModuleFilterBasis` on a module is a `FilterBasis` satisfying some additional axioms.
Example : if `M` is a topological module then the neighbourhoods of zero are a
`ModuleFilterBasis`. Conversely given a `ModuleFilterBasis` one can define a topology
compatible with the module structure on `M`. |
GroupFilterBasis.hasMem : Membership (Set M) (ModuleFilterBasis R M) :=
⟨fun B s ↦ s ∈ B.sets⟩ | instance | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | GroupFilterBasis.hasMem | null |
smul {U : Set M} (hU : U ∈ B) : ∃ V ∈ 𝓝 (0 : R), ∃ W ∈ B, V • W ⊆ U :=
B.smul' hU | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | smul | null |
smul_left (x₀ : R) {U : Set M} (hU : U ∈ B) : ∃ V ∈ B, V ⊆ (fun x ↦ x₀ • x) ⁻¹' U :=
B.smul_left' x₀ hU | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | smul_left | null |
smul_right (m₀ : M) {U : Set M} (hU : U ∈ B) : ∀ᶠ x in 𝓝 (0 : R), x • m₀ ∈ U :=
B.smul_right' m₀ hU | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | smul_right | null |
topology : TopologicalSpace M :=
B.toAddGroupFilterBasis.topology | def | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | topology | If `R` is discrete then the trivial additive group filter basis on any `R`-module is a
module filter basis. -/
instance [DiscreteTopology R] : Inhabited (ModuleFilterBasis R M) :=
⟨{
show AddGroupFilterBasis M from
default with
smul' := by
rintro U (rfl : U ∈ {{(0 : M)}})
use univ, univ_mem, {0}, rfl
rintro a ⟨x, -, m, rfl, rfl⟩
simp only [smul_zero, mem_singleton_iff]
smul_left' := by
rintro x₀ U (h : U ∈ {{(0 : M)}})
rw [mem_singleton_iff] at h
use {0}, rfl
simp [h]
smul_right' := by
rintro m₀ U (h : U ∈ (0 : Set (Set M)))
rw [Set.mem_zero] at h
simp [h, nhds_discrete] }⟩
/-- The topology associated to a module filter basis on a module over a topological ring.
It has the given basis as a basis of neighborhoods of zero. |
topology' {R M : Type*} [CommRing R] {_ : TopologicalSpace R} [AddCommGroup M] [Module R M]
(B : ModuleFilterBasis R M) : TopologicalSpace M :=
B.toAddGroupFilterBasis.topology | def | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | topology' | The topology associated to a module filter basis on a module over a topological ring.
It has the given basis as a basis of neighborhoods of zero. This version gets the ring
topology by unification instead of type class inference. |
_root_.ContinuousSMul.of_basis_zero {ι : Type*} [IsTopologicalRing R] [TopologicalSpace M]
[IsTopologicalAddGroup M] {p : ι → Prop} {b : ι → Set M} (h : HasBasis (𝓝 0) p b)
(hsmul : ∀ {i}, p i → ∃ V ∈ 𝓝 (0 : R), ∃ j, p j ∧ V • b j ⊆ b i)
(hsmul_left : ∀ (x₀ : R) {i}, p i → ∃ j, p j ∧ MapsTo (x₀ • ·) (b j) (b i))
(hsmul_right : ∀ (m₀ : M) {i}, p i → ∀ᶠ x in 𝓝 (0 : R), x • m₀ ∈ b i) : ContinuousSMul R M := by
apply ContinuousSMul.of_nhds_zero
· rw [h.tendsto_right_iff]
intro i hi
rcases hsmul hi with ⟨V, V_in, j, hj, hVj⟩
apply mem_of_superset (prod_mem_prod V_in <| h.mem_of_mem hj)
rintro ⟨v, w⟩ ⟨v_in : v ∈ V, w_in : w ∈ b j⟩
exact hVj (Set.smul_mem_smul v_in w_in)
· intro m₀
rw [h.tendsto_right_iff]
intro i hi
exact hsmul_right m₀ hi
· intro x₀
rw [h.tendsto_right_iff]
intro i hi
rcases hsmul_left x₀ hi with ⟨j, hj, hji⟩
exact mem_of_superset (h.mem_of_mem hj) hji | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | _root_.ContinuousSMul.of_basis_zero | A topological additive group with a basis of `𝓝 0` satisfying the axioms of `ModuleFilterBasis`
is a topological module.
This lemma is mathematically useless because one could obtain such a result by applying
`ModuleFilterBasis.continuousSMul` and use the fact that group topologies are characterized
by their neighborhoods of 0 to obtain the `ContinuousSMul` on the pre-existing topology.
But it turns out it's just easier to get it as a byproduct of the proof, so this is just a free
quality-of-life improvement. |
ofBases {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] (BR : RingFilterBasis R)
(BM : AddGroupFilterBasis M) (smul : ∀ {U}, U ∈ BM → ∃ V ∈ BR, ∃ W ∈ BM, V • W ⊆ U)
(smul_left : ∀ (x₀ : R) {U}, U ∈ BM → ∃ V ∈ BM, V ⊆ (fun x ↦ x₀ • x) ⁻¹' U)
(smul_right : ∀ (m₀ : M) {U}, U ∈ BM → ∃ V ∈ BR, V ⊆ (fun x ↦ x • m₀) ⁻¹' U) :
@ModuleFilterBasis R M _ BR.topology _ _ :=
let _ := BR.topology
{ BM with
smul' := by
intro U U_in
rcases smul U_in with ⟨V, V_in, W, W_in, H⟩
exact ⟨V, BR.toAddGroupFilterBasis.mem_nhds_zero V_in, W, W_in, H⟩
smul_left' := smul_left
smul_right' := by
intro m₀ U U_in
rcases smul_right m₀ U_in with ⟨V, V_in, H⟩
exact mem_of_superset (BR.toAddGroupFilterBasis.mem_nhds_zero V_in) H } | def | Topology | [
"Mathlib.Topology.Algebra.Module.Basic"
] | Mathlib/Topology/Algebra/FilterBasis.lean | ofBases | If a module is endowed with a topological structure coming from
a module filter basis then it's a topological module. -/
instance (priority := 100) continuousSMul [IsTopologicalRing R] :
@ContinuousSMul R M _ _ B.topology := by
let B' := B.toAddGroupFilterBasis
let _ := B'.topology
have _ := B'.isTopologicalAddGroup
exact ContinuousSMul.of_basis_zero B'.nhds_zero_hasBasis
(fun {_} => by simpa using B.smul)
(by simpa using B.smul_left) B.smul_right
/-- Build a module filter basis from compatible ring and additive group filter bases. |
@[norm_cast]
UniformSpace.Completion.coe_zero [Zero α] : ((0 : α) : Completion α) = 0 :=
rfl
@[simp] lemma UniformSpace.Completion.coe_eq_zero_iff [Zero α] [T0Space α] {x : α} :
(x : Completion α) = 0 ↔ x = 0 :=
Completion.coe_inj | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | UniformSpace.Completion.coe_zero | null |
@[norm_cast]
coe_neg (a : α) : ((-a : α) : Completion α) = -a :=
(map_coe uniformContinuous_neg a).symm
@[norm_cast] | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | coe_neg | null |
coe_sub (a b : α) : ((a - b : α) : Completion α) = a - b :=
(map₂_coe_coe a b Sub.sub uniformContinuous_sub).symm
@[norm_cast] | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | coe_sub | null |
coe_add (a b : α) : ((a + b : α) : Completion α) = a + b :=
(map₂_coe_coe a b (· + ·) uniformContinuous_add).symm | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | coe_add | null |
addGroup : AddGroup (Completion α) :=
{ (inferInstance : SubNegMonoid <| Completion α) with
neg_add_cancel := fun a ↦
Completion.induction_on a
(isClosed_eq (continuous_map₂ Completion.continuous_map continuous_id) continuous_const)
fun a ↦
show -(a : Completion α) + a = 0 by
rw_mod_cast [neg_add_cancel]
rfl } | instance | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | addGroup | null |
isUniformAddGroup : IsUniformAddGroup (Completion α) :=
⟨uniformContinuous_map₂ Sub.sub⟩ | instance | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | isUniformAddGroup | null |
@[simps]
toCompl : α →+ Completion α where
toFun := (↑)
map_add' := coe_add
map_zero' := coe_zero | def | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | toCompl | The map from a group to its completion as a group hom. |
continuous_toCompl : Continuous (toCompl : α → Completion α) :=
continuous_coe α
variable (α) in | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | continuous_toCompl | null |
isDenseInducing_toCompl : IsDenseInducing (toCompl : α → Completion α) :=
isDenseInducing_coe | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | isDenseInducing_toCompl | null |
instAddCommGroup : AddCommGroup (Completion α) :=
{ (inferInstance : AddGroup <| Completion α) with
add_comm := fun a b ↦
Completion.induction_on₂ a b
(isClosed_eq (continuous_map₂ continuous_fst continuous_snd)
(continuous_map₂ continuous_snd continuous_fst))
fun x y ↦ by
change (x : Completion α) + ↑y = ↑y + ↑x
rw [← coe_add, ← coe_add, add_comm] } | instance | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | instAddCommGroup | null |
instModule [Semiring R] [Module R α] [UniformContinuousConstSMul R α] :
Module R (Completion α) :=
{ (inferInstance : DistribMulAction R <| Completion α),
(inferInstance : MulActionWithZero R <| Completion α) with
add_smul := fun a b ↦
ext' (continuous_const_smul _) ((continuous_const_smul _).add (continuous_const_smul _))
fun x ↦ by
rw [← coe_smul, add_smul, coe_add, coe_smul, coe_smul] } | instance | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | instModule | null |
AddMonoidHom.extension [CompleteSpace β] [T0Space β] (f : α →+ β) (hf : Continuous f) :
Completion α →+ β :=
have hf : UniformContinuous f := uniformContinuous_addMonoidHom_of_continuous hf
{ toFun := Completion.extension f
map_zero' := by rw [← coe_zero, extension_coe hf, f.map_zero]
map_add' := fun a b ↦
Completion.induction_on₂ a b
(isClosed_eq (continuous_extension.comp continuous_add)
((continuous_extension.comp continuous_fst).add
(continuous_extension.comp continuous_snd)))
fun a b ↦
show Completion.extension f _ = Completion.extension f _ + Completion.extension f _ by
rw_mod_cast [extension_coe hf, extension_coe hf, extension_coe hf, f.map_add] } | def | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | AddMonoidHom.extension | Extension to the completion of a continuous group hom. |
AddMonoidHom.extension_coe [CompleteSpace β] [T0Space β] (f : α →+ β)
(hf : Continuous f) (a : α) : f.extension hf a = f a :=
UniformSpace.Completion.extension_coe (uniformContinuous_addMonoidHom_of_continuous hf) a
@[continuity] | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | AddMonoidHom.extension_coe | null |
AddMonoidHom.continuous_extension [CompleteSpace β] [T0Space β] (f : α →+ β)
(hf : Continuous f) : Continuous (f.extension hf) :=
UniformSpace.Completion.continuous_extension | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | AddMonoidHom.continuous_extension | null |
AddMonoidHom.completion (f : α →+ β) (hf : Continuous f) : Completion α →+ Completion β :=
(toCompl.comp f).extension (continuous_toCompl.comp hf)
@[continuity] | def | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | AddMonoidHom.completion | Completion of a continuous group hom, as a group hom. |
AddMonoidHom.continuous_completion (f : α →+ β) (hf : Continuous f) :
Continuous (AddMonoidHom.completion f hf : Completion α → Completion β) :=
continuous_map | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | AddMonoidHom.continuous_completion | null |
AddMonoidHom.completion_coe (f : α →+ β) (hf : Continuous f) (a : α) :
AddMonoidHom.completion f hf a = f a :=
map_coe (uniformContinuous_addMonoidHom_of_continuous hf) a | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | AddMonoidHom.completion_coe | null |
AddMonoidHom.completion_zero :
AddMonoidHom.completion (0 : α →+ β) continuous_const = 0 := by
ext x
refine Completion.induction_on x ?_ ?_
· apply isClosed_eq (AddMonoidHom.continuous_completion (0 : α →+ β) continuous_const)
exact continuous_const
· simp [(0 : α →+ β).completion_coe continuous_const, coe_zero] | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | AddMonoidHom.completion_zero | null |
AddMonoidHom.completion_add {γ : Type*} [AddCommGroup γ] [UniformSpace γ]
[IsUniformAddGroup γ] (f g : α →+ γ) (hf : Continuous f) (hg : Continuous g) :
AddMonoidHom.completion (f + g) (hf.add hg) =
AddMonoidHom.completion f hf + AddMonoidHom.completion g hg := by
have hfg := hf.add hg
ext x
refine Completion.induction_on x ?_ ?_
· exact isClosed_eq ((f + g).continuous_completion hfg)
((f.continuous_completion hf).add (g.continuous_completion hg))
· simp [(f + g).completion_coe hfg, coe_add, f.completion_coe hf, g.completion_coe hg] | theorem | Topology | [
"Mathlib.Topology.Algebra.UniformMulAction",
"Mathlib.Topology.UniformSpace.Completion",
"Mathlib.Topology.Algebra.Group.Pointwise"
] | Mathlib/Topology/Algebra/GroupCompletion.lean | AddMonoidHom.completion_add | null |
Filter.Tendsto.div_const {x : G₀} (hf : Tendsto f l (𝓝 x)) (y : G₀) :
Tendsto (fun a => f a / y) l (𝓝 (x / y)) := by
simpa only [div_eq_mul_inv] using hf.mul tendsto_const_nhds
variable [TopologicalSpace α]
nonrec theorem ContinuousAt.div_const {a : α} (hf : ContinuousAt f a) (y : G₀) :
ContinuousAt (fun x => f x / y) a :=
hf.div_const y
nonrec theorem ContinuousWithinAt.div_const {a} (hf : ContinuousWithinAt f s a) (y : G₀) :
ContinuousWithinAt (fun x => f x / y) s a :=
hf.div_const _ | theorem | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | Filter.Tendsto.div_const | null |
ContinuousOn.div_const (hf : ContinuousOn f s) (y : G₀) :
ContinuousOn (fun x => f x / y) s := by
simpa only [div_eq_mul_inv] using hf.mul continuousOn_const
@[continuity, fun_prop] | theorem | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | ContinuousOn.div_const | null |
Continuous.div_const (hf : Continuous f) (y : G₀) : Continuous fun x => f x / y := by
simpa only [div_eq_mul_inv] using hf.mul continuous_const | theorem | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | Continuous.div_const | null |
ContinuousInv₀ (G₀ : Type*) [Zero G₀] [Inv G₀] [TopologicalSpace G₀] : Prop where
/-- The map `fun x ↦ x⁻¹` is continuous at all nonzero points. -/
continuousAt_inv₀ : ∀ ⦃x : G₀⦄, x ≠ 0 → ContinuousAt Inv.inv x
export ContinuousInv₀ (continuousAt_inv₀)
@[deprecated (since := "2025-09-01")] alias HasContinuousInv₀ := ContinuousInv₀ | class | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | ContinuousInv₀ | A type with `0` and `Inv` such that `fun x ↦ x⁻¹` is continuous at all nonzero points. Any
normed (semi)field has this property. |
tendsto_inv₀ {x : G₀} (hx : x ≠ 0) : Tendsto Inv.inv (𝓝 x) (𝓝 x⁻¹) :=
continuousAt_inv₀ hx | theorem | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | tendsto_inv₀ | null |
continuousOn_inv₀ : ContinuousOn (Inv.inv : G₀ → G₀) {0}ᶜ := fun _x hx =>
(continuousAt_inv₀ hx).continuousWithinAt | theorem | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | continuousOn_inv₀ | null |
Filter.Tendsto.inv₀ {a : G₀} (hf : Tendsto f l (𝓝 a)) (ha : a ≠ 0) :
Tendsto (fun x => (f x)⁻¹) l (𝓝 a⁻¹) :=
(tendsto_inv₀ ha).comp hf
variable [TopologicalSpace α]
nonrec theorem ContinuousWithinAt.inv₀ (hf : ContinuousWithinAt f s a) (ha : f a ≠ 0) :
ContinuousWithinAt (fun x => (f x)⁻¹) s a :=
hf.inv₀ ha
@[fun_prop]
nonrec theorem ContinuousAt.inv₀ (hf : ContinuousAt f a) (ha : f a ≠ 0) :
ContinuousAt (fun x => (f x)⁻¹) a :=
hf.inv₀ ha
@[continuity, fun_prop] | theorem | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | Filter.Tendsto.inv₀ | If a function converges to a nonzero value, its inverse converges to the inverse of this value.
We use the name `Filter.Tendsto.inv₀` as `Filter.Tendsto.inv` is already used in multiplicative
topological groups. |
Continuous.inv₀ (hf : Continuous f) (h0 : ∀ x, f x ≠ 0) : Continuous fun x => (f x)⁻¹ :=
continuous_iff_continuousAt.2 fun x => (hf.tendsto x).inv₀ (h0 x)
@[fun_prop] | theorem | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | Continuous.inv₀ | null |
ContinuousOn.inv₀ (hf : ContinuousOn f s) (h0 : ∀ x ∈ s, f x ≠ 0) :
ContinuousOn (fun x => (f x)⁻¹) s := fun x hx => (hf x hx).inv₀ (h0 x hx) | theorem | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | ContinuousOn.inv₀ | null |
Units.isEmbedding_val₀ : IsEmbedding (val : G₀ˣ → G₀) :=
embedding_val_mk <| (continuousOn_inv₀ (G₀ := G₀)).mono fun _ ↦ IsUnit.ne_zero | theorem | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | Units.isEmbedding_val₀ | If `G₀` is a group with zero with topology such that `x ↦ x⁻¹` is continuous at all nonzero
points. Then the coercion `G₀ˣ → G₀` is a topological embedding. |
noncomputable unitsHomeomorphNeZero : G₀ˣ ≃ₜ {g : G₀ // g ≠ 0} :=
Units.isEmbedding_val₀.toHomeomorph.trans <| show _ ≃ₜ {g | _} from .setCongr <|
Set.ext fun x ↦ (Units.exists_iff_ne_zero (p := (· = x))).trans <| by simp | def | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | unitsHomeomorphNeZero | If a group with zero has continuous inversion, then its group of units is homeomorphic to
the set of nonzero elements. |
nhds_inv₀ (hx : x ≠ 0) : 𝓝 x⁻¹ = (𝓝 x)⁻¹ := by
refine le_antisymm (inv_le_iff_le_inv.1 ?_) (tendsto_inv₀ hx)
simpa only [inv_inv] using tendsto_inv₀ (inv_ne_zero hx) | lemma | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | nhds_inv₀ | null |
tendsto_inv_iff₀ {l : Filter α} {f : α → G₀} (hx : x ≠ 0) :
Tendsto (fun x ↦ (f x)⁻¹) l (𝓝 x⁻¹) ↔ Tendsto f l (𝓝 x) := by
simp only [nhds_inv₀ hx, ← Filter.comap_inv, tendsto_comap_iff, Function.comp_def, inv_inv] | lemma | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | tendsto_inv_iff₀ | null |
Filter.Tendsto.div {l : Filter α} {a b : G₀} (hf : Tendsto f l (𝓝 a))
(hg : Tendsto g l (𝓝 b)) (hy : b ≠ 0) : Tendsto (f / g) l (𝓝 (a / b)) := by
simpa only [div_eq_mul_inv] using hf.mul (hg.inv₀ hy) | theorem | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | Filter.Tendsto.div | null |
Filter.tendsto_mul_iff_of_ne_zero [T1Space G₀] {f g : α → G₀} {l : Filter α} {x y : G₀}
(hg : Tendsto g l (𝓝 y)) (hy : y ≠ 0) :
Tendsto (fun n => f n * g n) l (𝓝 <| x * y) ↔ Tendsto f l (𝓝 x) := by
refine ⟨fun hfg => ?_, fun hf => hf.mul hg⟩
rw [← mul_div_cancel_right₀ x hy]
refine Tendsto.congr' ?_ (hfg.div hg hy)
exact (hg.eventually_ne hy).mono fun n hn => mul_div_cancel_right₀ _ hn
variable [TopologicalSpace α] [TopologicalSpace β] {s : Set α} {a : α}
nonrec theorem ContinuousWithinAt.div (hf : ContinuousWithinAt f s a)
(hg : ContinuousWithinAt g s a) (h₀ : g a ≠ 0) : ContinuousWithinAt (f / g) s a :=
hf.div hg h₀ | theorem | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | Filter.tendsto_mul_iff_of_ne_zero | null |
ContinuousOn.div (hf : ContinuousOn f s) (hg : ContinuousOn g s) (h₀ : ∀ x ∈ s, g x ≠ 0) :
ContinuousOn (f / g) s := fun x hx => (hf x hx).div (hg x hx) (h₀ x hx) | theorem | Topology | [
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.GroupWithZero.Units.Equiv",
"Mathlib.Topology.Algebra.Monoid",
"Mathlib.Topology.Homeomorph.Lemmas"
] | Mathlib/Topology/Algebra/GroupWithZero.lean | ContinuousOn.div | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.