File: Mathlib/Topology/Algebra/UniformGroup.lean

full_name: UniformGroup.uniformContinuous_div
code: /-- A uniform group is a group in which multiplication and inversion are uniformly continuous. -/
class UniformGroup (α : Type*) [UniformSpace α] [Group α] : Prop where
  uniformContinuous_div : UniformContinuous fun p : α × α => p.1 / p.2
goal: UniformContinuous fun p => p.1 / p.2

full_name: UniformGroup
code: /-- A uniform group is a group in which multiplication and inversion are uniformly continuous. -/
class UniformGroup (α : Type*) [UniformSpace α] [Group α] : Prop where
  uniformContinuous_div : UniformContinuous fun p : α × α => p.1 / p.2
goal: Prop

full_name: UniformAddGroup.uniformContinuous_sub
code: /-- A uniform additive group is an additive group in which addition
  and negation are uniformly continuous. -/
class UniformAddGroup (α : Type*) [UniformSpace α] [AddGroup α] : Prop where
  uniformContinuous_sub : UniformContinuous fun p : α × α => p.1 - p.2
goal: UniformContinuous fun p => p.1 - p.2

full_name: UniformAddGroup
code: /-- A uniform additive group is an additive group in which addition
  and negation are uniformly continuous. -/
class UniformAddGroup (α : Type*) [UniformSpace α] [AddGroup α] : Prop where
  uniformContinuous_sub : UniformContinuous fun p : α × α => p.1 - p.2
goal: Prop

full_name: UniformGroup.mk'
code: @[to_additive]
theorem UniformGroup.mk' {α} [UniformSpace α] [Group α]
    (h₁ : UniformContinuous fun p : α × α => p.1 * p.2) (h₂ : UniformContinuous fun p : α => p⁻¹) :
    UniformGroup α 
goal: UniformGroup α

full_name: UniformAddGroup.mk'
code: @[to_additive]
theorem UniformGroup.mk' {α} [UniformSpace α] [Group α]
    (h₁ : UniformContinuous fun p : α × α => p.1 * p.2) (h₂ : UniformContinuous fun p : α => p⁻¹) :
    UniformGroup α 
goal: UniformAddGroup α

full_name: uniformContinuous_div
code: @[to_additive]
theorem uniformContinuous_div : UniformContinuous fun p : α × α => p.1 / p.2 
goal: UniformContinuous fun p => p.1 / p.2

full_name: uniformContinuous_sub
code: @[to_additive]
theorem uniformContinuous_div : UniformContinuous fun p : α × α => p.1 / p.2 
goal: UniformContinuous fun p => p.1 - p.2

full_name: UniformContinuous.div
code: @[to_additive]
theorem UniformContinuous.div [UniformSpace β] {f : β → α} {g : β → α} (hf : UniformContinuous f)
    (hg : UniformContinuous g) : UniformContinuous fun x => f x / g x 
goal: UniformContinuous fun x => f x / g x

full_name: UniformContinuous.sub
code: @[to_additive]
theorem UniformContinuous.div [UniformSpace β] {f : β → α} {g : β → α} (hf : UniformContinuous f)
    (hg : UniformContinuous g) : UniformContinuous fun x => f x / g x 
goal: UniformContinuous fun x => f x - g x

