ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Topology/ContinuousFunction/Ordered.lean

full_name: ContinuousMap.partialOrder
code: instance partialOrder [PartialOrder β] : PartialOrder C(α, β) 
goal: PartialOrder C(α, β)

full_name: ContinuousMap.le_def
code: theorem le_def [PartialOrder β] {f g : C(α, β)} : f ≤ g ↔ ∀ a, f a ≤ g a 
goal: f ≤ g ↔ ∀ (a : α), f a ≤ g a

full_name: ContinuousMap.lt_def
code: theorem lt_def [PartialOrder β] {f g : C(α, β)} : f < g ↔ (∀ a, f a ≤ g a) ∧ ∃ a, f a < g a 
goal: f < g ↔ (∀ (a : α), f a ≤ g a) ∧ ∃ a, f a < g a

full_name: ContinuousMap.sup
code: instance sup : Sup C(α, β) 
goal: Sup C(α, β)

full_name: ContinuousMap.coe_sup
code: @[simp, norm_cast] lemma coe_sup (f g : C(α, β)) : ⇑(f ⊔ g) = ⇑f ⊔ g 
goal: ⇑(f ⊔ g) = ⇑f ⊔ ⇑g

full_name: ContinuousMap.sup_apply
code: @[simp] lemma sup_apply (f g : C(α, β)) (a : α) : (f ⊔ g) a = f a ⊔ g a 
goal: (f ⊔ g) a = f a ⊔ g a

full_name: ContinuousMap.semilatticeSup
code: instance semilatticeSup : SemilatticeSup C(α, β) 
goal: SemilatticeSup C(α, β)

full_name: ContinuousMap.sup'_apply
code: lemma sup'_apply {ι : Type*} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β)) (a : α) :
    s.sup' H f a = s.sup' H fun i ↦ f i a 