full_name: UniformContinuous.inv
code: @[to_additive]
theorem UniformContinuous.inv [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
    UniformContinuous fun x => (f x)⁻¹ 
goal: UniformContinuous fun x => (f x)⁻¹

full_name: UniformContinuous.neg
code: @[to_additive]
theorem UniformContinuous.inv [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
    UniformContinuous fun x => (f x)⁻¹ 
goal: UniformContinuous fun x => -f x

full_name: uniformContinuous_inv
code: @[to_additive]
theorem uniformContinuous_inv : UniformContinuous fun x : α => x⁻¹ 
goal: UniformContinuous fun x => x⁻¹

full_name: uniformContinuous_neg
code: @[to_additive]
theorem uniformContinuous_inv : UniformContinuous fun x : α => x⁻¹ 
goal: UniformContinuous fun x => -x

full_name: UniformContinuous.add
code: @[to_additive]
theorem UniformContinuous.mul [UniformSpace β] {f : β → α} {g : β → α} (hf : UniformContinuous f)
    (hg : UniformContinuous g) : UniformContinuous fun x => f x * g x 
goal: UniformContinuous fun x => f x + g x

full_name: UniformContinuous.mul
code: @[to_additive]
theorem UniformContinuous.mul [UniformSpace β] {f : β → α} {g : β → α} (hf : UniformContinuous f)
    (hg : UniformContinuous g) : UniformContinuous fun x => f x * g x 
goal: UniformContinuous fun x => f x * g x

full_name: uniformContinuous_add
code: @[to_additive]
theorem uniformContinuous_mul : UniformContinuous fun p : α × α => p.1 * p.2 
goal: UniformContinuous fun p => p.1 + p.2

full_name: uniformContinuous_mul
code: @[to_additive]
theorem uniformContinuous_mul : UniformContinuous fun p : α × α => p.1 * p.2 
goal: UniformContinuous fun p => p.1 * p.2

full_name: UniformContinuous.const_nsmul
code: @[to_additive UniformContinuous.const_nsmul]
theorem UniformContinuous.pow_const [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
    ∀ n : ℕ, UniformContinuous fun x => f x ^ n
  
goal: UniformContinuous fun x => n • f x

full_name: UniformContinuous.pow_const
code: @[to_additive UniformContinuous.const_nsmul]
theorem UniformContinuous.pow_const [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
    ∀ n : ℕ, UniformContinuous fun x => f x ^ n
  
goal: UniformContinuous fun x => f x ^ n

full_name: uniformContinuous_const_nsmul
code: @[to_additive uniformContinuous_const_nsmul]
theorem uniformContinuous_pow_const (n : ℕ) : UniformContinuous fun x : α => x ^ n 
goal: UniformContinuous fun x => n • x

full_name: uniformContinuous_pow_const
code: @[to_additive uniformContinuous_const_nsmul]
theorem uniformContinuous_pow_const (n : ℕ) : UniformContinuous fun x : α => x ^ n 
goal: UniformContinuous fun x => x ^ n

full_name: UniformContinuous.const_zsmul
code: @[to_additive UniformContinuous.const_zsmul]
theorem UniformContinuous.zpow_const [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
    ∀ n : ℤ, UniformContinuous fun x => f x ^ n
  
goal: UniformContinuous fun x => n • f x

full_name: UniformContinuous.zpow_const
code: @[to_additive UniformContinuous.const_zsmul]
theorem UniformContinuous.zpow_const [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
    ∀ n : ℤ, UniformContinuous fun x => f x ^ n
  
goal: UniformContinuous fun x => f x ^ n

full_name: uniformContinuous_zpow_const
code: @[to_additive uniformContinuous_const_zsmul]
theorem uniformContinuous_zpow_const (n : ℤ) : UniformContinuous fun x : α => x ^ n 
goal: UniformContinuous fun x => x ^ n

full_name: uniformContinuous_const_zsmul
code: @[to_additive uniformContinuous_const_zsmul]
theorem uniformContinuous_zpow_const (n : ℤ) : UniformContinuous fun x : α => x ^ n 
goal: UniformContinuous fun x => n • x

full_name: UniformAddGroup.to_topologicalAddGroup
code: @[to_additive]
instance (priority := 10) UniformGroup.to_topologicalGroup : TopologicalGroup α 
goal: TopologicalAddGroup α

full_name: UniformGroup.to_topologicalGroup
code: @[to_additive]
instance (priority := 10) UniformGroup.to_topologicalGroup : TopologicalGroup α 
goal: TopologicalGroup α

full_name: instUniformAddGroupSum
code: @[to_additive]
instance [UniformSpace β] [Group β] [UniformGroup β] : UniformGroup (α × β) 
goal: UniformAddGroup (α × β)

full_name: instUniformGroupProd
code: @[to_additive]
instance [UniformSpace β] [Group β] [UniformGroup β] : UniformGroup (α × β) 
goal: UniformGroup (α × β)

full_name: Pi.instUniformAddGroup
code: @[to_additive]
instance Pi.instUniformGroup {ι : Type*} {G : ι → Type*} [∀ i, UniformSpace (G i)]
    [∀ i, Group (G i)] [∀ i, UniformGroup (G i)] : UniformGroup (∀ i, G i) 
goal: UniformAddGroup ((i : ι) → G i)

full_name: Pi.instUniformGroup
code: @[to_additive]
instance Pi.instUniformGroup {ι : Type*} {G : ι → Type*} [∀ i, UniformSpace (G i)]
    [∀ i, Group (G i)] [∀ i, UniformGroup (G i)] : UniformGroup (∀ i, G i) 
goal: UniformGroup ((i : ι) → G i)

full_name: uniformity_translate_add
code: @[to_additive]
theorem uniformity_translate_mul (a : α) : ((𝓤 α).map fun x : α × α => (x.1 * a, x.2 * a)) = 𝓤 α 
goal: Filter.map (fun x => (x.1 + a, x.2 + a)) (𝓤 α) = 𝓤 α

full_name: uniformity_translate_mul
code: @[to_additive]
theorem uniformity_translate_mul (a : α) : ((𝓤 α).map fun x : α × α => (x.1 * a, x.2 * a)) = 𝓤 α 
goal: Filter.map (fun x => (x.1 * a, x.2 * a)) (𝓤 α) = 𝓤 α

full_name: uniformEmbedding_translate_add
code: @[to_additive]
theorem uniformEmbedding_translate_mul (a : α) : UniformEmbedding fun x : α => x * a 
goal: UniformEmbedding fun x => x + a

full_name: uniformEmbedding_translate_mul
code: @[to_additive]
theorem uniformEmbedding_translate_mul (a : α) : UniformEmbedding fun x : α => x * a 
goal: UniformEmbedding fun x => x * a

full_name: AddOpposite.instUniformAddGroup
code: @[to_additive]
instance : UniformGroup αᵐᵒᵖ 
goal: UniformAddGroup αᵃᵒᵖ

full_name: MulOpposite.instUniformGroup
code: @[to_additive]
instance : UniformGroup αᵐᵒᵖ 
goal: UniformGroup αᵐᵒᵖ

full_name: uniformAddGroup_sInf
code: @[to_additive]
theorem uniformGroup_sInf {us : Set (UniformSpace β)} (h : ∀ u ∈ us, @UniformGroup β u _) :
    @UniformGroup β (sInf us) _ 
goal: UniformAddGroup β

full_name: uniformGroup_sInf
code: @[to_additive]
theorem uniformGroup_sInf {us : Set (UniformSpace β)} (h : ∀ u ∈ us, @UniformGroup β u _) :
    @UniformGroup β (sInf us) _ 
goal: UniformGroup β

full_name: uniformGroup_iInf
code: @[to_additive]
theorem uniformGroup_iInf {ι : Sort*} {us' : ι → UniformSpace β}
    (h' : ∀ i, @UniformGroup β (us' i) _) : @UniformGroup β (⨅ i, us' i) _ 
goal: UniformGroup β

full_name: uniformAddGroup_iInf
code: @[to_additive]
theorem uniformGroup_iInf {ι : Sort*} {us' : ι → UniformSpace β}
    (h' : ∀ i, @UniformGroup β (us' i) _) : @UniformGroup β (⨅ i, us' i) _ 
goal: UniformAddGroup β

full_name: uniformGroup_inf
code: @[to_additive]
theorem uniformGroup_inf {u₁ u₂ : UniformSpace β} (h₁ : @UniformGroup β u₁ _)
    (h₂ : @UniformGroup β u₂ _) : @UniformGroup β (u₁ ⊓ u₂) _ 
goal: UniformGroup β

full_name: uniformAddGroup_inf
code: @[to_additive]
theorem uniformGroup_inf {u₁ u₂ : UniformSpace β} (h₁ : @UniformGroup β u₁ _)
    (h₂ : @UniformGroup β u₂ _) : @UniformGroup β (u₁ ⊓ u₂) _ 
goal: UniformAddGroup β

full_name: UniformInducing.uniformAddGroup
code: @[to_additive]
lemma UniformInducing.uniformGroup {γ : Type*} [Group γ] [UniformSpace γ] [UniformGroup γ]
    [UniformSpace β] {F : Type*} [FunLike F β γ] [MonoidHomClass F β γ]
    (f : F) (hf : UniformInducing f) :
    UniformGroup β 
goal: UniformAddGroup β

full_name: UniformInducing.uniformGroup
code: @[to_additive]
lemma UniformInducing.uniformGroup {γ : Type*} [Group γ] [UniformSpace γ] [UniformGroup γ]
    [UniformSpace β] {F : Type*} [FunLike F β γ] [MonoidHomClass F β γ]
    (f : F) (hf : UniformInducing f) :
    UniformGroup β 
goal: UniformGroup β

full_name: UniformGroup.comap
code: @[to_additive]
protected theorem UniformGroup.comap {γ : Type*} [Group γ] {u : UniformSpace γ} [UniformGroup γ]
    {F : Type*} [FunLike F β γ] [MonoidHomClass F β γ] (f : F) : @UniformGroup β (u.comap f) _ 
goal: UniformGroup β

full_name: UniformAddGroup.comap
code: @[to_additive]
protected theorem UniformGroup.comap {γ : Type*} [Group γ] {u : UniformSpace γ} [UniformGroup γ]
    {F : Type*} [FunLike F β γ] [MonoidHomClass F β γ] (f : F) : @UniformGroup β (u.comap f) _ 
goal: UniformAddGroup β

full_name: Subgroup.uniformGroup
code: @[to_additive]
instance uniformGroup (S : Subgroup α) : UniformGroup S 
goal: UniformGroup ↥S

full_name: AddSubgroup.uniformAddGroup
code: @[to_additive]
instance uniformGroup (S : Subgroup α) : UniformGroup S 
goal: UniformAddGroup ↥S

full_name: uniformity_eq_comap_nhds_zero
code: @[to_additive]
theorem uniformity_eq_comap_nhds_one : 𝓤 α = comap (fun x : α × α => x.2 / x.1) (𝓝 (1 : α)) 
goal: 𝓤 α = Filter.comap (fun x => x.2 - x.1) (𝓝 0)

full_name: uniformity_eq_comap_nhds_one
code: @[to_additive]
theorem uniformity_eq_comap_nhds_one : 𝓤 α = comap (fun x : α × α => x.2 / x.1) (𝓝 (1 : α)) 
goal: 𝓤 α = Filter.comap (fun x => x.2 / x.1) (𝓝 1)

full_name: uniformity_eq_comap_nhds_one_swapped
code: @[to_additive]
theorem uniformity_eq_comap_nhds_one_swapped :
    𝓤 α = comap (fun x : α × α => x.1 / x.2) (𝓝 (1 : α)) 
goal: 𝓤 α = Filter.comap (fun x => x.1 / x.2) (𝓝 1)

full_name: uniformity_eq_comap_nhds_zero_swapped
code: @[to_additive]
theorem uniformity_eq_comap_nhds_one_swapped :
    𝓤 α = comap (fun x : α × α => x.1 / x.2) (𝓝 (1 : α)) 
goal: 𝓤 α = Filter.comap (fun x => x.1 - x.2) (𝓝 0)

full_name: UniformGroup.ext
code: @[to_additive]
theorem UniformGroup.ext {G : Type*} [Group G] {u v : UniformSpace G} (hu : @UniformGroup G u _)
    (hv : @UniformGroup G v _)
    (h : @nhds _ u.toTopologicalSpace 1 = @nhds _ v.toTopologicalSpace 1) : u = v 
goal: u = v

full_name: UniformAddGroup.ext
code: @[to_additive]
theorem UniformGroup.ext {G : Type*} [Group G] {u v : UniformSpace G} (hu : @UniformGroup G u _)
    (hv : @UniformGroup G v _)
    (h : @nhds _ u.toTopologicalSpace 1 = @nhds _ v.toTopologicalSpace 1) : u = v 
goal: u = v

full_name: UniformAddGroup.ext_iff
code: @[to_additive]
theorem UniformGroup.ext_iff {G : Type*} [Group G] {u v : UniformSpace G}
    (hu : @UniformGroup G u _) (hv : @UniformGroup G v _) :
    u = v ↔ @nhds _ u.toTopologicalSpace 1 = @nhds _ v.toTopologicalSpace 1 
goal: u = v ↔ 𝓝 0 = 𝓝 0

full_name: UniformGroup.ext_iff
code: @[to_additive]
theorem UniformGroup.ext_iff {G : Type*} [Group G] {u v : UniformSpace G}
    (hu : @UniformGroup G u _) (hv : @UniformGroup G v _) :
    u = v ↔ @nhds _ u.toTopologicalSpace 1 = @nhds _ v.toTopologicalSpace 1 
goal: u = v ↔ 𝓝 1 = 𝓝 1

full_name: UniformAddGroup.uniformity_countably_generated
code: @[to_additive]
theorem UniformGroup.uniformity_countably_generated [(𝓝 (1 : α)).IsCountablyGenerated] :
    (𝓤 α).IsCountablyGenerated 
goal: (𝓤 α).IsCountablyGenerated

full_name: UniformGroup.uniformity_countably_generated
code: @[to_additive]
theorem UniformGroup.uniformity_countably_generated [(𝓝 (1 : α)).IsCountablyGenerated] :
    (𝓤 α).IsCountablyGenerated 
goal: (𝓤 α).IsCountablyGenerated

full_name: uniformity_eq_comap_inv_mul_nhds_one
code: @[to_additive]
theorem uniformity_eq_comap_inv_mul_nhds_one :
    𝓤 α = comap (fun x : α × α => x.1⁻¹ * x.2) (𝓝 (1 : α)) 
goal: 𝓤 α = Filter.comap (fun x => x.1⁻¹ * x.2) (𝓝 1)

full_name: uniformity_eq_comap_neg_add_nhds_zero
code: @[to_additive]
theorem uniformity_eq_comap_inv_mul_nhds_one :
    𝓤 α = comap (fun x : α × α => x.1⁻¹ * x.2) (𝓝 (1 : α)) 
goal: 𝓤 α = Filter.comap (fun x => -x.1 + x.2) (𝓝 0)

full_name: uniformity_eq_comap_neg_add_nhds_zero_swapped
code: @[to_additive]
theorem uniformity_eq_comap_inv_mul_nhds_one_swapped :
    𝓤 α = comap (fun x : α × α => x.2⁻¹ * x.1) (𝓝 (1 : α)) 
goal: 𝓤 α = Filter.comap (fun x => -x.2 + x.1) (𝓝 0)

full_name: uniformity_eq_comap_inv_mul_nhds_one_swapped
code: @[to_additive]
theorem uniformity_eq_comap_inv_mul_nhds_one_swapped :
    𝓤 α = comap (fun x : α × α => x.2⁻¹ * x.1) (𝓝 (1 : α)) 
goal: 𝓤 α = Filter.comap (fun x => x.2⁻¹ * x.1) (𝓝 1)

full_name: Filter.HasBasis.uniformity_of_nhds_zero
code: @[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 } 
goal: (𝓤 α).HasBasis p fun i => {x | x.2 - x.1 ∈ U i}

full_name: Filter.HasBasis.uniformity_of_nhds_one
code: @[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 } 
goal: (𝓤 α).HasBasis p fun i => {x | x.2 / x.1 ∈ U i}

full_name: Filter.HasBasis.uniformity_of_nhds_one_inv_mul
code: @[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 } 
goal: (𝓤 α).HasBasis p fun i => {x | x.1⁻¹ * x.2 ∈ U i}

full_name: Filter.HasBasis.uniformity_of_nhds_zero_neg_add
code: @[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 } 
goal: (𝓤 α).HasBasis p fun i => {x | -x.1 + x.2 ∈ U i}

full_name: Filter.HasBasis.uniformity_of_nhds_one_swapped
code: @[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 } 
goal: (𝓤 α).HasBasis p fun i => {x | x.1 / x.2 ∈ U i}

full_name: Filter.HasBasis.uniformity_of_nhds_zero_swapped
code: @[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 } 
goal: (𝓤 α).HasBasis p fun i => {x | x.1 - x.2 ∈ U i}

full_name: Filter.HasBasis.uniformity_of_nhds_zero_neg_add_swapped
code: @[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 } 
goal: (𝓤 α).HasBasis p fun i => {x | -x.2 + x.1 ∈ U i}

full_name: Filter.HasBasis.uniformity_of_nhds_one_inv_mul_swapped
code: @[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 } 
goal: (𝓤 α).HasBasis p fun i => {x | x.2⁻¹ * x.1 ∈ U i}

full_name: uniformContinuous_of_tendsto_one
code: @[to_additive]
theorem uniformContinuous_of_tendsto_one {hom : Type*} [UniformSpace β] [Group β] [UniformGroup β]
    [FunLike hom α β] [MonoidHomClass hom α β] {f : hom} (h : Tendsto f (𝓝 1) (𝓝 1)) :
    UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: uniformContinuous_of_tendsto_zero
code: @[to_additive]
theorem uniformContinuous_of_tendsto_one {hom : Type*} [UniformSpace β] [Group β] [UniformGroup β]
    [FunLike hom α β] [MonoidHomClass hom α β] {f : hom} (h : Tendsto f (𝓝 1) (𝓝 1)) :
    UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: uniformContinuous_of_continuousAt_one
code: /-- 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`. -/
@[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`."]
theorem uniformContinuous_of_continuousAt_one {hom : Type*} [UniformSpace β] [Group β]
    [UniformGroup β] [FunLike hom α β] [MonoidHomClass hom α β]
    (f : hom) (hf : ContinuousAt f 1) :
    UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: uniformContinuous_of_continuousAt_zero
code: /-- 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`. -/
@[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`."]
theorem uniformContinuous_of_continuousAt_one {hom : Type*} [UniformSpace β] [Group β]
    [UniformGroup β] [FunLike hom α β] [MonoidHomClass hom α β]
    (f : hom) (hf : ContinuousAt f 1) :
    UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: MonoidHom.uniformContinuous_of_continuousAt_one
code: @[to_additive]
theorem MonoidHom.uniformContinuous_of_continuousAt_one [UniformSpace β] [Group β] [UniformGroup β]
    (f : α →* β) (hf : ContinuousAt f 1) : UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: AddMonoidHom.uniformContinuous_of_continuousAt_zero
code: @[to_additive]
theorem MonoidHom.uniformContinuous_of_continuousAt_one [UniformSpace β] [Group β] [UniformGroup β]
    (f : α →* β) (hf : ContinuousAt f 1) : UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: UniformGroup.uniformContinuous_iff_open_ker
code: /-- A homomorphism from a uniform group to a discrete uniform group is continuous if and only if
its kernel is open. -/
@[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."]
theorem UniformGroup.uniformContinuous_iff_open_ker {hom : Type*} [UniformSpace β]
    [DiscreteTopology β] [Group β] [UniformGroup β] [FunLike hom α β] [MonoidHomClass hom α β]
    {f : hom} :
    UniformContinuous f ↔ IsOpen ((f : α →* β).ker : Set α) 
goal: UniformContinuous ⇑f ↔ IsOpen ↑(↑f).ker

full_name: UniformAddGroup.uniformContinuous_iff_open_ker
code: /-- A homomorphism from a uniform group to a discrete uniform group is continuous if and only if
its kernel is open. -/
@[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."]
theorem UniformGroup.uniformContinuous_iff_open_ker {hom : Type*} [UniformSpace β]
    [DiscreteTopology β] [Group β] [UniformGroup β] [FunLike hom α β] [MonoidHomClass hom α β]
    {f : hom} :
    UniformContinuous f ↔ IsOpen ((f : α →* β).ker : Set α) 
goal: UniformContinuous ⇑f ↔ IsOpen ↑(↑f).ker

full_name: uniformContinuous_addMonoidHom_of_continuous
code: @[to_additive]
theorem uniformContinuous_monoidHom_of_continuous {hom : Type*} [UniformSpace β] [Group β]
    [UniformGroup β] [FunLike hom α β] [MonoidHomClass hom α β] {f : hom} (h : Continuous f) :
    UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: uniformContinuous_monoidHom_of_continuous
code: @[to_additive]
theorem uniformContinuous_monoidHom_of_continuous {hom : Type*} [UniformSpace β] [Group β]
    [UniformGroup β] [FunLike hom α β] [MonoidHomClass hom α β] {f : hom} (h : Continuous f) :
    UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: CauchySeq.mul
code: @[to_additive]
theorem CauchySeq.mul {ι : Type*} [Preorder ι] {u v : ι → α} (hu : CauchySeq u)
    (hv : CauchySeq v) : CauchySeq (u * v) 
goal: CauchySeq (u * v)

full_name: CauchySeq.add
code: @[to_additive]
theorem CauchySeq.mul {ι : Type*} [Preorder ι] {u v : ι → α} (hu : CauchySeq u)
    (hv : CauchySeq v) : CauchySeq (u * v) 
goal: CauchySeq (u + v)

full_name: CauchySeq.add_const
code: @[to_additive]
theorem CauchySeq.mul_const {ι : Type*} [Preorder ι] {u : ι → α} {x : α} (hu : CauchySeq u) :
    CauchySeq fun n => u n * x 
goal: CauchySeq fun n => u n + x

full_name: CauchySeq.mul_const
code: @[to_additive]
theorem CauchySeq.mul_const {ι : Type*} [Preorder ι] {u : ι → α} {x : α} (hu : CauchySeq u) :
    CauchySeq fun n => u n * x 
goal: CauchySeq fun n => u n * x

full_name: CauchySeq.const_mul
code: @[to_additive]
theorem CauchySeq.const_mul {ι : Type*} [Preorder ι] {u : ι → α} {x : α} (hu : CauchySeq u) :
    CauchySeq fun n => x * u n 
goal: CauchySeq fun n => x * u n

full_name: CauchySeq.const_add
code: @[to_additive]
theorem CauchySeq.const_mul {ι : Type*} [Preorder ι] {u : ι → α} {x : α} (hu : CauchySeq u) :
    CauchySeq fun n => x * u n 
goal: CauchySeq fun n => x + u n

full_name: CauchySeq.neg
code: @[to_additive]
theorem CauchySeq.inv {ι : Type*} [Preorder ι] {u : ι → α} (h : CauchySeq u) :
    CauchySeq u⁻¹ 
goal: CauchySeq (-u)

full_name: CauchySeq.inv
code: @[to_additive]
theorem CauchySeq.inv {ι : Type*} [Preorder ι] {u : ι → α} (h : CauchySeq u) :
    CauchySeq u⁻¹ 
goal: CauchySeq u⁻¹

full_name: totallyBounded_iff_subset_finite_iUnion_nhds_one
code: @[to_additive]
theorem totallyBounded_iff_subset_finite_iUnion_nhds_one {s : Set α} :
    TotallyBounded s ↔ ∀ U ∈ 𝓝 (1 : α), ∃ t : Set α, t.Finite ∧ s ⊆ ⋃ y ∈ t, y • U 
goal: TotallyBounded s ↔ ∀ U ∈ 𝓝 1, ∃ t, t.Finite ∧ s ⊆ ⋃ y ∈ t, y • U

full_name: totallyBounded_iff_subset_finite_iUnion_nhds_zero
code: @[to_additive]
theorem totallyBounded_iff_subset_finite_iUnion_nhds_one {s : Set α} :
    TotallyBounded s ↔ ∀ U ∈ 𝓝 (1 : α), ∃ t : Set α, t.Finite ∧ s ⊆ ⋃ y ∈ t, y • U 
goal: TotallyBounded s ↔ ∀ U ∈ 𝓝 0, ∃ t, t.Finite ∧ s ⊆ ⋃ y ∈ t, y +ᵥ U

full_name: TendstoUniformlyOnFilter.add
code: @[to_additive]
theorem TendstoUniformlyOnFilter.mul (hf : TendstoUniformlyOnFilter f g l l')
    (hf' : TendstoUniformlyOnFilter f' g' l l') : TendstoUniformlyOnFilter (f * f') (g * g') l l' 
goal: TendstoUniformlyOnFilter (f + f') (g + g') l l'

full_name: TendstoUniformlyOnFilter.mul
code: @[to_additive]
theorem TendstoUniformlyOnFilter.mul (hf : TendstoUniformlyOnFilter f g l l')
    (hf' : TendstoUniformlyOnFilter f' g' l l') : TendstoUniformlyOnFilter (f * f') (g * g') l l' 
goal: TendstoUniformlyOnFilter (f * f') (g * g') l l'

full_name: TendstoUniformlyOnFilter.sub
code: @[to_additive]
theorem TendstoUniformlyOnFilter.div (hf : TendstoUniformlyOnFilter f g l l')
    (hf' : TendstoUniformlyOnFilter f' g' l l') : TendstoUniformlyOnFilter (f / f') (g / g') l l' 
goal: TendstoUniformlyOnFilter (f - f') (g - g') l l'

full_name: TendstoUniformlyOnFilter.div
code: @[to_additive]
theorem TendstoUniformlyOnFilter.div (hf : TendstoUniformlyOnFilter f g l l')
    (hf' : TendstoUniformlyOnFilter f' g' l l') : TendstoUniformlyOnFilter (f / f') (g / g') l l' 
goal: TendstoUniformlyOnFilter (f / f') (g / g') l l'

full_name: TendstoUniformlyOn.mul
code: @[to_additive]
theorem TendstoUniformlyOn.mul (hf : TendstoUniformlyOn f g l s)
    (hf' : TendstoUniformlyOn f' g' l s) : TendstoUniformlyOn (f * f') (g * g') l s 
goal: TendstoUniformlyOn (f * f') (g * g') l s

full_name: TendstoUniformlyOn.add
code: @[to_additive]
theorem TendstoUniformlyOn.mul (hf : TendstoUniformlyOn f g l s)
    (hf' : TendstoUniformlyOn f' g' l s) : TendstoUniformlyOn (f * f') (g * g') l s 
goal: TendstoUniformlyOn (f + f') (g + g') l s

full_name: TendstoUniformlyOn.sub
code: @[to_additive]
theorem TendstoUniformlyOn.div (hf : TendstoUniformlyOn f g l s)
    (hf' : TendstoUniformlyOn f' g' l s) : TendstoUniformlyOn (f / f') (g / g') l s 
goal: TendstoUniformlyOn (f - f') (g - g') l s

full_name: TendstoUniformlyOn.div
code: @[to_additive]
theorem TendstoUniformlyOn.div (hf : TendstoUniformlyOn f g l s)
    (hf' : TendstoUniformlyOn f' g' l s) : TendstoUniformlyOn (f / f') (g / g') l s 
goal: TendstoUniformlyOn (f / f') (g / g') l s

full_name: TendstoUniformly.add
code: @[to_additive]
theorem TendstoUniformly.mul (hf : TendstoUniformly f g l) (hf' : TendstoUniformly f' g' l) :
    TendstoUniformly (f * f') (g * g') l 
goal: TendstoUniformly (f + f') (g + g') l

full_name: TendstoUniformly.mul
code: @[to_additive]
theorem TendstoUniformly.mul (hf : TendstoUniformly f g l) (hf' : TendstoUniformly f' g' l) :
    TendstoUniformly (f * f') (g * g') l 
goal: TendstoUniformly (f * f') (g * g') l

full_name: TendstoUniformly.div
code: @[to_additive]
theorem TendstoUniformly.div (hf : TendstoUniformly f g l) (hf' : TendstoUniformly f' g' l) :
    TendstoUniformly (f / f') (g / g') l 
goal: TendstoUniformly (f / f') (g / g') l

full_name: TendstoUniformly.sub
code: @[to_additive]
theorem TendstoUniformly.div (hf : TendstoUniformly f g l) (hf' : TendstoUniformly f' g' l) :
    TendstoUniformly (f / f') (g / g') l 
goal: TendstoUniformly (f - f') (g - g') l

full_name: UniformCauchySeqOn.add
code: @[to_additive]
theorem UniformCauchySeqOn.mul (hf : UniformCauchySeqOn f l s) (hf' : UniformCauchySeqOn f' l s) :
    UniformCauchySeqOn (f * f') l s 
goal: UniformCauchySeqOn (f + f') l s

full_name: UniformCauchySeqOn.mul
code: @[to_additive]
theorem UniformCauchySeqOn.mul (hf : UniformCauchySeqOn f l s) (hf' : UniformCauchySeqOn f' l s) :
    UniformCauchySeqOn (f * f') l s 
goal: UniformCauchySeqOn (f * f') l s

full_name: UniformCauchySeqOn.sub
code: @[to_additive]
theorem UniformCauchySeqOn.div (hf : UniformCauchySeqOn f l s) (hf' : UniformCauchySeqOn f' l s) :
    UniformCauchySeqOn (f / f') l s 
goal: UniformCauchySeqOn (f - f') l s

full_name: UniformCauchySeqOn.div
code: @[to_additive]
theorem UniformCauchySeqOn.div (hf : UniformCauchySeqOn f l s) (hf' : UniformCauchySeqOn f' l s) :
    UniformCauchySeqOn (f / f') l s 
goal: UniformCauchySeqOn (f / f') l s

full_name: TopologicalAddGroup.toUniformSpace
code: /-- 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
`UniformGroup` structure. Two important special cases where they _do_ coincide are for
commutative groups (see `comm_topologicalGroup_is_uniform`) and for compact groups (see
`topologicalGroup_is_uniform_of_compactSpace`). -/
@[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
`UniformAddGroup` structure. Two important special cases where they _do_ coincide are for
commutative additive groups (see `comm_topologicalAddGroup_is_uniform`) and for compact
additive groups (see `topologicalAddGroup_is_uniform_of_compactSpace`)."]
def TopologicalGroup.toUniformSpace : UniformSpace G 
goal: UniformSpace G

full_name: TopologicalGroup.toUniformSpace
code: /-- 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
`UniformGroup` structure. Two important special cases where they _do_ coincide are for
commutative groups (see `comm_topologicalGroup_is_uniform`) and for compact groups (see
`topologicalGroup_is_uniform_of_compactSpace`). -/
@[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
`UniformAddGroup` structure. Two important special cases where they _do_ coincide are for
commutative additive groups (see `comm_topologicalAddGroup_is_uniform`) and for compact
additive groups (see `topologicalAddGroup_is_uniform_of_compactSpace`)."]
def TopologicalGroup.toUniformSpace : UniformSpace G 
goal: UniformSpace G

full_name: uniformity_eq_comap_nhds_zero'
code: @[to_additive]
theorem uniformity_eq_comap_nhds_one' : 𝓤 G = comap (fun p : G × G => p.2 / p.1) (𝓝 (1 : G)) 
goal: 𝓤 G = Filter.comap (fun p => p.2 - p.1) (𝓝 0)

full_name: uniformity_eq_comap_nhds_one'
code: @[to_additive]
theorem uniformity_eq_comap_nhds_one' : 𝓤 G = comap (fun p : G × G => p.2 / p.1) (𝓝 (1 : G)) 
goal: 𝓤 G = Filter.comap (fun p => p.2 / p.1) (𝓝 1)

full_name: topologicalAddGroup_is_uniform_of_compactSpace
code: @[to_additive]
theorem topologicalGroup_is_uniform_of_compactSpace [CompactSpace G] : UniformGroup G 
goal: UniformAddGroup G

full_name: topologicalGroup_is_uniform_of_compactSpace
code: @[to_additive]
theorem topologicalGroup_is_uniform_of_compactSpace [CompactSpace G] : UniformGroup G 
goal: UniformGroup G

full_name: Subgroup.isClosed_of_discrete
code: @[to_additive]
instance Subgroup.isClosed_of_discrete [T2Space G] {H : Subgroup G} [DiscreteTopology H] :
    IsClosed (H : Set G) 
goal: IsClosed ↑H

full_name: AddSubgroup.isClosed_of_discrete
code: @[to_additive]
instance Subgroup.isClosed_of_discrete [T2Space G] {H : Subgroup G} [DiscreteTopology H] :
    IsClosed (H : Set G) 
goal: IsClosed ↑H

full_name: AddSubgroup.tendsto_coe_cofinite_of_discrete
code: @[to_additive]
lemma Subgroup.tendsto_coe_cofinite_of_discrete [T2Space G] (H : Subgroup G) [DiscreteTopology H] :
    Tendsto ((↑) : H → G) cofinite (cocompact _) 
goal: Filter.Tendsto Subtype.val Filter.cofinite (Filter.cocompact G)

full_name: Subgroup.tendsto_coe_cofinite_of_discrete
code: @[to_additive]
lemma Subgroup.tendsto_coe_cofinite_of_discrete [T2Space G] (H : Subgroup G) [DiscreteTopology H] :
    Tendsto ((↑) : H → G) cofinite (cocompact _) 
goal: Filter.Tendsto Subtype.val Filter.cofinite (Filter.cocompact G)

full_name: MonoidHom.tendsto_coe_cofinite_of_discrete
code: @[to_additive]
lemma 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 _) 
goal: Filter.Tendsto (⇑f) Filter.cofinite (Filter.cocompact G)

full_name: AddMonoidHom.tendsto_coe_cofinite_of_discrete
code: @[to_additive]
lemma 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 _) 
goal: Filter.Tendsto (⇑f) Filter.cofinite (Filter.cocompact G)

full_name: TopologicalGroup.tendstoUniformly_iff
code: @[to_additive]
theorem TopologicalGroup.tendstoUniformly_iff {ι α : Type*} (F : ι → α → G) (f : α → G)
    (p : Filter ι) :
    @TendstoUniformly α G ι (TopologicalGroup.toUniformSpace G) F f p ↔
      ∀ u ∈ 𝓝 (1 : G), ∀ᶠ i in p, ∀ a, F i a / f a ∈ u 
goal: TendstoUniformly F f p ↔ ∀ u ∈ 𝓝 1, ∀ᶠ (i : ι) in p, ∀ (a : α), F i a / f a ∈ u

full_name: TopologicalAddGroup.tendstoUniformly_iff
code: @[to_additive]
theorem TopologicalGroup.tendstoUniformly_iff {ι α : Type*} (F : ι → α → G) (f : α → G)
    (p : Filter ι) :
    @TendstoUniformly α G ι (TopologicalGroup.toUniformSpace G) F f p ↔
      ∀ u ∈ 𝓝 (1 : G), ∀ᶠ i in p, ∀ a, F i a / f a ∈ u 
goal: TendstoUniformly F f p ↔ ∀ u ∈ 𝓝 0, ∀ᶠ (i : ι) in p, ∀ (a : α), F i a - f a ∈ u

full_name: TopologicalGroup.tendstoUniformlyOn_iff
code: @[to_additive]
theorem TopologicalGroup.tendstoUniformlyOn_iff {ι α : Type*} (F : ι → α → G) (f : α → G)
    (p : Filter ι) (s : Set α) :
    @TendstoUniformlyOn α G ι (TopologicalGroup.toUniformSpace G) F f p s ↔
      ∀ u ∈ 𝓝 (1 : G), ∀ᶠ i in p, ∀ a ∈ s, F i a / f a ∈ u 
goal: TendstoUniformlyOn F f p s ↔ ∀ u ∈ 𝓝 1, ∀ᶠ (i : ι) in p, ∀ a ∈ s, F i a / f a ∈ u

full_name: TopologicalAddGroup.tendstoUniformlyOn_iff
code: @[to_additive]
theorem TopologicalGroup.tendstoUniformlyOn_iff {ι α : Type*} (F : ι → α → G) (f : α → G)
    (p : Filter ι) (s : Set α) :
    @TendstoUniformlyOn α G ι (TopologicalGroup.toUniformSpace G) F f p s ↔
      ∀ u ∈ 𝓝 (1 : G), ∀ᶠ i in p, ∀ a ∈ s, F i a / f a ∈ u 
goal: TendstoUniformlyOn F f p s ↔ ∀ u ∈ 𝓝 0, ∀ᶠ (i : ι) in p, ∀ a ∈ s, F i a - f a ∈ u

full_name: TopologicalGroup.tendstoLocallyUniformly_iff
code: @[to_additive]
theorem TopologicalGroup.tendstoLocallyUniformly_iff {ι α : Type*} [TopologicalSpace α]
    (F : ι → α → G) (f : α → G) (p : Filter ι) :
    @TendstoLocallyUniformly α G ι (TopologicalGroup.toUniformSpace G) _ F f p ↔
      ∀ u ∈ 𝓝 (1 : G), ∀ (x : α), ∃ t ∈ 𝓝 x, ∀ᶠ i in p, ∀ a ∈ t, F i a / f a ∈ u 
goal: TendstoLocallyUniformly F f p ↔ ∀ u ∈ 𝓝 1, ∀ (x : α), ∃ t ∈ 𝓝 x, ∀ᶠ (i : ι) in p, ∀ a ∈ t, F i a / f a ∈ u

full_name: TopologicalAddGroup.tendstoLocallyUniformly_iff
code: @[to_additive]
theorem TopologicalGroup.tendstoLocallyUniformly_iff {ι α : Type*} [TopologicalSpace α]
    (F : ι → α → G) (f : α → G) (p : Filter ι) :
    @TendstoLocallyUniformly α G ι (TopologicalGroup.toUniformSpace G) _ F f p ↔
      ∀ u ∈ 𝓝 (1 : G), ∀ (x : α), ∃ t ∈ 𝓝 x, ∀ᶠ i in p, ∀ a ∈ t, F i a / f a ∈ u 
goal: TendstoLocallyUniformly F f p ↔ ∀ u ∈ 𝓝 0, ∀ (x : α), ∃ t ∈ 𝓝 x, ∀ᶠ (i : ι) in p, ∀ a ∈ t, F i a - f a ∈ u

full_name: TopologicalGroup.tendstoLocallyUniformlyOn_iff
code: @[to_additive]
theorem TopologicalGroup.tendstoLocallyUniformlyOn_iff {ι α : Type*} [TopologicalSpace α]
    (F : ι → α → G) (f : α → G) (p : Filter ι) (s : Set α) :
    @TendstoLocallyUniformlyOn α G ι (TopologicalGroup.toUniformSpace G) _ F f p s ↔
      ∀ u ∈ 𝓝 (1 : G), ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, ∀ᶠ i in p, ∀ a ∈ t, F i a / f a ∈ u 
goal: TendstoLocallyUniformlyOn F f p s ↔ ∀ u ∈ 𝓝 1, ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, ∀ᶠ (i : ι) in p, ∀ a ∈ t, F i a / f a ∈ u

full_name: TopologicalAddGroup.tendstoLocallyUniformlyOn_iff
code: @[to_additive]
theorem TopologicalGroup.tendstoLocallyUniformlyOn_iff {ι α : Type*} [TopologicalSpace α]
    (F : ι → α → G) (f : α → G) (p : Filter ι) (s : Set α) :
    @TendstoLocallyUniformlyOn α G ι (TopologicalGroup.toUniformSpace G) _ F f p s ↔
      ∀ u ∈ 𝓝 (1 : G), ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, ∀ᶠ i in p, ∀ a ∈ t, F i a / f a ∈ u 
goal: TendstoLocallyUniformlyOn F f p s ↔ ∀ u ∈ 𝓝 0, ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, ∀ᶠ (i : ι) in p, ∀ a ∈ t, F i a - f a ∈ u

full_name: comm_topologicalGroup_is_uniform
code: @[to_additive]
-- Porting note: renamed theorem to conform to naming convention
theorem comm_topologicalGroup_is_uniform : UniformGroup G 
goal: UniformGroup G

full_name: comm_topologicalAddGroup_is_uniform
code: @[to_additive]
-- Porting note: renamed theorem to conform to naming convention
theorem comm_topologicalGroup_is_uniform : UniformGroup G 
goal: UniformAddGroup G

full_name: UniformAddGroup.toUniformSpace_eq
code: @[to_additive]
theorem UniformGroup.toUniformSpace_eq {G : Type*} [u : UniformSpace G] [Group G]
    [UniformGroup G] : TopologicalGroup.toUniformSpace G = u 
goal: TopologicalAddGroup.toUniformSpace G = u

full_name: UniformGroup.toUniformSpace_eq
code: @[to_additive]
theorem UniformGroup.toUniformSpace_eq {G : Type*} [u : UniformSpace G] [Group G]
    [UniformGroup G] : TopologicalGroup.toUniformSpace G = u 
goal: TopologicalGroup.toUniformSpace G = u

full_name: tendsto_sub_comap_self
code: @[to_additive]
theorem tendsto_div_comap_self (x₀ : α) :
    Tendsto (fun t : β × β => t.2 / t.1) ((comap fun p : β × β => (e p.1, e p.2)) <| 𝓝 (x₀, x₀))
      (𝓝 1) 
goal: Filter.Tendsto (fun t => t.2 - t.1) (Filter.comap (fun p => (e p.1, e p.2)) (𝓝 (x₀, x₀))) (𝓝 0)

full_name: tendsto_div_comap_self
code: @[to_additive]
theorem tendsto_div_comap_self (x₀ : α) :
    Tendsto (fun t : β × β => t.2 / t.1) ((comap fun p : β × β => (e p.1, e p.2)) <| 𝓝 (x₀, x₀))
      (𝓝 1) 
goal: Filter.Tendsto (fun t => t.2 / t.1) (Filter.comap (fun p => (e p.1, e p.2)) (𝓝 (x₀, x₀))) (𝓝 1)

full_name: _private.Mathlib.Topology.Algebra.UniformGroup.0.DenseInducing.extend_Z_bilin_aux
code: private theorem extend_Z_bilin_aux (x₀ : α) (y₁ : δ) : ∃ U₂ ∈ comap e (𝓝 x₀), ∀ x ∈ U₂, ∀ x' ∈ U₂,
    (fun p : β × δ => φ p.1 p.2) (x' - x, y₁) ∈ W' 
goal: ∃ U₂ ∈ Filter.comap (⇑e) (𝓝 x₀), ∀ x ∈ U₂, ∀ x' ∈ U₂, (fun p => (φ p.1) p.2) (x' - x, y₁) ∈ W'

full_name: _private.Mathlib.Topology.Algebra.UniformGroup.0.DenseInducing.extend_Z_bilin_key
code: private theorem 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' 
goal: ∃ U ∈ Filter.comap (⇑e) (𝓝 x₀),
  ∃ V ∈ Filter.comap (⇑f) (𝓝 y₀),
    ∀ x ∈ U, ∀ x' ∈ U, ∀ y ∈ V, ∀ y' ∈ V, (fun p => (φ p.1) p.2) (x', y') - (fun p => (φ p.1) p.2) (x, y) ∈ W'

full_name: DenseInducing.extend_Z_bilin
code: /-- 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. -/
theorem extend_Z_bilin : Continuous (extend (de.prod df) (fun p : β × δ => φ p.1 p.2)) 
goal: Continuous (⋯.extend fun p => (φ p.1) p.2)

full_name: QuotientGroup.completeSpace'
code: /-- The quotient `G ⧸ N` of a complete first countable topological group `G` by a normal subgroup
is itself complete. [N. Bourbaki, *General Topology*, IX.3.1 Proposition 4][bourbaki1966b]

Because a topological group is not equipped with a `UniformSpace` instance by default, we must
explicitly provide it in order to consider completeness. See `QuotientGroup.completeSpace` for a
version in which `G` is already equipped with a uniform structure. -/
@[to_additive "The quotient `G ⧸ N` of a complete first countable topological additive group
`G` by a normal additive subgroup is itself complete. Consequently, quotients of Banach spaces by
subspaces are complete. [N. Bourbaki, *General Topology*, IX.3.1 Proposition 4][bourbaki1966b]

Because an additive topological group is not equipped with a `UniformSpace` instance by default,
we must explicitly provide it in order to consider completeness. See
`QuotientAddGroup.completeSpace` for a version in which `G` is already equipped with a uniform
structure."]
instance QuotientGroup.completeSpace' (G : Type u) [Group G] [TopologicalSpace G]
    [TopologicalGroup G] [FirstCountableTopology G] (N : Subgroup G) [N.Normal]
    [@CompleteSpace G (TopologicalGroup.toUniformSpace G)] :
    @CompleteSpace (G ⧸ N) (TopologicalGroup.toUniformSpace (G ⧸ N)) 
goal: CompleteSpace (G ⧸ N)

full_name: QuotientAddGroup.completeSpace'
code: /-- The quotient `G ⧸ N` of a complete first countable topological group `G` by a normal subgroup
is itself complete. [N. Bourbaki, *General Topology*, IX.3.1 Proposition 4][bourbaki1966b]

Because a topological group is not equipped with a `UniformSpace` instance by default, we must
explicitly provide it in order to consider completeness. See `QuotientGroup.completeSpace` for a
version in which `G` is already equipped with a uniform structure. -/
@[to_additive "The quotient `G ⧸ N` of a complete first countable topological additive group
`G` by a normal additive subgroup is itself complete. Consequently, quotients of Banach spaces by
subspaces are complete. [N. Bourbaki, *General Topology*, IX.3.1 Proposition 4][bourbaki1966b]

Because an additive topological group is not equipped with a `UniformSpace` instance by default,
we must explicitly provide it in order to consider completeness. See
`QuotientAddGroup.completeSpace` for a version in which `G` is already equipped with a uniform
structure."]
instance QuotientGroup.completeSpace' (G : Type u) [Group G] [TopologicalSpace G]
    [TopologicalGroup G] [FirstCountableTopology G] (N : Subgroup G) [N.Normal]
    [@CompleteSpace G (TopologicalGroup.toUniformSpace G)] :
    @CompleteSpace (G ⧸ N) (TopologicalGroup.toUniformSpace (G ⧸ N)) 
goal: CompleteSpace (G ⧸ N)

full_name: QuotientGroup.completeSpace
code: /-- The quotient `G ⧸ N` of a complete first countable uniform group `G` by a normal subgroup
is itself complete. In contrast to `QuotientGroup.completeSpace'`, in this version `G` is
already equipped with a uniform structure.
[N. Bourbaki, *General Topology*, IX.3.1 Proposition 4][bourbaki1966b]

Even though `G` is equipped with a uniform structure, the quotient `G ⧸ N` does not inherit a
uniform structure, so it is still provided manually via `TopologicalGroup.toUniformSpace`.
In the most common use cases, this coincides (definitionally) with the uniform structure on the
quotient obtained via other means.  -/
@[to_additive "The quotient `G ⧸ N` of a complete first countable uniform additive group
`G` by a normal additive subgroup is itself complete. Consequently, quotients of Banach spaces by
subspaces are complete. In contrast to `QuotientAddGroup.completeSpace'`, in this version
`G` is already equipped with a uniform structure.
[N. Bourbaki, *General Topology*, IX.3.1 Proposition 4][bourbaki1966b]

Even though `G` is equipped with a uniform structure, the quotient `G ⧸ N` does not inherit a
uniform structure, so it is still provided manually via `TopologicalAddGroup.toUniformSpace`.
In the most common use case ─ quotients of normed additive commutative groups by subgroups ─
significant care was taken so that the uniform structure inherent in that setting coincides
(definitionally) with the uniform structure provided here."]
instance QuotientGroup.completeSpace (G : Type u) [Group G] [us : UniformSpace G] [UniformGroup G]
    [FirstCountableTopology G] (N : Subgroup G) [N.Normal] [hG : CompleteSpace G] :
    @CompleteSpace (G ⧸ N) (TopologicalGroup.toUniformSpace (G ⧸ N)) 
goal: CompleteSpace (G ⧸ N)

full_name: QuotientAddGroup.completeSpace
code: /-- The quotient `G ⧸ N` of a complete first countable uniform group `G` by a normal subgroup
is itself complete. In contrast to `QuotientGroup.completeSpace'`, in this version `G` is
already equipped with a uniform structure.
[N. Bourbaki, *General Topology*, IX.3.1 Proposition 4][bourbaki1966b]

Even though `G` is equipped with a uniform structure, the quotient `G ⧸ N` does not inherit a
uniform structure, so it is still provided manually via `TopologicalGroup.toUniformSpace`.
In the most common use cases, this coincides (definitionally) with the uniform structure on the
quotient obtained via other means.  -/
@[to_additive "The quotient `G ⧸ N` of a complete first countable uniform additive group
`G` by a normal additive subgroup is itself complete. Consequently, quotients of Banach spaces by
subspaces are complete. In contrast to `QuotientAddGroup.completeSpace'`, in this version
`G` is already equipped with a uniform structure.
[N. Bourbaki, *General Topology*, IX.3.1 Proposition 4][bourbaki1966b]

Even though `G` is equipped with a uniform structure, the quotient `G ⧸ N` does not inherit a
uniform structure, so it is still provided manually via `TopologicalAddGroup.toUniformSpace`.
In the most common use case ─ quotients of normed additive commutative groups by subgroups ─
significant care was taken so that the uniform structure inherent in that setting coincides
(definitionally) with the uniform structure provided here."]
instance QuotientGroup.completeSpace (G : Type u) [Group G] [us : UniformSpace G] [UniformGroup G]
    [FirstCountableTopology G] (N : Subgroup G) [N.Normal] [hG : CompleteSpace G] :
    @CompleteSpace (G ⧸ N) (TopologicalGroup.toUniformSpace (G ⧸ N)) 
goal: CompleteSpace (G ⧸ N)