goal: (s.sup' H f) a = s.sup' H fun i => (f i) a

full_name: ContinuousMap.coe_sup'
code: @[simp, norm_cast]
lemma coe_sup' {ι : Type*} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β)) :
    ⇑(s.sup' H f) = s.sup' H fun i ↦ ⇑(f i) 
goal: ⇑(s.sup' H f) = s.sup' H fun i => ⇑(f i)

full_name: ContinuousMap.inf
code: instance inf : Inf C(α, β) 
goal: Inf C(α, β)

full_name: ContinuousMap.coe_inf
code: @[simp, norm_cast] lemma coe_inf (f g : C(α, β)) : ⇑(f ⊓ g) = ⇑f ⊓ g 
goal: ⇑(f ⊓ g) = ⇑f ⊓ ⇑g

full_name: ContinuousMap.inf_apply
code: @[simp] lemma inf_apply (f g : C(α, β)) (a : α) : (f ⊓ g) a = f a ⊓ g a 
goal: (f ⊓ g) a = f a ⊓ g a

full_name: ContinuousMap.semilatticeInf
code: instance semilatticeInf : SemilatticeInf C(α, β) 
goal: SemilatticeInf C(α, β)

full_name: ContinuousMap.inf'_apply
code: lemma inf'_apply {ι : Type*} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β)) (a : α) :
    s.inf' H f a = s.inf' H fun i ↦ f i a 
goal: (s.inf' H f) a = s.inf' H fun i => (f i) a

full_name: ContinuousMap.coe_inf'
code: @[simp, norm_cast]
lemma coe_inf' {ι : Type*} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β)) :
    ⇑(s.inf' H f) = s.inf' H fun i ↦ ⇑(f i) 
goal: ⇑(s.inf' H f) = s.inf' H fun i => ⇑(f i)

full_name: ContinuousMap.instLatticeOfTopologicalLattice
code: instance [Lattice β] [TopologicalLattice β] : Lattice C(α, β) 
goal: Lattice C(α, β)

full_name: ContinuousMap.IccExtend
code: /-- Extend a continuous function `f : C(Set.Icc a b, β)` to a function `f : C(α, β)`.  -/
def IccExtend (f : C(Set.Icc a b, β)) : C(α, β) 
goal: C(α, β)

full_name: ContinuousMap.coe_IccExtend
code: @[simp]
theorem coe_IccExtend (f : C(Set.Icc a b, β)) :
    ((IccExtend h f : C(α, β)) : α → β) = Set.IccExtend h f 
goal: ⇑(ContinuousMap.IccExtend h f) = Set.IccExtend h ⇑f
File: Mathlib/Topology/ContinuousFunction/T0Sierpinski.lean

full_name: TopologicalSpace.eq_induced_by_maps_to_sierpinski
code: theorem eq_induced_by_maps_to_sierpinski (X : Type*) [t : TopologicalSpace X] :
    t = ⨅ u : Opens X, sierpinskiSpace.induced (· ∈ u) 
goal: t = ⨅ u, TopologicalSpace.induced (fun x => x ∈ u) sierpinskiSpace

full_name: TopologicalSpace.productOfMemOpens
code: /-- The continuous map from `X` to the product of copies of the Sierpinski space, (one copy for each
open subset `u` of `X`). The `u` coordinate of `productOfMemOpens x` is given by `x ∈ u`.
-/
def productOfMemOpens : C(X, Opens X → Prop) 
goal: C(X, TopologicalSpace.Opens X → Prop)

full_name: TopologicalSpace.productOfMemOpens_inducing
code: theorem productOfMemOpens_inducing : Inducing (productOfMemOpens X) 
goal: Inducing ⇑(TopologicalSpace.productOfMemOpens X)

full_name: TopologicalSpace.productOfMemOpens_injective
code: theorem productOfMemOpens_injective [T0Space X] : Function.Injective (productOfMemOpens X) 
goal: Function.Injective ⇑(TopologicalSpace.productOfMemOpens X)

full_name: TopologicalSpace.productOfMemOpens_embedding
code: theorem productOfMemOpens_embedding [T0Space X] : Embedding (productOfMemOpens X) 
goal: Embedding ⇑(TopologicalSpace.productOfMemOpens X)
File: Mathlib/Topology/ContinuousFunction/Sigma.lean

full_name: ContinuousMap.embedding_sigmaMk_comp
code: theorem embedding_sigmaMk_comp [Nonempty X] :
    Embedding (fun g : Σ i, C(X, Y i) ↦ (sigmaMk g.1).comp g.2) 
goal: Embedding fun g => (ContinuousMap.sigmaMk g.fst).comp g.snd

full_name: ContinuousMap.exists_lift_sigma
code: /-- Every continuous map from a connected topological space to the disjoint union of a family of
topological spaces is a composition of the embedding `ContinuousMap.sigmMk i : C(Y i, Σ i, Y i)` for
some `i` and a continuous map `g : C(X, Y i)`. See also `Continuous.exists_lift_sigma` for a version
with unbundled functions and `ContinuousMap.sigmaCodHomeomorph` for a homeomorphism defined using
this fact. -/
theorem exists_lift_sigma (f : C(X, Σ i, Y i)) : ∃ i g, f = (sigmaMk i).comp g 
goal: ∃ i g, f = (ContinuousMap.sigmaMk i).comp g

full_name: ContinuousMap.sigmaCodHomeomorph
code: /-- Homeomorphism between the type `C(X, Σ i, Y i)` of continuous maps from a connected topological
space to the disjoint union of a family of topological spaces and the disjoint union of the types of
continuous maps `C(X, Y i)`.

The inverse map sends `⟨i, g⟩` to `ContinuousMap.comp (ContinuousMap.sigmaMk i) g`. -/
@[simps! symm_apply]
def sigmaCodHomeomorph : C(X, Σ i, Y i) ≃ₜ Σ i, C(X, Y i) 
goal: C(X, (i : ι) × Y i) ≃ₜ (i : ι) × C(X, Y i)

full_name: ContinuousMap.sigmaCodHomeomorph_symm_apply
code: /-- Homeomorphism between the type `C(X, Σ i, Y i)` of continuous maps from a connected topological
space to the disjoint union of a family of topological spaces and the disjoint union of the types of
continuous maps `C(X, Y i)`.

The inverse map sends `⟨i, g⟩` to `ContinuousMap.comp (ContinuousMap.sigmaMk i) g`. -/
@[simps! symm_apply]
def sigmaCodHomeomorph : C(X, Σ i, Y i) ≃ₜ Σ i, C(X, Y i) 
goal: ∀ (a : (i : ι) × C(X, Y i)), (ContinuousMap.sigmaCodHomeomorph X Y).symm a = (ContinuousMap.sigmaMk a.fst).comp a.snd
File: Mathlib/Topology/Separation/NotNormal.lean

full_name: IsClosed.mk_lt_continuum
code: /-- Let `s` be a closed set in a separable normal space. If the induced topology on `s` is discrete,
then `s` has cardinality less than continuum.

The proof follows
https://en.wikipedia.org/wiki/Moore_plane#Proof_that_the_Moore_plane_is_not_normal -/
theorem IsClosed.mk_lt_continuum [NormalSpace X] {s : Set X} (hs : IsClosed s)
    [DiscreteTopology s] : #s < 𝔠 
goal: #↑s < 𝔠

full_name: IsClosed.not_normal_of_continuum_le_mk
code: /-- Let `s` be a closed set in a separable space. If the induced topology on `s` is discrete and `s`
has cardinality at least continuum, then the ambient space is not a normal space. -/
theorem IsClosed.not_normal_of_continuum_le_mk {s : Set X} (hs : IsClosed s) [DiscreteTopology s]
    (hmk : 𝔠 ≤ #s) : ¬NormalSpace X 
goal: ¬NormalSpace X
File: Mathlib/Topology/ContinuousFunction/Weierstrass.lean

full_name: polynomialFunctions_closure_eq_top'
code: /-- The special case of the Weierstrass approximation theorem for the interval `[0,1]`.
This is just a matter of unravelling definitions and using the Bernstein approximations.
-/
theorem polynomialFunctions_closure_eq_top' : (polynomialFunctions I).topologicalClosure = ⊤ 
goal: (polynomialFunctions I).topologicalClosure = ⊤

full_name: polynomialFunctions_closure_eq_top
code: /-- The **Weierstrass Approximation Theorem**:
polynomials functions on `[a, b] ⊆ ℝ` are dense in `C([a,b],ℝ)`

(While we could deduce this as an application of the Stone-Weierstrass theorem,
our proof of that relies on the fact that `abs` is in the closure of polynomials on `[-M, M]`,
so we may as well get this done first.)
-/
theorem polynomialFunctions_closure_eq_top (a b : ℝ) :
    (polynomialFunctions (Set.Icc a b)).topologicalClosure = ⊤ 
goal: (polynomialFunctions (Set.Icc a b)).topologicalClosure = ⊤

full_name: continuousMap_mem_polynomialFunctions_closure
code: /-- An alternative statement of Weierstrass' theorem.

Every real-valued continuous function on `[a,b]` is a uniform limit of polynomials.
-/
theorem continuousMap_mem_polynomialFunctions_closure (a b : ℝ) (f : C(Set.Icc a b, ℝ)) :
    f ∈ (polynomialFunctions (Set.Icc a b)).topologicalClosure 
goal: f ∈ (polynomialFunctions (Set.Icc a b)).topologicalClosure

full_name: exists_polynomial_near_continuousMap
code: /-- An alternative statement of Weierstrass' theorem,
for those who like their epsilons.

Every real-valued continuous function on `[a,b]` is within any `ε > 0` of some polynomial.
-/
theorem exists_polynomial_near_continuousMap (a b : ℝ) (f : C(Set.Icc a b, ℝ)) (ε : ℝ)
    (pos : 0 < ε) : ∃ p : ℝ[X], ‖p.toContinuousMapOn _ - f‖ < ε 
goal: ∃ p, ‖p.toContinuousMapOn (Set.Icc a b) - f‖ < ε

full_name: exists_polynomial_near_of_continuousOn
code: /-- Another alternative statement of Weierstrass's theorem,
for those who like epsilons, but not bundled continuous functions.

Every real-valued function `ℝ → ℝ` which is continuous on `[a,b]`
can be approximated to within any `ε > 0` on `[a,b]` by some polynomial.
-/
theorem exists_polynomial_near_of_continuousOn (a b : ℝ) (f : ℝ → ℝ)
    (c : ContinuousOn f (Set.Icc a b)) (ε : ℝ) (pos : 0 < ε) :
    ∃ p : ℝ[X], ∀ x ∈ Set.Icc a b, |p.eval x - f x| < ε 
goal: ∃ p, ∀ x ∈ Set.Icc a b, |Polynomial.eval x p - f x| < ε
File: Mathlib/Topology/ContinuousFunction/StarOrdered.lean

full_name: ContinuousMap.starOrderedRing_of_sqrt
code: lemma starOrderedRing_of_sqrt {R : Type*} [PartialOrder R] [NonUnitalRing R] [StarRing R]
    [StarOrderedRing R] [TopologicalSpace R] [ContinuousStar R] [TopologicalRing R]
    (sqrt : R → R) (h_continuousOn : ContinuousOn sqrt {x : R | 0 ≤ x})
    (h_sqrt : ∀ x, 0 ≤ x → star (sqrt x) * sqrt x = x) : StarOrderedRing C(α, R) 
goal: StarOrderedRing C(α, R)

full_name: ContinuousMap.instStarOrderedRingRCLike
code: instance (priority := 100) instStarOrderedRingRCLike {𝕜 : Type*} [RCLike 𝕜] :
    StarOrderedRing C(α, 𝕜) 
goal: StarOrderedRing C(α, 𝕜)

full_name: ContinuousMap.instStarOrderedRingReal
code: instance instStarOrderedRingReal : StarOrderedRing C(α, ℝ) 
goal: StarOrderedRing C(α, ℝ)

full_name: ContinuousMap.instStarOrderedRingComplex
code: instance instStarOrderedRingComplex : StarOrderedRing C(α, ℂ) 
goal: StarOrderedRing C(α, ℂ)

full_name: ContinuousMap.instStarOrderedRingNNReal
code: instance instStarOrderedRingNNReal : StarOrderedRing C(α, ℝ≥0) 
goal: StarOrderedRing C(α, ℝ≥0)

full_name: ContinuousMapZero.instStarOrderedRing
code: instance instStarOrderedRing {R : Type*}
    [TopologicalSpace R] [OrderedCommSemiring R] [NoZeroDivisors R] [StarRing R] [StarOrderedRing R]
    [TopologicalSemiring R] [ContinuousStar R] [StarOrderedRing C(α, R)] :
    StarOrderedRing C(α, R)₀ 
goal: StarOrderedRing (ContinuousMapZero α R)

full_name: ContinuousMapZero.instStarOrderedRingReal
code: instance instStarOrderedRingReal : StarOrderedRing C(α, ℝ)₀ 
goal: StarOrderedRing (ContinuousMapZero α ℝ)

full_name: ContinuousMapZero.instStarOrderedRingComplex
code: instance instStarOrderedRingComplex : StarOrderedRing C(α, ℂ)₀ 
goal: StarOrderedRing (ContinuousMapZero α ℂ)

full_name: ContinuousMapZero.instStarOrderedRingNNReal
code: instance instStarOrderedRingNNReal : StarOrderedRing C(α, ℝ≥0)₀ 
goal: StarOrderedRing (ContinuousMapZero α ℝ≥0)
File: Mathlib/Topology/Metrizable/ContinuousMap.lean

full_name: ContinuousMap.instPseudoMetrizableSpace
code: instance [PseudoMetrizableSpace Y] : PseudoMetrizableSpace C(X, Y) 
goal: TopologicalSpace.PseudoMetrizableSpace C(X, Y)

full_name: ContinuousMap.instMetrizableSpace
code: instance [MetrizableSpace Y] : MetrizableSpace C(X, Y) 
goal: TopologicalSpace.MetrizableSpace C(X, Y)
File: Mathlib/Topology/Metrizable/Urysohn.lean

full_name: TopologicalSpace.exists_inducing_l_infty
code: /-- For a regular topological space with second countable topology,
there exists an inducing map to `l^∞ = ℕ →ᵇ ℝ`. -/
theorem exists_inducing_l_infty : ∃ f : X → ℕ →ᵇ ℝ, Inducing f 
goal: ∃ f, Inducing f

full_name: TopologicalSpace.PseudoMetrizableSpace.of_regularSpace_secondCountableTopology
code: /-- *Urysohn's metrization theorem* (Tychonoff's version):
a regular topological space with second countable topology `X` is metrizable,
i.e., there exists a pseudometric space structure that generates the same topology. -/
instance (priority := 90) PseudoMetrizableSpace.of_regularSpace_secondCountableTopology :
    PseudoMetrizableSpace X 
goal: TopologicalSpace.PseudoMetrizableSpace X

full_name: TopologicalSpace.exists_embedding_l_infty
code: /-- A T₃ topological space with second countable topology can be embedded into `l^∞ = ℕ →ᵇ ℝ`. -/
theorem exists_embedding_l_infty : ∃ f : X → ℕ →ᵇ ℝ, Embedding f 
goal: ∃ f, Embedding f

full_name: TopologicalSpace.metrizableSpace_of_t3_second_countable
code: /-- *Urysohn's metrization theorem* (Tychonoff's version): a T₃ topological space with second
countable topology `X` is metrizable, i.e., there exists a metric space structure that generates the
same topology. -/
instance (priority := 90) metrizableSpace_of_t3_second_countable : MetrizableSpace X 
goal: TopologicalSpace.MetrizableSpace X
File: Mathlib/Topology/Algebra/Order/Group.lean

full_name: LinearOrderedAddCommGroup.topologicalAddGroup
code: instance (priority := 100) LinearOrderedAddCommGroup.topologicalAddGroup :
    TopologicalAddGroup G 
goal: TopologicalAddGroup G

full_name: continuous_abs
code: @[continuity]
theorem continuous_abs : Continuous (abs : G → G) 
goal: Continuous abs

full_name: Filter.Tendsto.abs
code: protected theorem Filter.Tendsto.abs {a : G} (h : Tendsto f l (𝓝 a)) :
    Tendsto (fun x => |f x|) l (𝓝 |a|) 
goal: Filter.Tendsto (fun x => |f x|) l (𝓝 |a|)

full_name: tendsto_zero_iff_abs_tendsto_zero
code: theorem tendsto_zero_iff_abs_tendsto_zero (f : α → G) :
    Tendsto f l (𝓝 0) ↔ Tendsto (abs ∘ f) l (𝓝 0) 
goal: Filter.Tendsto f l (𝓝 0) ↔ Filter.Tendsto (abs ∘ f) l (𝓝 0)

full_name: Continuous.abs
code: @[fun_prop]
protected theorem Continuous.abs (h : Continuous f) : Continuous fun x => |f x| 
goal: Continuous fun x => |f x|

full_name: ContinuousAt.abs
code: @[fun_prop]
protected theorem ContinuousAt.abs (h : ContinuousAt f a) : ContinuousAt (fun x => |f x|) a 
goal: ContinuousAt (fun x => |f x|) a

full_name: ContinuousWithinAt.abs
code: protected theorem ContinuousWithinAt.abs (h : ContinuousWithinAt f s a) :
    ContinuousWithinAt (fun x => |f x|) s a 
goal: ContinuousWithinAt (fun x => |f x|) s a

full_name: ContinuousOn.abs
code: @[fun_prop]
protected theorem ContinuousOn.abs (h : ContinuousOn f s) : ContinuousOn (fun x => |f x|) s 
goal: ContinuousOn (fun x => |f x|) s

full_name: tendsto_abs_nhdsWithin_zero
code: theorem tendsto_abs_nhdsWithin_zero : Tendsto (abs : G → G) (𝓝[≠] 0) (𝓝[>] 0) 
goal: Filter.Tendsto abs (𝓝[≠] 0) (𝓝[>] 0)
File: Mathlib/Topology/Algebra/Order/Rolle.lean

full_name: exists_Ioo_extr_on_Icc
code: /-- A continuous function on a closed interval with `f a = f b`
takes either its maximum or its minimum value at a point in the interior of the interval. -/
theorem exists_Ioo_extr_on_Icc (hab : a < b) (hfc : ContinuousOn f (Icc a b)) (hfI : f a = f b) :
    ∃ c ∈ Ioo a b, IsExtrOn f (Icc a b) c 
goal: ∃ c ∈ Set.Ioo a b, IsExtrOn f (Set.Icc a b) c

full_name: exists_isLocalExtr_Ioo
code: /-- A continuous function on a closed interval with `f a = f b`
has a local extremum at some point of the corresponding open interval. -/
theorem exists_isLocalExtr_Ioo (hab : a < b) (hfc : ContinuousOn f (Icc a b)) (hfI : f a = f b) :
    ∃ c ∈ Ioo a b, IsLocalExtr f c 
goal: ∃ c ∈ Set.Ioo a b, IsLocalExtr f c

full_name: exists_isExtrOn_Ioo_of_tendsto
code: /-- If a function `f` is continuous on an open interval
and tends to the same value at its endpoints, then it has an extremum on this open interval. -/
lemma exists_isExtrOn_Ioo_of_tendsto (hab : a < b) (hfc : ContinuousOn f (Ioo a b))
    (ha : Tendsto f (𝓝[>] a) (𝓝 l)) (hb : Tendsto f (𝓝[<] b) (𝓝 l)) :
    ∃ c ∈ Ioo a b, IsExtrOn f (Ioo a b) c 
goal: ∃ c ∈ Set.Ioo a b, IsExtrOn f (Set.Ioo a b) c

full_name: exists_isLocalExtr_Ioo_of_tendsto
code: /-- If a function `f` is continuous on an open interval
and tends to the same value at its endpoints,
then it has a local extremum on this open interval. -/
lemma exists_isLocalExtr_Ioo_of_tendsto (hab : a < b) (hfc : ContinuousOn f (Ioo a b))
    (ha : Tendsto f (𝓝[>] a) (𝓝 l)) (hb : Tendsto f (𝓝[<] b) (𝓝 l)) :
    ∃ c ∈ Ioo a b, IsLocalExtr f c 
goal: ∃ c ∈ Set.Ioo a b, IsLocalExtr f c
File: Mathlib/Topology/Algebra/Valued/NormedValued.lean

full_name: NormedField.valuation
code: /-- The valuation on a nonarchimedean normed field `K` defined as `nnnorm`. -/
def valuation : Valuation K ℝ≥0 
goal: Valuation K ℝ≥0

full_name: NormedField.valuation_apply
code: theorem valuation_apply (x : K) : valuation h x = ‖x‖₊ 
goal: (NormedField.valuation h) x = ‖x‖₊

full_name: NormedField.toValued
code: /-- The valued field structure on a nonarchimedean normed field `K`, determined by the norm. -/
def toValued : Valued K ℝ≥0 
goal: Valued K ℝ≥0

full_name: Valued.norm
code: /-- The norm function determined by a rank one valuation on a field `L`. -/
def norm : L → ℝ 
goal: L → ℝ

full_name: Valued.norm_nonneg
code: theorem norm_nonneg (x : L) : 0 ≤ norm x 
goal: 0 ≤ Valued.norm x

full_name: Valued.norm_add_le
code: theorem norm_add_le (x y : L) : norm (x + y) ≤ max (norm x) (norm y) 
goal: Valued.norm (x + y) ≤ max (Valued.norm x) (Valued.norm y)

full_name: Valued.norm_eq_zero
code: theorem norm_eq_zero {x : L} (hx : norm x = 0) : x = 0 
goal: x = 0

full_name: Valued.toNormedField
code: /-- The normed field structure determined by a rank one valuation. -/
def toNormedField : NormedField L 
goal: NormedField L
File: Mathlib/Topology/Algebra/Order/Archimedean.lean

full_name: Rat.denseRange_cast
code: /-- Rational numbers are dense in a linear ordered archimedean field. -/
theorem Rat.denseRange_cast {𝕜} [LinearOrderedField 𝕜] [TopologicalSpace 𝕜] [OrderTopology 𝕜]
    [Archimedean 𝕜] : DenseRange ((↑) : ℚ → 𝕜) 
goal: DenseRange Rat.cast

full_name: AddSubgroup.dense_of_not_isolated_zero
code: /-- An additive subgroup of an archimedean linear ordered additive commutative group with order
topology is dense provided that for all positive `ε` there exists a positive element of the
subgroup that is less than `ε`. -/
theorem dense_of_not_isolated_zero (S : AddSubgroup G) (hS : ∀ ε > 0, ∃ g ∈ S, g ∈ Ioo 0 ε) :
    Dense (S : Set G) 
goal: Dense ↑S

full_name: AddSubgroup.dense_of_no_min
code: /-- Let `S` be a nontrivial additive subgroup in an archimedean linear ordered additive commutative
group `G` with order topology. If the set of positive elements of `S` does not have a minimal
element, then `S` is dense `G`. -/
theorem dense_of_no_min (S : AddSubgroup G) (hbot : S ≠ ⊥)
    (H : ¬∃ a : G, IsLeast { g : G | g ∈ S ∧ 0 < g } a) : Dense (S : Set G) 
goal: Dense ↑S

full_name: AddSubgroup.dense_or_cyclic
code: /-- An additive subgroup of an archimedean linear ordered additive commutative group `G` with order
topology either is dense in `G` or is a cyclic subgroup. -/
theorem dense_or_cyclic (S : AddSubgroup G) : Dense (S : Set G) ∨ ∃ a : G, S = closure {a} 
goal: Dense ↑S ∨ ∃ a, S = AddSubgroup.closure {a}
File: Mathlib/Topology/Algebra/InfiniteSum/GroupCompletion.lean

full_name: hasSum_iff_hasSum_compl
code: /-- A function `f` has a sum in an uniform additive group `α` if and only if it has that sum in the
completion of `α`. -/
theorem hasSum_iff_hasSum_compl (f : β → α) (a : α) :
    HasSum (toCompl ∘ f) a ↔ HasSum f a 
goal: HasSum (⇑UniformSpace.Completion.toCompl ∘ f) (↑α a) ↔ HasSum f a

full_name: summable_iff_summable_compl_and_tsum_mem
code: /-- A function `f` is summable in a uniform additive group `α` if and only if it is summable in
`Completion α` and its sum in `Completion α` lies in the range of `toCompl : α →+ Completion α`. -/
theorem summable_iff_summable_compl_and_tsum_mem (f : β → α) :
    Summable f ↔ Summable (toCompl ∘ f) ∧ ∑' i, toCompl (f i) ∈ Set.range toCompl 
goal: Summable f ↔
  Summable (⇑UniformSpace.Completion.toCompl ∘ f) ∧
    ∑' (i : β), UniformSpace.Completion.toCompl (f i) ∈ Set.range ⇑UniformSpace.Completion.toCompl

full_name: summable_iff_cauchySeq_finset_and_tsum_mem
code: /-- A function `f` is summable in a uniform additive group `α` if and only if the net of its partial
sums is Cauchy and its sum in `Completion α` lies in the range of `toCompl : α →+ Completion α`.
(The condition that the net of partial sums is Cauchy can be checked using
`cauchySeq_finset_iff_sum_vanishing` or `cauchySeq_finset_iff_tsum_vanishing`.) -/
theorem summable_iff_cauchySeq_finset_and_tsum_mem (f : β → α) :
    Summable f ↔ CauchySeq (fun s : Finset β ↦ ∑ b in s, f b) ∧
      ∑' i, toCompl (f i) ∈ Set.range toCompl 
goal: Summable f ↔
  (CauchySeq fun s => ∑ b ∈ s, f b) ∧
    ∑' (i : β), UniformSpace.Completion.toCompl (f i) ∈ Set.range ⇑UniformSpace.Completion.toCompl

full_name: Summable.toCompl_tsum
code: /-- If a function `f` is summable in a uniform additive group `α`, then its sum in `α` is the same
as its sum in `Completion α`. -/
theorem Summable.toCompl_tsum {f : β → α} (hf : Summable f) : ∑' i, toCompl (f i) = ∑' i, f i 
goal: ∑' (i : β), UniformSpace.Completion.toCompl (f i) = ↑α (∑' (i : β), f i)
File: Mathlib/Topology/Algebra/Module/Simple.lean

full_name: LinearMap.isClosed_or_dense_ker
code: /-- The kernel of a linear map taking values in a simple module over the base ring is closed or
dense. Applies, e.g., to the case when `R = N` is a division ring. -/
theorem LinearMap.isClosed_or_dense_ker (l : M →ₗ[R] N) :
    IsClosed (LinearMap.ker l : Set M) ∨ Dense (LinearMap.ker l : Set M) 
goal: IsClosed ↑(LinearMap.ker l) ∨ Dense ↑(LinearMap.ker l)
File: Mathlib/Topology/Algebra/Module/Determinant.lean

full_name: ContinuousLinearMap.det
code: /-- The determinant of a continuous linear map, mainly as a convenience device to be able to
write `A.det` instead of `(A : M →ₗ[R] M).det`. -/
noncomputable abbrev det {R : Type*} [CommRing R] {M : Type*} [TopologicalSpace M] [AddCommGroup M]
    [Module R M] (A : M →L[R] M) : R 
goal: R

full_name: ContinuousLinearEquiv.det_coe_symm
code: @[simp]
theorem det_coe_symm {R : Type*} [Field R] {M : Type*} [TopologicalSpace M] [AddCommGroup M]
    [Module R M] (A : M ≃L[R] M) : (A.symm : M →L[R] M).det = (A : M →L[R] M).det⁻¹ 
goal: (↑A.symm).det = (↑A).det⁻¹