File: Mathlib/Topology/Algebra/Group/Basic.lean

full_name: Homeomorph.addLeft
code: /-- Multiplication from the left in a topological group as a homeomorphism. -/
@[to_additive "Addition from the left in a topological additive group as a homeomorphism."]
protected def Homeomorph.mulLeft (a : G) : G ≃ₜ G 
goal: G ≃ₜ G

full_name: Homeomorph.mulLeft
code: /-- Multiplication from the left in a topological group as a homeomorphism. -/
@[to_additive "Addition from the left in a topological additive group as a homeomorphism."]
protected def Homeomorph.mulLeft (a : G) : G ≃ₜ G 
goal: G ≃ₜ G

full_name: Homeomorph.coe_mulLeft
code: @[to_additive (attr := simp)]
theorem Homeomorph.coe_mulLeft (a : G) : ⇑(Homeomorph.mulLeft a) = (a * ·) 
goal: ⇑(Homeomorph.mulLeft a) = fun x => a * x

full_name: Homeomorph.coe_addLeft
code: @[to_additive (attr := simp)]
theorem Homeomorph.coe_mulLeft (a : G) : ⇑(Homeomorph.mulLeft a) = (a * ·) 
goal: ⇑(Homeomorph.addLeft a) = fun x => a + x

full_name: Homeomorph.mulLeft_symm
code: @[to_additive]
theorem Homeomorph.mulLeft_symm (a : G) : (Homeomorph.mulLeft a).symm = Homeomorph.mulLeft a⁻¹ 
goal: (Homeomorph.mulLeft a).symm = Homeomorph.mulLeft a⁻¹

full_name: Homeomorph.addLeft_symm
code: @[to_additive]
theorem Homeomorph.mulLeft_symm (a : G) : (Homeomorph.mulLeft a).symm = Homeomorph.mulLeft a⁻¹ 
goal: (Homeomorph.addLeft a).symm = Homeomorph.addLeft (-a)

full_name: isOpenMap_mul_left
code: @[to_additive]
lemma isOpenMap_mul_left (a : G) : IsOpenMap (a * ·) 
goal: IsOpenMap fun x => a * x

full_name: isOpenMap_add_left
code: @[to_additive]
lemma isOpenMap_mul_left (a : G) : IsOpenMap (a * ·) 
goal: IsOpenMap fun x => a + x

full_name: IsOpen.left_addCoset
code: @[to_additive IsOpen.left_addCoset]
theorem IsOpen.leftCoset {U : Set G} (h : IsOpen U) (x : G) : IsOpen (x • U) 
goal: IsOpen (x +ᵥ U)

full_name: IsOpen.leftCoset
code: @[to_additive IsOpen.left_addCoset]
theorem IsOpen.leftCoset {U : Set G} (h : IsOpen U) (x : G) : IsOpen (x • U) 
goal: IsOpen (x • U)

full_name: isClosedMap_mul_left
code: @[to_additive]
lemma isClosedMap_mul_left (a : G) : IsClosedMap (a * ·) 
goal: IsClosedMap fun x => a * x

full_name: isClosedMap_add_left
code: @[to_additive]
lemma isClosedMap_mul_left (a : G) : IsClosedMap (a * ·) 
goal: IsClosedMap fun x => a + x

full_name: IsClosed.left_addCoset
code: @[to_additive IsClosed.left_addCoset]
theorem IsClosed.leftCoset {U : Set G} (h : IsClosed U) (x : G) : IsClosed (x • U) 
goal: IsClosed (x +ᵥ U)

full_name: IsClosed.leftCoset
code: @[to_additive IsClosed.left_addCoset]
theorem IsClosed.leftCoset {U : Set G} (h : IsClosed U) (x : G) : IsClosed (x • U) 
goal: IsClosed (x • U)

full_name: Homeomorph.mulRight
code: /-- Multiplication from the right in a topological group as a homeomorphism. -/
@[to_additive "Addition from the right in a topological additive group as a homeomorphism."]
protected def Homeomorph.mulRight (a : G) : G ≃ₜ G 
goal: G ≃ₜ G

full_name: Homeomorph.addRight
code: /-- Multiplication from the right in a topological group as a homeomorphism. -/
@[to_additive "Addition from the right in a topological additive group as a homeomorphism."]
protected def Homeomorph.mulRight (a : G) : G ≃ₜ G 
goal: G ≃ₜ G

full_name: Homeomorph.coe_mulRight
code: @[to_additive (attr := simp)]
lemma Homeomorph.coe_mulRight (a : G) : ⇑(Homeomorph.mulRight a) = (· * a) 
goal: ⇑(Homeomorph.mulRight a) = fun x => x * a

full_name: Homeomorph.coe_addRight
code: @[to_additive (attr := simp)]
lemma Homeomorph.coe_mulRight (a : G) : ⇑(Homeomorph.mulRight a) = (· * a) 
goal: ⇑(Homeomorph.addRight a) = fun x => x + a

full_name: Homeomorph.mulRight_symm
code: @[to_additive]
theorem Homeomorph.mulRight_symm (a : G) :
    (Homeomorph.mulRight a).symm = Homeomorph.mulRight a⁻¹ 
goal: (Homeomorph.mulRight a).symm = Homeomorph.mulRight a⁻¹

full_name: Homeomorph.addRight_symm
code: @[to_additive]
theorem Homeomorph.mulRight_symm (a : G) :
    (Homeomorph.mulRight a).symm = Homeomorph.mulRight a⁻¹ 
goal: (Homeomorph.addRight a).symm = Homeomorph.addRight (-a)

full_name: isOpenMap_add_right
code: @[to_additive]
theorem isOpenMap_mul_right (a : G) : IsOpenMap (· * a) 
goal: IsOpenMap fun x => x + a

full_name: isOpenMap_mul_right
code: @[to_additive]
theorem isOpenMap_mul_right (a : G) : IsOpenMap (· * a) 
goal: IsOpenMap fun x => x * a

full_name: IsOpen.rightCoset
code: @[to_additive IsOpen.right_addCoset]
theorem IsOpen.rightCoset {U : Set G} (h : IsOpen U) (x : G) : IsOpen (op x • U) 
goal: IsOpen (MulOpposite.op x • U)

full_name: IsOpen.right_addCoset
code: @[to_additive IsOpen.right_addCoset]
theorem IsOpen.rightCoset {U : Set G} (h : IsOpen U) (x : G) : IsOpen (op x • U) 
goal: IsOpen (AddOpposite.op x +ᵥ U)

full_name: isClosedMap_add_right
code: @[to_additive]
theorem isClosedMap_mul_right (a : G) : IsClosedMap (· * a) 
goal: IsClosedMap fun x => x + a

full_name: isClosedMap_mul_right
code: @[to_additive]
theorem isClosedMap_mul_right (a : G) : IsClosedMap (· * a) 
goal: IsClosedMap fun x => x * a

full_name: IsClosed.rightCoset
code: @[to_additive IsClosed.right_addCoset]
theorem IsClosed.rightCoset {U : Set G} (h : IsClosed U) (x : G) : IsClosed (op x • U) 
goal: IsClosed (MulOpposite.op x • U)

full_name: IsClosed.right_addCoset
code: @[to_additive IsClosed.right_addCoset]
theorem IsClosed.rightCoset {U : Set G} (h : IsClosed U) (x : G) : IsClosed (op x • U) 
goal: IsClosed (AddOpposite.op x +ᵥ U)

full_name: discreteTopology_of_isOpen_singleton_zero
code: @[to_additive]
theorem discreteTopology_of_isOpen_singleton_one (h : IsOpen ({1} : Set G)) :
    DiscreteTopology G 
goal: DiscreteTopology G

full_name: discreteTopology_of_isOpen_singleton_one
code: @[to_additive]
theorem discreteTopology_of_isOpen_singleton_one (h : IsOpen ({1} : Set G)) :
    DiscreteTopology G 
goal: DiscreteTopology G

full_name: discreteTopology_iff_isOpen_singleton_one
code: @[to_additive]
theorem discreteTopology_iff_isOpen_singleton_one : DiscreteTopology G ↔ IsOpen ({1} : Set G) 
goal: DiscreteTopology G ↔ IsOpen {1}

full_name: discreteTopology_iff_isOpen_singleton_zero
code: @[to_additive]
theorem discreteTopology_iff_isOpen_singleton_one : DiscreteTopology G ↔ IsOpen ({1} : Set G) 
goal: DiscreteTopology G ↔ IsOpen {0}

full_name: ContinuousNeg
code: /-- Basic hypothesis to talk about a topological additive group. A topological additive group
over `M`, for example, is obtained by requiring the instances `AddGroup M` and
`ContinuousAdd M` and `ContinuousNeg M`. -/
class ContinuousNeg (G : Type u) [TopologicalSpace G] [Neg G] : Prop where
  continuous_neg : Continuous fun a : G => -a
goal: Prop

full_name: ContinuousNeg.continuous_neg
code: /-- Basic hypothesis to talk about a topological additive group. A topological additive group
over `M`, for example, is obtained by requiring the instances `AddGroup M` and
`ContinuousAdd M` and `ContinuousNeg M`. -/
class ContinuousNeg (G : Type u) [TopologicalSpace G] [Neg G] : Prop where
  continuous_neg : Continuous fun a : G => -a
goal: Continuous fun a => -a

full_name: ContinuousInv
code: /-- Basic hypothesis to talk about a topological group. A topological group over `M`, for example,
is obtained by requiring the instances `Group M` and `ContinuousMul M` and
`ContinuousInv M`. -/
@[to_additive (attr := continuity)]
class ContinuousInv (G : Type u) [TopologicalSpace G] [Inv G] : Prop where
  continuous_inv : Continuous fun a : G => a⁻¹
goal: Prop

full_name: ContinuousInv.continuous_inv
code: /-- Basic hypothesis to talk about a topological group. A topological group over `M`, for example,
is obtained by requiring the instances `Group M` and `ContinuousMul M` and
`ContinuousInv M`. -/
@[to_additive (attr := continuity)]
class ContinuousInv (G : Type u) [TopologicalSpace G] [Inv G] : Prop where
  continuous_inv : Continuous fun a : G => a⁻¹
goal: Continuous fun a => a⁻¹

full_name: ContinuousInv.induced
code: @[to_additive]
theorem ContinuousInv.induced {α : Type*} {β : Type*} {F : Type*} [FunLike F α β] [Group α]
    [Group β] [MonoidHomClass F α β] [tβ : TopologicalSpace β] [ContinuousInv β] (f : F) :
    @ContinuousInv α (tβ.induced f) _ 
goal: ContinuousInv α

full_name: ContinuousNeg.induced
code: @[to_additive]
theorem ContinuousInv.induced {α : Type*} {β : Type*} {F : Type*} [FunLike F α β] [Group α]
    [Group β] [MonoidHomClass F α β] [tβ : TopologicalSpace β] [ContinuousInv β] (f : F) :
    @ContinuousInv α (tβ.induced f) _ 
goal: ContinuousNeg α

full_name: Specializes.neg
code: @[to_additive]
protected theorem Specializes.inv {x y : G} (h : x ⤳ y) : (x⁻¹) ⤳ (y⁻¹) 
goal: (-x) ⤳ (-y)

full_name: Specializes.inv
code: @[to_additive]
protected theorem Specializes.inv {x y : G} (h : x ⤳ y) : (x⁻¹) ⤳ (y⁻¹) 
goal: x⁻¹ ⤳ y⁻¹

full_name: Inseparable.inv
code: @[to_additive]
protected theorem Inseparable.inv {x y : G} (h : Inseparable x y) : Inseparable (x⁻¹) (y⁻¹) 
goal: Inseparable x⁻¹ y⁻¹

full_name: Inseparable.neg
code: @[to_additive]
protected theorem Inseparable.inv {x y : G} (h : Inseparable x y) : Inseparable (x⁻¹) (y⁻¹) 
goal: Inseparable (-x) (-y)

full_name: Specializes.zpow
code: @[to_additive]
protected theorem Specializes.zpow {G : Type*} [DivInvMonoid G] [TopologicalSpace G]
    [ContinuousMul G] [ContinuousInv G] {x y : G} (h : x ⤳ y) : ∀ m : ℤ, (x ^ m) ⤳ (y ^ m)
  
goal: (x ^ m) ⤳ (y ^ m)

full_name: Specializes.zsmul
code: @[to_additive]
protected theorem Specializes.zpow {G : Type*} [DivInvMonoid G] [TopologicalSpace G]
    [ContinuousMul G] [ContinuousInv G] {x y : G} (h : x ⤳ y) : ∀ m : ℤ, (x ^ m) ⤳ (y ^ m)
  
goal: (m • x) ⤳ (m • y)

full_name: Inseparable.zsmul
code: @[to_additive]
protected theorem Inseparable.zpow {G : Type*} [DivInvMonoid G] [TopologicalSpace G]
    [ContinuousMul G] [ContinuousInv G] {x y : G} (h : Inseparable x y) (m : ℤ) :
    Inseparable (x ^ m) (y ^ m) 
goal: Inseparable (m • x) (m • y)

full_name: Inseparable.zpow
code: @[to_additive]
protected theorem Inseparable.zpow {G : Type*} [DivInvMonoid G] [TopologicalSpace G]
    [ContinuousMul G] [ContinuousInv G] {x y : G} (h : Inseparable x y) (m : ℤ) :
    Inseparable (x ^ m) (y ^ m) 
goal: Inseparable (x ^ m) (y ^ m)

full_name: instContinuousNegULift
code: @[to_additive]
instance : ContinuousInv (ULift G) 
goal: ContinuousNeg (ULift.{u_1, w} G)

full_name: instContinuousInvULift
code: @[to_additive]
instance : ContinuousInv (ULift G) 
goal: ContinuousInv (ULift.{u_1, w} G)

full_name: continuousOn_inv
code: @[to_additive]
theorem continuousOn_inv {s : Set G} : ContinuousOn Inv.inv s 
goal: ContinuousOn Inv.inv s

full_name: continuousOn_neg
code: @[to_additive]
theorem continuousOn_inv {s : Set G} : ContinuousOn Inv.inv s 
goal: ContinuousOn Neg.neg s

full_name: continuousWithinAt_neg
code: @[to_additive]
theorem continuousWithinAt_inv {s : Set G} {x : G} : ContinuousWithinAt Inv.inv s x 
goal: ContinuousWithinAt Neg.neg s x

full_name: continuousWithinAt_inv
code: @[to_additive]
theorem continuousWithinAt_inv {s : Set G} {x : G} : ContinuousWithinAt Inv.inv s x 
goal: ContinuousWithinAt Inv.inv s x

full_name: continuousAt_neg
code: @[to_additive]
theorem continuousAt_inv {x : G} : ContinuousAt Inv.inv x 
goal: ContinuousAt Neg.neg x

full_name: continuousAt_inv
code: @[to_additive]
theorem continuousAt_inv {x : G} : ContinuousAt Inv.inv x 
goal: ContinuousAt Inv.inv x

full_name: tendsto_neg
code: @[to_additive]
theorem tendsto_inv (a : G) : Tendsto Inv.inv (𝓝 a) (𝓝 a⁻¹) 
goal: Filter.Tendsto Neg.neg (𝓝 a) (𝓝 (-a))

full_name: tendsto_inv
code: @[to_additive]
theorem tendsto_inv (a : G) : Tendsto Inv.inv (𝓝 a) (𝓝 a⁻¹) 
goal: Filter.Tendsto Inv.inv (𝓝 a) (𝓝 a⁻¹)

full_name: Filter.Tendsto.inv
code: /-- If a function converges to a value in a multiplicative topological group, then its inverse
converges to the inverse of this value. For the version in normed fields assuming additionally
that the limit is nonzero, use `Tendsto.inv'`. -/
@[to_additive
  "If a function converges to a value in an additive topological group, then its
  negation converges to the negation of this value."]
theorem Filter.Tendsto.inv {f : α → G} {l : Filter α} {y : G} (h : Tendsto f l (𝓝 y)) :
    Tendsto (fun x => (f x)⁻¹) l (𝓝 y⁻¹) 
goal: Filter.Tendsto (fun x => (f x)⁻¹) l (𝓝 y⁻¹)

full_name: Filter.Tendsto.neg
code: /-- If a function converges to a value in a multiplicative topological group, then its inverse
converges to the inverse of this value. For the version in normed fields assuming additionally
that the limit is nonzero, use `Tendsto.inv'`. -/
@[to_additive
  "If a function converges to a value in an additive topological group, then its
  negation converges to the negation of this value."]
theorem Filter.Tendsto.inv {f : α → G} {l : Filter α} {y : G} (h : Tendsto f l (𝓝 y)) :
    Tendsto (fun x => (f x)⁻¹) l (𝓝 y⁻¹) 
goal: Filter.Tendsto (fun x => -f x) l (𝓝 (-y))

full_name: Continuous.inv
code: @[to_additive (attr := continuity, fun_prop)]
theorem Continuous.inv (hf : Continuous f) : Continuous fun x => (f x)⁻¹ 
goal: Continuous fun x => (f x)⁻¹

full_name: Continuous.neg
code: @[to_additive (attr := continuity, fun_prop)]
theorem Continuous.inv (hf : Continuous f) : Continuous fun x => (f x)⁻¹ 
goal: Continuous fun x => -f x

full_name: ContinuousAt.inv
code: @[to_additive (attr := fun_prop)]
theorem ContinuousAt.inv (hf : ContinuousAt f x) : ContinuousAt (fun x => (f x)⁻¹) x 
goal: ContinuousAt (fun x => (f x)⁻¹) x

full_name: ContinuousAt.neg
code: @[to_additive (attr := fun_prop)]
theorem ContinuousAt.inv (hf : ContinuousAt f x) : ContinuousAt (fun x => (f x)⁻¹) x 
goal: ContinuousAt (fun x => -f x) x

full_name: ContinuousOn.inv
code: @[to_additive (attr := fun_prop)]
theorem ContinuousOn.inv (hf : ContinuousOn f s) : ContinuousOn (fun x => (f x)⁻¹) s 
goal: ContinuousOn (fun x => (f x)⁻¹) s

full_name: ContinuousOn.neg
code: @[to_additive (attr := fun_prop)]
theorem ContinuousOn.inv (hf : ContinuousOn f s) : ContinuousOn (fun x => (f x)⁻¹) s 
goal: ContinuousOn (fun x => -f x) s

full_name: ContinuousWithinAt.inv
code: @[to_additive]
theorem ContinuousWithinAt.inv (hf : ContinuousWithinAt f s x) :
    ContinuousWithinAt (fun x => (f x)⁻¹) s x 
goal: ContinuousWithinAt (fun x => (f x)⁻¹) s x

full_name: ContinuousWithinAt.neg
code: @[to_additive]
theorem ContinuousWithinAt.inv (hf : ContinuousWithinAt f s x) :
    ContinuousWithinAt (fun x => (f x)⁻¹) s x 
goal: ContinuousWithinAt (fun x => -f x) s x

full_name: Prod.continuousInv
code: @[to_additive]
instance Prod.continuousInv [TopologicalSpace H] [Inv H] [ContinuousInv H] :
    ContinuousInv (G × H) 
goal: ContinuousInv (G × H)

full_name: Prod.continuousNeg
code: @[to_additive]
instance Prod.continuousInv [TopologicalSpace H] [Inv H] [ContinuousInv H] :
    ContinuousInv (G × H) 
goal: ContinuousNeg (G × H)

full_name: Pi.continuousInv
code: @[to_additive]
instance Pi.continuousInv {C : ι → Type*} [∀ i, TopologicalSpace (C i)] [∀ i, Inv (C i)]
    [∀ i, ContinuousInv (C i)] : ContinuousInv (∀ i, C i) 
goal: ContinuousInv ((i : ι) → C i)

full_name: Pi.continuousNeg
code: @[to_additive]
instance Pi.continuousInv {C : ι → Type*} [∀ i, TopologicalSpace (C i)] [∀ i, Inv (C i)]
    [∀ i, ContinuousInv (C i)] : ContinuousInv (∀ i, C i) 
goal: ContinuousNeg ((i : ι) → C i)

full_name: Pi.has_continuous_neg'
code: /-- A version of `Pi.continuousInv` for non-dependent functions. It is needed because sometimes
Lean fails to use `Pi.continuousInv` for non-dependent functions. -/
@[to_additive
  "A version of `Pi.continuousNeg` for non-dependent functions. It is needed
  because sometimes Lean fails to use `Pi.continuousNeg` for non-dependent functions."]
instance Pi.has_continuous_inv' : ContinuousInv (ι → G) 
goal: ContinuousNeg (ι → G)

full_name: Pi.has_continuous_inv'
code: /-- A version of `Pi.continuousInv` for non-dependent functions. It is needed because sometimes
Lean fails to use `Pi.continuousInv` for non-dependent functions. -/
@[to_additive
  "A version of `Pi.continuousNeg` for non-dependent functions. It is needed
  because sometimes Lean fails to use `Pi.continuousNeg` for non-dependent functions."]
instance Pi.has_continuous_inv' : ContinuousInv (ι → G) 
goal: ContinuousInv (ι → G)

full_name: continuousInv_of_discreteTopology
code: @[to_additive]
instance (priority := 100) continuousInv_of_discreteTopology [TopologicalSpace H] [Inv H]
    [DiscreteTopology H] : ContinuousInv H 
goal: ContinuousInv H

full_name: continuousNeg_of_discreteTopology
code: @[to_additive]
instance (priority := 100) continuousInv_of_discreteTopology [TopologicalSpace H] [Inv H]
    [DiscreteTopology H] : ContinuousInv H 
goal: ContinuousNeg H

full_name: isClosed_setOf_map_neg
code: @[to_additive]
theorem isClosed_setOf_map_inv [Inv G₁] [Inv G₂] [ContinuousInv G₂] :
    IsClosed { f : G₁ → G₂ | ∀ x, f x⁻¹ = (f x)⁻¹ } 
goal: IsClosed {f | ∀ (x : G₁), f (-x) = -f x}

full_name: isClosed_setOf_map_inv
code: @[to_additive]
theorem isClosed_setOf_map_inv [Inv G₁] [Inv G₂] [ContinuousInv G₂] :
    IsClosed { f : G₁ → G₂ | ∀ x, f x⁻¹ = (f x)⁻¹ } 
goal: IsClosed {f | ∀ (x : G₁), f x⁻¹ = (f x)⁻¹}

full_name: instContinuousNegAdditiveOfContinuousInv
code: instance [TopologicalSpace H] [Inv H] [ContinuousInv H] : ContinuousNeg (Additive H) 
goal: ContinuousNeg (Additive H)

full_name: instContinuousInvMultiplicativeOfContinuousNeg
code: instance [TopologicalSpace H] [Neg H] [ContinuousNeg H] : ContinuousInv (Multiplicative H) 
goal: ContinuousInv (Multiplicative H)

full_name: IsCompact.neg
code: @[to_additive]
theorem IsCompact.inv (hs : IsCompact s) : IsCompact s⁻¹ 
goal: IsCompact (-s)

full_name: IsCompact.inv
code: @[to_additive]
theorem IsCompact.inv (hs : IsCompact s) : IsCompact s⁻¹ 
goal: IsCompact s⁻¹

full_name: Homeomorph.inv
code: /-- Inversion in a topological group as a homeomorphism. -/
@[to_additive "Negation in a topological group as a homeomorphism."]
protected def Homeomorph.inv (G : Type*) [TopologicalSpace G] [InvolutiveInv G]
    [ContinuousInv G] : G ≃ₜ G 
goal: G ≃ₜ G

full_name: Homeomorph.neg
code: /-- Inversion in a topological group as a homeomorphism. -/
@[to_additive "Negation in a topological group as a homeomorphism."]
protected def Homeomorph.inv (G : Type*) [TopologicalSpace G] [InvolutiveInv G]
    [ContinuousInv G] : G ≃ₜ G 
goal: G ≃ₜ G

full_name: Homeomorph.coe_neg
code: @[to_additive (attr := simp)]
lemma Homeomorph.coe_inv {G : Type*} [TopologicalSpace G] [InvolutiveInv G] [ContinuousInv G] :
    ⇑(Homeomorph.inv G) = Inv.inv 
goal: ⇑(Homeomorph.neg G) = Neg.neg

full_name: Homeomorph.coe_inv
code: @[to_additive (attr := simp)]
lemma Homeomorph.coe_inv {G : Type*} [TopologicalSpace G] [InvolutiveInv G] [ContinuousInv G] :
    ⇑(Homeomorph.inv G) = Inv.inv 
goal: ⇑(Homeomorph.inv G) = Inv.inv

full_name: isOpenMap_inv
code: @[to_additive]
theorem isOpenMap_inv : IsOpenMap (Inv.inv : G → G) 
goal: IsOpenMap Inv.inv

full_name: isOpenMap_neg
code: @[to_additive]
theorem isOpenMap_inv : IsOpenMap (Inv.inv : G → G) 
goal: IsOpenMap Neg.neg

full_name: isClosedMap_neg
code: @[to_additive]
theorem isClosedMap_inv : IsClosedMap (Inv.inv : G → G) 
goal: IsClosedMap Neg.neg

full_name: isClosedMap_inv
code: @[to_additive]
theorem isClosedMap_inv : IsClosedMap (Inv.inv : G → G) 
goal: IsClosedMap Inv.inv

full_name: IsOpen.inv
code: @[to_additive]
theorem IsOpen.inv (hs : IsOpen s) : IsOpen s⁻¹ 
goal: IsOpen s⁻¹

full_name: IsOpen.neg
code: @[to_additive]
theorem IsOpen.inv (hs : IsOpen s) : IsOpen s⁻¹ 
goal: IsOpen (-s)

full_name: IsClosed.inv
code: @[to_additive]
theorem IsClosed.inv (hs : IsClosed s) : IsClosed s⁻¹ 
goal: IsClosed s⁻¹

full_name: IsClosed.neg
code: @[to_additive]
theorem IsClosed.inv (hs : IsClosed s) : IsClosed s⁻¹ 
goal: IsClosed (-s)

full_name: neg_closure
code: @[to_additive]
theorem inv_closure : ∀ s : Set G, (closure s)⁻¹ = closure s⁻¹ 
goal: -closure s = closure (-s)

full_name: inv_closure
code: @[to_additive]
theorem inv_closure : ∀ s : Set G, (closure s)⁻¹ = closure s⁻¹ 
goal: (closure s)⁻¹ = closure s⁻¹

full_name: continuous_neg_iff
code: @[to_additive (attr := simp)]
lemma continuous_inv_iff : Continuous f⁻¹ ↔ Continuous f 
goal: Continuous (-f) ↔ Continuous f

full_name: continuous_inv_iff
code: @[to_additive (attr := simp)]
lemma continuous_inv_iff : Continuous f⁻¹ ↔ Continuous f 
goal: Continuous f⁻¹ ↔ Continuous f

full_name: continuousAt_inv_iff
code: @[to_additive (attr := simp)]
lemma continuousAt_inv_iff : ContinuousAt f⁻¹ x ↔ ContinuousAt f x 
goal: ContinuousAt f⁻¹ x ↔ ContinuousAt f x

full_name: continuousAt_neg_iff
code: @[to_additive (attr := simp)]
lemma continuousAt_inv_iff : ContinuousAt f⁻¹ x ↔ ContinuousAt f x 
goal: ContinuousAt (-f) x ↔ ContinuousAt f x

full_name: continuousOn_inv_iff
code: @[to_additive (attr := simp)]
lemma continuousOn_inv_iff : ContinuousOn f⁻¹ s ↔ ContinuousOn f s 
goal: ContinuousOn f⁻¹ s ↔ ContinuousOn f s

full_name: continuousOn_neg_iff
code: @[to_additive (attr := simp)]
lemma continuousOn_inv_iff : ContinuousOn f⁻¹ s ↔ ContinuousOn f s 
goal: ContinuousOn (-f) s ↔ ContinuousOn f s

full_name: continuousNeg_sInf
code: @[to_additive]
theorem continuousInv_sInf {ts : Set (TopologicalSpace G)}
    (h : ∀ t ∈ ts, @ContinuousInv G t _) : @ContinuousInv G (sInf ts) _ 
goal: ContinuousNeg G

full_name: continuousInv_sInf
code: @[to_additive]
theorem continuousInv_sInf {ts : Set (TopologicalSpace G)}
    (h : ∀ t ∈ ts, @ContinuousInv G t _) : @ContinuousInv G (sInf ts) _ 
goal: ContinuousInv G

full_name: continuousNeg_iInf
code: @[to_additive]
theorem continuousInv_iInf {ts' : ι' → TopologicalSpace G}
    (h' : ∀ i, @ContinuousInv G (ts' i) _) : @ContinuousInv G (⨅ i, ts' i) _ 
goal: ContinuousNeg G

full_name: continuousInv_iInf
code: @[to_additive]
theorem continuousInv_iInf {ts' : ι' → TopologicalSpace G}
    (h' : ∀ i, @ContinuousInv G (ts' i) _) : @ContinuousInv G (⨅ i, ts' i) _ 
goal: ContinuousInv G

full_name: continuousInv_inf
code: @[to_additive]
theorem continuousInv_inf {t₁ t₂ : TopologicalSpace G} (h₁ : @ContinuousInv G t₁ _)
    (h₂ : @ContinuousInv G t₂ _) : @ContinuousInv G (t₁ ⊓ t₂) _ 
goal: ContinuousInv G

full_name: continuousNeg_inf
code: @[to_additive]
theorem continuousInv_inf {t₁ t₂ : TopologicalSpace G} (h₁ : @ContinuousInv G t₁ _)
    (h₂ : @ContinuousInv G t₂ _) : @ContinuousInv G (t₁ ⊓ t₂) _ 
goal: ContinuousNeg G

full_name: Inducing.continuousNeg
code: @[to_additive]
theorem Inducing.continuousInv {G H : Type*} [Inv G] [Inv H] [TopologicalSpace G]
    [TopologicalSpace H] [ContinuousInv H] {f : G → H} (hf : Inducing f)
    (hf_inv : ∀ x, f x⁻¹ = (f x)⁻¹) : ContinuousInv G 
goal: ContinuousNeg G

full_name: Inducing.continuousInv
code: @[to_additive]
theorem Inducing.continuousInv {G H : Type*} [Inv G] [Inv H] [TopologicalSpace G]
    [TopologicalSpace H] [ContinuousInv H] {f : G → H} (hf : Inducing f)
    (hf_inv : ∀ x, f x⁻¹ = (f x)⁻¹) : ContinuousInv G 
goal: ContinuousInv G

full_name: TopologicalAddGroup
code: /-- A topological (additive) group is a group in which the addition and negation operations are
continuous. -/
class TopologicalAddGroup (G : Type u) [TopologicalSpace G] [AddGroup G] extends
  ContinuousAdd G, ContinuousNeg G : Prop
goal: Prop

full_name: TopologicalGroup
code: /-- A topological group is a group in which the multiplication and inversion operations are
continuous.

When you declare an instance that does not already have a `UniformSpace` instance,
you should also provide an instance of `UniformSpace` and `UniformGroup` using
`TopologicalGroup.toUniformSpace` and `topologicalCommGroup_isUniform`. -/
-- Porting note: check that these ↑ names exist once they've been ported in the future.
@[to_additive]
class TopologicalGroup (G : Type*) [TopologicalSpace G] [Group G] extends ContinuousMul G,
  ContinuousInv G : Prop
goal: Prop

full_name: ConjAct.units_continuousConstSMul
code: instance ConjAct.units_continuousConstSMul {M} [Monoid M] [TopologicalSpace M]
    [ContinuousMul M] : ContinuousConstSMul (ConjAct Mˣ) M 
goal: ContinuousConstSMul (ConjAct Mˣ) M

full_name: TopologicalGroup.continuous_conj_prod
code: /-- Conjugation is jointly continuous on `G × G` when both `mul` and `inv` are continuous. -/
@[to_additive
  "Conjugation is jointly continuous on `G × G` when both `add` and `neg` are continuous."]
theorem TopologicalGroup.continuous_conj_prod [ContinuousInv G] :
    Continuous fun g : G × G => g.fst * g.snd * g.fst⁻¹ 
goal: Continuous fun g => g.1 * g.2 * g.1⁻¹

full_name: TopologicalAddGroup.continuous_conj_sum
code: /-- Conjugation is jointly continuous on `G × G` when both `mul` and `inv` are continuous. -/
@[to_additive
  "Conjugation is jointly continuous on `G × G` when both `add` and `neg` are continuous."]
theorem TopologicalGroup.continuous_conj_prod [ContinuousInv G] :
    Continuous fun g : G × G => g.fst * g.snd * g.fst⁻¹ 
goal: Continuous fun g => g.1 + g.2 + -g.1

full_name: TopologicalAddGroup.continuous_conj
code: /-- Conjugation by a fixed element is continuous when `mul` is continuous. -/
@[to_additive (attr := continuity)
  "Conjugation by a fixed element is continuous when `add` is continuous."]
theorem TopologicalGroup.continuous_conj (g : G) : Continuous fun h : G => g * h * g⁻¹ 
goal: Continuous fun h => g + h + -g

full_name: TopologicalGroup.continuous_conj
code: /-- Conjugation by a fixed element is continuous when `mul` is continuous. -/
@[to_additive (attr := continuity)
  "Conjugation by a fixed element is continuous when `add` is continuous."]
theorem TopologicalGroup.continuous_conj (g : G) : Continuous fun h : G => g * h * g⁻¹ 
goal: Continuous fun h => g * h * g⁻¹

full_name: TopologicalGroup.continuous_conj'
code: /-- Conjugation acting on fixed element of the group is continuous when both `mul` and
`inv` are continuous. -/
@[to_additive (attr := continuity)
  "Conjugation acting on fixed element of the additive group is continuous when both
    `add` and `neg` are continuous."]
theorem TopologicalGroup.continuous_conj' [ContinuousInv G] (h : G) :
    Continuous fun g : G => g * h * g⁻¹ 
goal: Continuous fun g => g * h * g⁻¹

full_name: TopologicalAddGroup.continuous_conj'
code: /-- Conjugation acting on fixed element of the group is continuous when both `mul` and
`inv` are continuous. -/
@[to_additive (attr := continuity)
  "Conjugation acting on fixed element of the additive group is continuous when both
    `add` and `neg` are continuous."]
theorem TopologicalGroup.continuous_conj' [ContinuousInv G] (h : G) :
    Continuous fun g : G => g * h * g⁻¹ 
goal: Continuous fun g => g + h + -g

full_name: instTopologicalGroupULift
code: instance : TopologicalGroup (ULift G) 
goal: TopologicalGroup (ULift.{u_1, w} G)

full_name: continuous_zsmul
code: @[to_additive (attr := continuity)]
theorem continuous_zpow : ∀ z : ℤ, Continuous fun a : G => a ^ z
  
goal: Continuous fun a => z • a

full_name: continuous_zpow
code: @[to_additive (attr := continuity)]
theorem continuous_zpow : ∀ z : ℤ, Continuous fun a : G => a ^ z
  
goal: Continuous fun a => a ^ z

full_name: AddGroup.continuousConstSMul_int
code: instance AddGroup.continuousConstSMul_int {A} [AddGroup A] [TopologicalSpace A]
    [TopologicalAddGroup A] : ContinuousConstSMul ℤ A 
goal: ContinuousConstSMul ℤ A

full_name: AddGroup.continuousSMul_int
code: instance AddGroup.continuousSMul_int {A} [AddGroup A] [TopologicalSpace A]
    [TopologicalAddGroup A] : ContinuousSMul ℤ A 
goal: ContinuousSMul ℤ A

full_name: Continuous.zsmul
code: @[to_additive (attr := continuity, fun_prop)]
theorem Continuous.zpow {f : α → G} (h : Continuous f) (z : ℤ) : Continuous fun b => f b ^ z 
goal: Continuous fun b => z • f b

full_name: Continuous.zpow
code: @[to_additive (attr := continuity, fun_prop)]
theorem Continuous.zpow {f : α → G} (h : Continuous f) (z : ℤ) : Continuous fun b => f b ^ z 
goal: Continuous fun b => f b ^ z

full_name: continuousOn_zpow
code: @[to_additive]
theorem continuousOn_zpow {s : Set G} (z : ℤ) : ContinuousOn (fun x => x ^ z) s 
goal: ContinuousOn (fun x => x ^ z) s

full_name: continuousOn_zsmul
code: @[to_additive]
theorem continuousOn_zpow {s : Set G} (z : ℤ) : ContinuousOn (fun x => x ^ z) s 
goal: ContinuousOn (fun x => z • x) s

full_name: continuousAt_zsmul
code: @[to_additive]
theorem continuousAt_zpow (x : G) (z : ℤ) : ContinuousAt (fun x => x ^ z) x 
goal: ContinuousAt (fun x => z • x) x

full_name: continuousAt_zpow
code: @[to_additive]
theorem continuousAt_zpow (x : G) (z : ℤ) : ContinuousAt (fun x => x ^ z) x 
goal: ContinuousAt (fun x => x ^ z) x

full_name: Filter.Tendsto.zsmul
code: @[to_additive]
theorem Filter.Tendsto.zpow {α} {l : Filter α} {f : α → G} {x : G} (hf : Tendsto f l (𝓝 x))
    (z : ℤ) : Tendsto (fun x => f x ^ z) l (𝓝 (x ^ z)) 
goal: Filter.Tendsto (fun x => z • f x) l (𝓝 (z • x))

full_name: Filter.Tendsto.zpow
code: @[to_additive]
theorem Filter.Tendsto.zpow {α} {l : Filter α} {f : α → G} {x : G} (hf : Tendsto f l (𝓝 x))
    (z : ℤ) : Tendsto (fun x => f x ^ z) l (𝓝 (x ^ z)) 
goal: Filter.Tendsto (fun x => f x ^ z) l (𝓝 (x ^ z))

full_name: ContinuousWithinAt.zsmul
code: @[to_additive]
theorem ContinuousWithinAt.zpow {f : α → G} {x : α} {s : Set α} (hf : ContinuousWithinAt f s x)
    (z : ℤ) : ContinuousWithinAt (fun x => f x ^ z) s x 
goal: ContinuousWithinAt (fun x => z • f x) s x

full_name: ContinuousWithinAt.zpow
code: @[to_additive]
theorem ContinuousWithinAt.zpow {f : α → G} {x : α} {s : Set α} (hf : ContinuousWithinAt f s x)
    (z : ℤ) : ContinuousWithinAt (fun x => f x ^ z) s x 
goal: ContinuousWithinAt (fun x => f x ^ z) s x

full_name: ContinuousAt.zpow
code: @[to_additive (attr := fun_prop)]
theorem ContinuousAt.zpow {f : α → G} {x : α} (hf : ContinuousAt f x) (z : ℤ) :
    ContinuousAt (fun x => f x ^ z) x 
goal: ContinuousAt (fun x => f x ^ z) x

full_name: ContinuousAt.zsmul
code: @[to_additive (attr := fun_prop)]
theorem ContinuousAt.zpow {f : α → G} {x : α} (hf : ContinuousAt f x) (z : ℤ) :
    ContinuousAt (fun x => f x ^ z) x 
goal: ContinuousAt (fun x => z • f x) x

full_name: ContinuousOn.zsmul
code: @[to_additive (attr := fun_prop)]
theorem ContinuousOn.zpow {f : α → G} {s : Set α} (hf : ContinuousOn f s) (z : ℤ) :
    ContinuousOn (fun x => f x ^ z) s 
goal: ContinuousOn (fun x => z • f x) s

full_name: ContinuousOn.zpow
code: @[to_additive (attr := fun_prop)]
theorem ContinuousOn.zpow {f : α → G} {s : Set α} (hf : ContinuousOn f s) (z : ℤ) :
    ContinuousOn (fun x => f x ^ z) s 
goal: ContinuousOn (fun x => f x ^ z) s

full_name: tendsto_inv_nhdsWithin_Ioi
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Ioi {a : H} : Tendsto Inv.inv (𝓝[>] a) (𝓝[<] a⁻¹) 
goal: Filter.Tendsto Inv.inv (𝓝[>] a) (𝓝[<] a⁻¹)

full_name: tendsto_neg_nhdsWithin_Ioi
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Ioi {a : H} : Tendsto Inv.inv (𝓝[>] a) (𝓝[<] a⁻¹) 
goal: Filter.Tendsto Neg.neg (𝓝[>] a) (𝓝[<] (-a))

full_name: tendsto_neg_nhdsWithin_Iio
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Iio {a : H} : Tendsto Inv.inv (𝓝[<] a) (𝓝[>] a⁻¹) 
goal: Filter.Tendsto Neg.neg (𝓝[<] a) (𝓝[>] (-a))

full_name: tendsto_inv_nhdsWithin_Iio
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Iio {a : H} : Tendsto Inv.inv (𝓝[<] a) (𝓝[>] a⁻¹) 
goal: Filter.Tendsto Inv.inv (𝓝[<] a) (𝓝[>] a⁻¹)

full_name: tendsto_neg_nhdsWithin_Ioi_neg
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Ioi_inv {a : H} : Tendsto Inv.inv (𝓝[>] a⁻¹) (𝓝[<] a) 
goal: Filter.Tendsto Neg.neg (𝓝[>] (-a)) (𝓝[<] a)

full_name: tendsto_inv_nhdsWithin_Ioi_inv
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Ioi_inv {a : H} : Tendsto Inv.inv (𝓝[>] a⁻¹) (𝓝[<] a) 
goal: Filter.Tendsto Inv.inv (𝓝[>] a⁻¹) (𝓝[<] a)

full_name: tendsto_neg_nhdsWithin_Iio_neg
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Iio_inv {a : H} : Tendsto Inv.inv (𝓝[<] a⁻¹) (𝓝[>] a) 
goal: Filter.Tendsto Neg.neg (𝓝[<] (-a)) (𝓝[>] a)

full_name: tendsto_inv_nhdsWithin_Iio_inv
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Iio_inv {a : H} : Tendsto Inv.inv (𝓝[<] a⁻¹) (𝓝[>] a) 
goal: Filter.Tendsto Inv.inv (𝓝[<] a⁻¹) (𝓝[>] a)

full_name: tendsto_neg_nhdsWithin_Ici
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Ici {a : H} : Tendsto Inv.inv (𝓝[≥] a) (𝓝[≤] a⁻¹) 
goal: Filter.Tendsto Neg.neg (𝓝[≥] a) (𝓝[≤] (-a))

full_name: tendsto_inv_nhdsWithin_Ici
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Ici {a : H} : Tendsto Inv.inv (𝓝[≥] a) (𝓝[≤] a⁻¹) 
goal: Filter.Tendsto Inv.inv (𝓝[≥] a) (𝓝[≤] a⁻¹)

full_name: tendsto_neg_nhdsWithin_Iic
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Iic {a : H} : Tendsto Inv.inv (𝓝[≤] a) (𝓝[≥] a⁻¹) 
goal: Filter.Tendsto Neg.neg (𝓝[≤] a) (𝓝[≥] (-a))

full_name: tendsto_inv_nhdsWithin_Iic
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Iic {a : H} : Tendsto Inv.inv (𝓝[≤] a) (𝓝[≥] a⁻¹) 
goal: Filter.Tendsto Inv.inv (𝓝[≤] a) (𝓝[≥] a⁻¹)

full_name: tendsto_neg_nhdsWithin_Ici_neg
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Ici_inv {a : H} : Tendsto Inv.inv (𝓝[≥] a⁻¹) (𝓝[≤] a) 
goal: Filter.Tendsto Neg.neg (𝓝[≥] (-a)) (𝓝[≤] a)

full_name: tendsto_inv_nhdsWithin_Ici_inv
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Ici_inv {a : H} : Tendsto Inv.inv (𝓝[≥] a⁻¹) (𝓝[≤] a) 
goal: Filter.Tendsto Inv.inv (𝓝[≥] a⁻¹) (𝓝[≤] a)

full_name: tendsto_inv_nhdsWithin_Iic_inv
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Iic_inv {a : H} : Tendsto Inv.inv (𝓝[≤] a⁻¹) (𝓝[≥] a) 
goal: Filter.Tendsto Inv.inv (𝓝[≤] a⁻¹) (𝓝[≥] a)

full_name: tendsto_neg_nhdsWithin_Iic_neg
code: @[to_additive]
theorem tendsto_inv_nhdsWithin_Iic_inv {a : H} : Tendsto Inv.inv (𝓝[≤] a⁻¹) (𝓝[≥] a) 
goal: Filter.Tendsto Neg.neg (𝓝[≤] (-a)) (𝓝[≥] a)

full_name: instTopologicalAddGroupSum
code: @[to_additive]
instance [TopologicalSpace H] [Group H] [TopologicalGroup H] : TopologicalGroup (G × H) 
goal: TopologicalAddGroup (G × H)

full_name: instTopologicalGroupProd
code: @[to_additive]
instance [TopologicalSpace H] [Group H] [TopologicalGroup H] : TopologicalGroup (G × H) 
goal: TopologicalGroup (G × H)

full_name: Pi.topologicalAddGroup
code: @[to_additive]
instance Pi.topologicalGroup {C : β → Type*} [∀ b, TopologicalSpace (C b)] [∀ b, Group (C b)]
    [∀ b, TopologicalGroup (C b)] : TopologicalGroup (∀ b, C b) 
goal: TopologicalAddGroup ((b : β) → C b)

full_name: Pi.topologicalGroup
code: @[to_additive]
instance Pi.topologicalGroup {C : β → Type*} [∀ b, TopologicalSpace (C b)] [∀ b, Group (C b)]
    [∀ b, TopologicalGroup (C b)] : TopologicalGroup (∀ b, C b) 
goal: TopologicalGroup ((b : β) → C b)

full_name: instContinuousInvMulOpposite
code: @[to_additive]
instance [Inv α] [ContinuousInv α] : ContinuousInv αᵐᵒᵖ 
goal: ContinuousInv αᵐᵒᵖ

full_name: instContinuousNegAddOpposite
code: @[to_additive]
instance [Inv α] [ContinuousInv α] : ContinuousInv αᵐᵒᵖ 
goal: ContinuousNeg αᵃᵒᵖ

full_name: instTopologicalGroupMulOpposite
code: /-- If multiplication is continuous in `α`, then it also is in `αᵐᵒᵖ`. -/
@[to_additive "If addition is continuous in `α`, then it also is in `αᵃᵒᵖ`."]
instance [Group α] [TopologicalGroup α] : TopologicalGroup αᵐᵒᵖ 
goal: TopologicalGroup αᵐᵒᵖ

full_name: instTopologicalAddGroupAddOpposite
code: /-- If multiplication is continuous in `α`, then it also is in `αᵐᵒᵖ`. -/
@[to_additive "If addition is continuous in `α`, then it also is in `αᵃᵒᵖ`."]
instance [Group α] [TopologicalGroup α] : TopologicalGroup αᵐᵒᵖ 
goal: TopologicalAddGroup αᵃᵒᵖ

full_name: nhds_zero_symm
code: @[to_additive]
theorem nhds_one_symm : comap Inv.inv (𝓝 (1 : G)) = 𝓝 (1 : G) 
goal: Filter.comap Neg.neg (𝓝 0) = 𝓝 0

full_name: nhds_one_symm
code: @[to_additive]
theorem nhds_one_symm : comap Inv.inv (𝓝 (1 : G)) = 𝓝 (1 : G) 
goal: Filter.comap Inv.inv (𝓝 1) = 𝓝 1

full_name: nhds_one_symm'
code: @[to_additive]
theorem nhds_one_symm' : map Inv.inv (𝓝 (1 : G)) = 𝓝 (1 : G) 
goal: Filter.map Inv.inv (𝓝 1) = 𝓝 1

full_name: nhds_zero_symm'
code: @[to_additive]
theorem nhds_one_symm' : map Inv.inv (𝓝 (1 : G)) = 𝓝 (1 : G) 
goal: Filter.map Neg.neg (𝓝 0) = 𝓝 0

full_name: inv_mem_nhds_one
code: @[to_additive]
theorem inv_mem_nhds_one {S : Set G} (hS : S ∈ (𝓝 1 : Filter G)) : S⁻¹ ∈ 𝓝 (1 : G) 
goal: S⁻¹ ∈ 𝓝 1

full_name: neg_mem_nhds_zero
code: @[to_additive]
theorem inv_mem_nhds_one {S : Set G} (hS : S ∈ (𝓝 1 : Filter G)) : S⁻¹ ∈ 𝓝 (1 : G) 
goal: -S ∈ 𝓝 0

full_name: Homeomorph.shearMulRight
code: /-- The map `(x, y) ↦ (x, x * y)` as a homeomorphism. This is a shear mapping. -/
@[to_additive "The map `(x, y) ↦ (x, x + y)` as a homeomorphism. This is a shear mapping."]
protected def Homeomorph.shearMulRight : G × G ≃ₜ G × G 
goal: G × G ≃ₜ G × G

full_name: Homeomorph.shearAddRight
code: /-- The map `(x, y) ↦ (x, x * y)` as a homeomorphism. This is a shear mapping. -/
@[to_additive "The map `(x, y) ↦ (x, x + y)` as a homeomorphism. This is a shear mapping."]
protected def Homeomorph.shearMulRight : G × G ≃ₜ G × G 
goal: G × G ≃ₜ G × G

full_name: Homeomorph.shearMulRight_coe
code: @[to_additive (attr := simp)]
theorem Homeomorph.shearMulRight_coe :
    ⇑(Homeomorph.shearMulRight G) = fun z : G × G => (z.1, z.1 * z.2) 
goal: ⇑(Homeomorph.shearMulRight G) = fun z => (z.1, z.1 * z.2)

full_name: Homeomorph.shearAddRight_coe
code: @[to_additive (attr := simp)]
theorem Homeomorph.shearMulRight_coe :
    ⇑(Homeomorph.shearMulRight G) = fun z : G × G => (z.1, z.1 * z.2) 
goal: ⇑(Homeomorph.shearAddRight G) = fun z => (z.1, z.1 + z.2)

full_name: Homeomorph.shearMulRight_symm_coe
code: @[to_additive (attr := simp)]
theorem Homeomorph.shearMulRight_symm_coe :
    ⇑(Homeomorph.shearMulRight G).symm = fun z : G × G => (z.1, z.1⁻¹ * z.2) 
goal: ⇑(Homeomorph.shearMulRight G).symm = fun z => (z.1, z.1⁻¹ * z.2)

full_name: Homeomorph.shearAddRight_symm_coe
code: @[to_additive (attr := simp)]
theorem Homeomorph.shearMulRight_symm_coe :
    ⇑(Homeomorph.shearMulRight G).symm = fun z : G × G => (z.1, z.1⁻¹ * z.2) 
goal: ⇑(Homeomorph.shearAddRight G).symm = fun z => (z.1, -z.1 + z.2)

full_name: Inducing.topologicalGroup
code: @[to_additive]
protected theorem Inducing.topologicalGroup {F : Type*} [Group H] [TopologicalSpace H]
    [FunLike F H G] [MonoidHomClass F H G] (f : F) (hf : Inducing f) : TopologicalGroup H 
goal: TopologicalGroup H

full_name: Inducing.topologicalAddGroup
code: @[to_additive]
protected theorem Inducing.topologicalGroup {F : Type*} [Group H] [TopologicalSpace H]
    [FunLike F H G] [MonoidHomClass F H G] (f : F) (hf : Inducing f) : TopologicalGroup H 
goal: TopologicalAddGroup H

full_name: topologicalGroup_induced
code: @[to_additive]
-- Porting note: removed `protected` (needs to be in namespace)
theorem topologicalGroup_induced {F : Type*} [Group H] [FunLike F H G] [MonoidHomClass F H G]
    (f : F) :
    @TopologicalGroup H (induced f ‹_›) _ 
goal: TopologicalGroup H

full_name: topologicalAddGroup_induced
code: @[to_additive]
-- Porting note: removed `protected` (needs to be in namespace)
theorem topologicalGroup_induced {F : Type*} [Group H] [FunLike F H G] [MonoidHomClass F H G]
    (f : F) :
    @TopologicalGroup H (induced f ‹_›) _ 
goal: TopologicalAddGroup H

full_name: AddSubgroup.instTopologicalAddGroupSubtypeMem
code: @[to_additive]
instance (S : Subgroup G) : TopologicalGroup S 
goal: TopologicalAddGroup ↥S

full_name: Subgroup.instTopologicalGroupSubtypeMem
code: @[to_additive]
instance (S : Subgroup G) : TopologicalGroup S 
goal: TopologicalGroup ↥S

full_name: Subgroup.topologicalClosure
code: /-- The (topological-space) closure of a subgroup of a topological group is
itself a subgroup. -/
@[to_additive
  "The (topological-space) closure of an additive subgroup of an additive topological group is
  itself an additive subgroup."]
def Subgroup.topologicalClosure (s : Subgroup G) : Subgroup G 
goal: Subgroup G

full_name: AddSubgroup.topologicalClosure
code: /-- The (topological-space) closure of a subgroup of a topological group is
itself a subgroup. -/
@[to_additive
  "The (topological-space) closure of an additive subgroup of an additive topological group is
  itself an additive subgroup."]
def Subgroup.topologicalClosure (s : Subgroup G) : Subgroup G 
goal: AddSubgroup G

full_name: AddSubgroup.topologicalClosure_coe
code: @[to_additive (attr := simp)]
theorem Subgroup.topologicalClosure_coe {s : Subgroup G} :
    (s.topologicalClosure : Set G) = _root_.closure s 
goal: ↑s.topologicalClosure = closure ↑s

full_name: Subgroup.topologicalClosure_coe
code: @[to_additive (attr := simp)]
theorem Subgroup.topologicalClosure_coe {s : Subgroup G} :
    (s.topologicalClosure : Set G) = _root_.closure s 
goal: ↑s.topologicalClosure = closure ↑s

full_name: Subgroup.le_topologicalClosure
code: @[to_additive]
theorem Subgroup.le_topologicalClosure (s : Subgroup G) : s ≤ s.topologicalClosure 
goal: s ≤ s.topologicalClosure

full_name: AddSubgroup.le_topologicalClosure
code: @[to_additive]
theorem Subgroup.le_topologicalClosure (s : Subgroup G) : s ≤ s.topologicalClosure 
goal: s ≤ s.topologicalClosure

full_name: Subgroup.isClosed_topologicalClosure
code: @[to_additive]
theorem Subgroup.isClosed_topologicalClosure (s : Subgroup G) :
    IsClosed (s.topologicalClosure : Set G) 
goal: IsClosed ↑s.topologicalClosure

full_name: AddSubgroup.isClosed_topologicalClosure
code: @[to_additive]
theorem Subgroup.isClosed_topologicalClosure (s : Subgroup G) :
    IsClosed (s.topologicalClosure : Set G) 
goal: IsClosed ↑s.topologicalClosure

full_name: Subgroup.topologicalClosure_minimal
code: @[to_additive]
theorem Subgroup.topologicalClosure_minimal (s : Subgroup G) {t : Subgroup G} (h : s ≤ t)
    (ht : IsClosed (t : Set G)) : s.topologicalClosure ≤ t 
goal: s.topologicalClosure ≤ t

full_name: AddSubgroup.topologicalClosure_minimal
code: @[to_additive]
theorem Subgroup.topologicalClosure_minimal (s : Subgroup G) {t : Subgroup G} (h : s ≤ t)
    (ht : IsClosed (t : Set G)) : s.topologicalClosure ≤ t 
goal: s.topologicalClosure ≤ t

full_name: DenseRange.topologicalClosure_map_addSubgroup
code: @[to_additive]
theorem DenseRange.topologicalClosure_map_subgroup [Group H] [TopologicalSpace H]
    [TopologicalGroup H] {f : G →* H} (hf : Continuous f) (hf' : DenseRange f) {s : Subgroup G}
    (hs : s.topologicalClosure = ⊤) : (s.map f).topologicalClosure = ⊤ 
goal: (AddSubgroup.map f s).topologicalClosure = ⊤

full_name: DenseRange.topologicalClosure_map_subgroup
code: @[to_additive]
theorem DenseRange.topologicalClosure_map_subgroup [Group H] [TopologicalSpace H]
    [TopologicalGroup H] {f : G →* H} (hf : Continuous f) (hf' : DenseRange f) {s : Subgroup G}
    (hs : s.topologicalClosure = ⊤) : (s.map f).topologicalClosure = ⊤ 
goal: (Subgroup.map f s).topologicalClosure = ⊤

full_name: AddSubgroup.is_normal_topologicalClosure
code: /-- The topological closure of a normal subgroup is normal. -/
@[to_additive "The topological closure of a normal additive subgroup is normal."]
theorem Subgroup.is_normal_topologicalClosure {G : Type*} [TopologicalSpace G] [Group G]
    [TopologicalGroup G] (N : Subgroup G) [N.Normal] : (Subgroup.topologicalClosure N).Normal 
goal: N.topologicalClosure.Normal

full_name: Subgroup.is_normal_topologicalClosure
code: /-- The topological closure of a normal subgroup is normal. -/
@[to_additive "The topological closure of a normal additive subgroup is normal."]
theorem Subgroup.is_normal_topologicalClosure {G : Type*} [TopologicalSpace G] [Group G]
    [TopologicalGroup G] (N : Subgroup G) [N.Normal] : (Subgroup.topologicalClosure N).Normal 
goal: N.topologicalClosure.Normal

full_name: mul_mem_connectedComponent_one
code: @[to_additive]
theorem mul_mem_connectedComponent_one {G : Type*} [TopologicalSpace G] [MulOneClass G]
    [ContinuousMul G] {g h : G} (hg : g ∈ connectedComponent (1 : G))
    (hh : h ∈ connectedComponent (1 : G)) : g * h ∈ connectedComponent (1 : G) 
goal: g * h ∈ connectedComponent 1

full_name: add_mem_connectedComponent_zero
code: @[to_additive]
theorem mul_mem_connectedComponent_one {G : Type*} [TopologicalSpace G] [MulOneClass G]
    [ContinuousMul G] {g h : G} (hg : g ∈ connectedComponent (1 : G))
    (hh : h ∈ connectedComponent (1 : G)) : g * h ∈ connectedComponent (1 : G) 
goal: g + h ∈ connectedComponent 0

full_name: inv_mem_connectedComponent_one
code: @[to_additive]
theorem inv_mem_connectedComponent_one {G : Type*} [TopologicalSpace G] [Group G]
    [TopologicalGroup G] {g : G} (hg : g ∈ connectedComponent (1 : G)) :
    g⁻¹ ∈ connectedComponent (1 : G) 
goal: g⁻¹ ∈ connectedComponent 1

full_name: neg_mem_connectedComponent_zero
code: @[to_additive]
theorem inv_mem_connectedComponent_one {G : Type*} [TopologicalSpace G] [Group G]
    [TopologicalGroup G] {g : G} (hg : g ∈ connectedComponent (1 : G)) :
    g⁻¹ ∈ connectedComponent (1 : G) 
goal: -g ∈ connectedComponent 0

full_name: AddSubgroup.connectedComponentOfZero
code: /-- The connected component of 1 is a subgroup of `G`. -/
@[to_additive "The connected component of 0 is a subgroup of `G`."]
def Subgroup.connectedComponentOfOne (G : Type*) [TopologicalSpace G] [Group G]
    [TopologicalGroup G] : Subgroup G 
goal: AddSubgroup G

full_name: Subgroup.connectedComponentOfOne
code: /-- The connected component of 1 is a subgroup of `G`. -/
@[to_additive "The connected component of 0 is a subgroup of `G`."]
def Subgroup.connectedComponentOfOne (G : Type*) [TopologicalSpace G] [Group G]
    [TopologicalGroup G] : Subgroup G 
goal: Subgroup G

full_name: AddSubgroup.addCommGroupTopologicalClosure
code: /-- If a subgroup of a topological group is commutative, then so is its topological closure. -/
@[to_additive
  "If a subgroup of an additive topological group is commutative, then so is its
  topological closure."]
def Subgroup.commGroupTopologicalClosure [T2Space G] (s : Subgroup G)
    (hs : ∀ x y : s, x * y = y * x) : CommGroup s.topologicalClosure 
goal: AddCommGroup ↥s.topologicalClosure

full_name: Subgroup.commGroupTopologicalClosure
code: /-- If a subgroup of a topological group is commutative, then so is its topological closure. -/
@[to_additive
  "If a subgroup of an additive topological group is commutative, then so is its
  topological closure."]
def Subgroup.commGroupTopologicalClosure [T2Space G] (s : Subgroup G)
    (hs : ∀ x y : s, x * y = y * x) : CommGroup s.topologicalClosure 
goal: CommGroup ↥s.topologicalClosure

full_name: AddSubgroup.coe_topologicalClosure_bot
code: @[to_additive]
lemma Subgroup.coe_topologicalClosure_bot :
    ((⊥ : Subgroup G).topologicalClosure : Set G) = _root_.closure ({1} : Set G) 
goal: ↑⊥.topologicalClosure = closure {0}

full_name: Subgroup.coe_topologicalClosure_bot
code: @[to_additive]
lemma Subgroup.coe_topologicalClosure_bot :
    ((⊥ : Subgroup G).topologicalClosure : Set G) = _root_.closure ({1} : Set G) 
goal: ↑⊥.topologicalClosure = closure {1}

full_name: exists_nhds_split_inv
code: @[to_additive exists_nhds_half_neg]
theorem exists_nhds_split_inv {s : Set G} (hs : s ∈ 𝓝 (1 : G)) :
    ∃ V ∈ 𝓝 (1 : G), ∀ v ∈ V, ∀ w ∈ V, v / w ∈ s 
goal: ∃ V ∈ 𝓝 1, ∀ v ∈ V, ∀ w ∈ V, v / w ∈ s

full_name: exists_nhds_half_neg
code: @[to_additive exists_nhds_half_neg]
theorem exists_nhds_split_inv {s : Set G} (hs : s ∈ 𝓝 (1 : G)) :
    ∃ V ∈ 𝓝 (1 : G), ∀ v ∈ V, ∀ w ∈ V, v / w ∈ s 
goal: ∃ V ∈ 𝓝 0, ∀ v ∈ V, ∀ w ∈ V, v - w ∈ s

full_name: nhds_translation_add_neg
code: @[to_additive]
theorem nhds_translation_mul_inv (x : G) : comap (· * x⁻¹) (𝓝 1) = 𝓝 x 
goal: Filter.comap (fun x_1 => x_1 + -x) (𝓝 0) = 𝓝 x

full_name: nhds_translation_mul_inv
code: @[to_additive]
theorem nhds_translation_mul_inv (x : G) : comap (· * x⁻¹) (𝓝 1) = 𝓝 x 
goal: Filter.comap (fun x_1 => x_1 * x⁻¹) (𝓝 1) = 𝓝 x

full_name: map_add_left_nhds
code: @[to_additive (attr := simp)]
theorem map_mul_left_nhds (x y : G) : map (x * ·) (𝓝 y) = 𝓝 (x * y) 
goal: Filter.map (fun x_1 => x + x_1) (𝓝 y) = 𝓝 (x + y)

full_name: map_mul_left_nhds
code: @[to_additive (attr := simp)]
theorem map_mul_left_nhds (x y : G) : map (x * ·) (𝓝 y) = 𝓝 (x * y) 
goal: Filter.map (fun x_1 => x * x_1) (𝓝 y) = 𝓝 (x * y)

full_name: map_mul_left_nhds_one
code: @[to_additive]
theorem map_mul_left_nhds_one (x : G) : map (x * ·) (𝓝 1) = 𝓝 x 
goal: Filter.map (fun x_1 => x * x_1) (𝓝 1) = 𝓝 x

full_name: map_add_left_nhds_zero
code: @[to_additive]
theorem map_mul_left_nhds_one (x : G) : map (x * ·) (𝓝 1) = 𝓝 x 
goal: Filter.map (fun x_1 => x + x_1) (𝓝 0) = 𝓝 x

full_name: map_mul_right_nhds
code: @[to_additive (attr := simp)]
theorem map_mul_right_nhds (x y : G) : map (· * x) (𝓝 y) = 𝓝 (y * x) 
goal: Filter.map (fun x_1 => x_1 * x) (𝓝 y) = 𝓝 (y * x)

full_name: map_add_right_nhds
code: @[to_additive (attr := simp)]
theorem map_mul_right_nhds (x y : G) : map (· * x) (𝓝 y) = 𝓝 (y * x) 
goal: Filter.map (fun x_1 => x_1 + x) (𝓝 y) = 𝓝 (y + x)

full_name: map_mul_right_nhds_one
code: @[to_additive]
theorem map_mul_right_nhds_one (x : G) : map (· * x) (𝓝 1) = 𝓝 x 
goal: Filter.map (fun x_1 => x_1 * x) (𝓝 1) = 𝓝 x

full_name: map_add_right_nhds_zero
code: @[to_additive]
theorem map_mul_right_nhds_one (x : G) : map (· * x) (𝓝 1) = 𝓝 x 
goal: Filter.map (fun x_1 => x_1 + x) (𝓝 0) = 𝓝 x

full_name: Filter.HasBasis.nhds_of_one
code: @[to_additive]
theorem Filter.HasBasis.nhds_of_one {ι : Sort*} {p : ι → Prop} {s : ι → Set G}
    (hb : HasBasis (𝓝 1 : Filter G) p s) (x : G) :
    HasBasis (𝓝 x) p fun i => { y | y / x ∈ s i } 
goal: (𝓝 x).HasBasis p fun i => {y | y / x ∈ s i}

full_name: Filter.HasBasis.nhds_of_zero
code: @[to_additive]
theorem Filter.HasBasis.nhds_of_one {ι : Sort*} {p : ι → Prop} {s : ι → Set G}
    (hb : HasBasis (𝓝 1 : Filter G) p s) (x : G) :
    HasBasis (𝓝 x) p fun i => { y | y / x ∈ s i } 
goal: (𝓝 x).HasBasis p fun i => {y | y - x ∈ s i}

full_name: mem_closure_iff_nhds_zero
code: @[to_additive]
theorem mem_closure_iff_nhds_one {x : G} {s : Set G} :
    x ∈ closure s ↔ ∀ U ∈ (𝓝 1 : Filter G), ∃ y ∈ s, y / x ∈ U 
goal: x ∈ closure s ↔ ∀ U ∈ 𝓝 0, ∃ y ∈ s, y - x ∈ U

full_name: mem_closure_iff_nhds_one
code: @[to_additive]
theorem mem_closure_iff_nhds_one {x : G} {s : Set G} :
    x ∈ closure s ↔ ∀ U ∈ (𝓝 1 : Filter G), ∃ y ∈ s, y / x ∈ U 
goal: x ∈ closure s ↔ ∀ U ∈ 𝓝 1, ∃ y ∈ s, y / x ∈ U

full_name: continuous_of_continuousAt_zero
code: /-- A monoid homomorphism (a bundled morphism of a type that implements `MonoidHomClass`) from a
topological group to a topological monoid is continuous provided that it is continuous at one. See
also `uniformContinuous_of_continuousAt_one`. -/
@[to_additive
  "An additive monoid homomorphism (a bundled morphism of a type that implements
  `AddMonoidHomClass`) from an additive topological group to an additive topological monoid is
  continuous provided that it is continuous at zero. See also
  `uniformContinuous_of_continuousAt_zero`."]
theorem continuous_of_continuousAt_one {M hom : Type*} [MulOneClass M] [TopologicalSpace M]
    [ContinuousMul M] [FunLike hom G M] [MonoidHomClass hom G M] (f : hom)
    (hf : ContinuousAt f 1) :
    Continuous f 
goal: Continuous ⇑f

full_name: continuous_of_continuousAt_one
code: /-- A monoid homomorphism (a bundled morphism of a type that implements `MonoidHomClass`) from a
topological group to a topological monoid is continuous provided that it is continuous at one. See
also `uniformContinuous_of_continuousAt_one`. -/
@[to_additive
  "An additive monoid homomorphism (a bundled morphism of a type that implements
  `AddMonoidHomClass`) from an additive topological group to an additive topological monoid is
  continuous provided that it is continuous at zero. See also
  `uniformContinuous_of_continuousAt_zero`."]
theorem continuous_of_continuousAt_one {M hom : Type*} [MulOneClass M] [TopologicalSpace M]
    [ContinuousMul M] [FunLike hom G M] [MonoidHomClass hom G M] (f : hom)
    (hf : ContinuousAt f 1) :
    Continuous f 
goal: Continuous ⇑f

full_name: continuous_of_continuousAt_one₂
code: @[to_additive continuous_of_continuousAt_zero₂]
theorem continuous_of_continuousAt_one₂ {H M : Type*} [CommMonoid M] [TopologicalSpace M]
    [ContinuousMul M] [Group H] [TopologicalSpace H] [TopologicalGroup H] (f : G →* H →* M)
    (hf : ContinuousAt (fun x : G × H ↦ f x.1 x.2) (1, 1))
    (hl : ∀ x, ContinuousAt (f x) 1) (hr : ∀ y, ContinuousAt (f · y) 1) :
    Continuous (fun x : G × H ↦ f x.1 x.2) 
goal: Continuous fun x => (f x.1) x.2

full_name: continuous_of_continuousAt_zero₂
code: @[to_additive continuous_of_continuousAt_zero₂]
theorem continuous_of_continuousAt_one₂ {H M : Type*} [CommMonoid M] [TopologicalSpace M]
    [ContinuousMul M] [Group H] [TopologicalSpace H] [TopologicalGroup H] (f : G →* H →* M)
    (hf : ContinuousAt (fun x : G × H ↦ f x.1 x.2) (1, 1))
    (hl : ∀ x, ContinuousAt (f x) 1) (hr : ∀ y, ContinuousAt (f · y) 1) :
    Continuous (fun x : G × H ↦ f x.1 x.2) 
goal: Continuous fun x => (f x.1) x.2

full_name: TopologicalGroup.ext
code: @[to_additive]
theorem TopologicalGroup.ext {G : Type*} [Group G] {t t' : TopologicalSpace G}
    (tg : @TopologicalGroup G t _) (tg' : @TopologicalGroup G t' _)
    (h : @nhds G t 1 = @nhds G t' 1) : t = t' 
goal: t = t'

full_name: TopologicalAddGroup.ext
code: @[to_additive]
theorem TopologicalGroup.ext {G : Type*} [Group G] {t t' : TopologicalSpace G}
    (tg : @TopologicalGroup G t _) (tg' : @TopologicalGroup G t' _)
    (h : @nhds G t 1 = @nhds G t' 1) : t = t' 
goal: t = t'

full_name: TopologicalAddGroup.ext_iff
code: @[to_additive]
theorem TopologicalGroup.ext_iff {G : Type*} [Group G] {t t' : TopologicalSpace G}
    (tg : @TopologicalGroup G t _) (tg' : @TopologicalGroup G t' _) :
    t = t' ↔ @nhds G t 1 = @nhds G t' 1 
goal: t = t' ↔ 𝓝 0 = 𝓝 0

full_name: TopologicalGroup.ext_iff
code: @[to_additive]
theorem TopologicalGroup.ext_iff {G : Type*} [Group G] {t t' : TopologicalSpace G}
    (tg : @TopologicalGroup G t _) (tg' : @TopologicalGroup G t' _) :
    t = t' ↔ @nhds G t 1 = @nhds G t' 1 
goal: t = t' ↔ 𝓝 1 = 𝓝 1

full_name: ContinuousNeg.of_nhds_zero
code: @[to_additive]
theorem ContinuousInv.of_nhds_one {G : Type*} [Group G] [TopologicalSpace G]
    (hinv : Tendsto (fun x : G => x⁻¹) (𝓝 1) (𝓝 1))
    (hleft : ∀ x₀ : G, 𝓝 x₀ = map (fun x : G => x₀ * x) (𝓝 1))
    (hconj : ∀ x₀ : G, Tendsto (fun x : G => x₀ * x * x₀⁻¹) (𝓝 1) (𝓝 1)) : ContinuousInv G 
goal: ContinuousNeg G

full_name: ContinuousInv.of_nhds_one
code: @[to_additive]
theorem ContinuousInv.of_nhds_one {G : Type*} [Group G] [TopologicalSpace G]
    (hinv : Tendsto (fun x : G => x⁻¹) (𝓝 1) (𝓝 1))
    (hleft : ∀ x₀ : G, 𝓝 x₀ = map (fun x : G => x₀ * x) (𝓝 1))
    (hconj : ∀ x₀ : G, Tendsto (fun x : G => x₀ * x * x₀⁻¹) (𝓝 1) (𝓝 1)) : ContinuousInv G 
goal: ContinuousInv G

full_name: TopologicalAddGroup.of_nhds_zero'
code: @[to_additive]
theorem TopologicalGroup.of_nhds_one' {G : Type u} [Group G] [TopologicalSpace G]
    (hmul : Tendsto (uncurry ((· * ·) : G → G → G)) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1))
    (hinv : Tendsto (fun x : G => x⁻¹) (𝓝 1) (𝓝 1))
    (hleft : ∀ x₀ : G, 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1))
    (hright : ∀ x₀ : G, 𝓝 x₀ = map (fun x => x * x₀) (𝓝 1)) : TopologicalGroup G 
goal: TopologicalAddGroup G

full_name: TopologicalGroup.of_nhds_one'
code: @[to_additive]
theorem TopologicalGroup.of_nhds_one' {G : Type u} [Group G] [TopologicalSpace G]
    (hmul : Tendsto (uncurry ((· * ·) : G → G → G)) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1))
    (hinv : Tendsto (fun x : G => x⁻¹) (𝓝 1) (𝓝 1))
    (hleft : ∀ x₀ : G, 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1))
    (hright : ∀ x₀ : G, 𝓝 x₀ = map (fun x => x * x₀) (𝓝 1)) : TopologicalGroup G 
goal: TopologicalGroup G

full_name: TopologicalGroup.of_nhds_one
code: @[to_additive]
theorem TopologicalGroup.of_nhds_one {G : Type u} [Group G] [TopologicalSpace G]
    (hmul : Tendsto (uncurry ((· * ·) : G → G → G)) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1))
    (hinv : Tendsto (fun x : G => x⁻¹) (𝓝 1) (𝓝 1))
    (hleft : ∀ x₀ : G, 𝓝 x₀ = map (x₀ * ·) (𝓝 1))
    (hconj : ∀ x₀ : G, Tendsto (x₀ * · * x₀⁻¹) (𝓝 1) (𝓝 1)) : TopologicalGroup G 
goal: TopologicalGroup G

full_name: TopologicalAddGroup.of_nhds_zero
code: @[to_additive]
theorem TopologicalGroup.of_nhds_one {G : Type u} [Group G] [TopologicalSpace G]
    (hmul : Tendsto (uncurry ((· * ·) : G → G → G)) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1))
    (hinv : Tendsto (fun x : G => x⁻¹) (𝓝 1) (𝓝 1))
    (hleft : ∀ x₀ : G, 𝓝 x₀ = map (x₀ * ·) (𝓝 1))
    (hconj : ∀ x₀ : G, Tendsto (x₀ * · * x₀⁻¹) (𝓝 1) (𝓝 1)) : TopologicalGroup G 
goal: TopologicalAddGroup G

full_name: TopologicalGroup.of_comm_of_nhds_one
code: @[to_additive]
theorem TopologicalGroup.of_comm_of_nhds_one {G : Type u} [CommGroup G] [TopologicalSpace G]
    (hmul : Tendsto (uncurry ((· * ·) : G → G → G)) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1))
    (hinv : Tendsto (fun x : G => x⁻¹) (𝓝 1) (𝓝 1))
    (hleft : ∀ x₀ : G, 𝓝 x₀ = map (x₀ * ·) (𝓝 1)) : TopologicalGroup G 
goal: TopologicalGroup G

full_name: TopologicalAddGroup.of_comm_of_nhds_zero
code: @[to_additive]
theorem TopologicalGroup.of_comm_of_nhds_one {G : Type u} [CommGroup G] [TopologicalSpace G]
    (hmul : Tendsto (uncurry ((· * ·) : G → G → G)) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1))
    (hinv : Tendsto (fun x : G => x⁻¹) (𝓝 1) (𝓝 1))
    (hleft : ∀ x₀ : G, 𝓝 x₀ = map (x₀ * ·) (𝓝 1)) : TopologicalGroup G 
goal: TopologicalAddGroup G

full_name: QuotientAddGroup.Quotient.topologicalSpace
code: @[to_additive]
instance QuotientGroup.Quotient.topologicalSpace {G : Type*} [Group G] [TopologicalSpace G]
    (N : Subgroup G) : TopologicalSpace (G ⧸ N) 
goal: TopologicalSpace (G ⧸ N)

full_name: QuotientGroup.Quotient.topologicalSpace
code: @[to_additive]
instance QuotientGroup.Quotient.topologicalSpace {G : Type*} [Group G] [TopologicalSpace G]
    (N : Subgroup G) : TopologicalSpace (G ⧸ N) 
goal: TopologicalSpace (G ⧸ N)

full_name: QuotientAddGroup.isOpenMap_coe
code: @[to_additive]
theorem QuotientGroup.isOpenMap_coe : IsOpenMap ((↑) : G → G ⧸ N) 
goal: IsOpenMap QuotientAddGroup.mk

full_name: QuotientGroup.isOpenMap_coe
code: @[to_additive]
theorem QuotientGroup.isOpenMap_coe : IsOpenMap ((↑) : G → G ⧸ N) 
goal: IsOpenMap QuotientGroup.mk

full_name: topologicalAddGroup_quotient
code: @[to_additive]
instance topologicalGroup_quotient [N.Normal] : TopologicalGroup (G ⧸ N) 
goal: TopologicalAddGroup (G ⧸ N)

full_name: topologicalGroup_quotient
code: @[to_additive]
instance topologicalGroup_quotient [N.Normal] : TopologicalGroup (G ⧸ N) 
goal: TopologicalGroup (G ⧸ N)

full_name: QuotientGroup.nhds_eq
code: /-- Neighborhoods in the quotient are precisely the map of neighborhoods in the prequotient. -/
@[to_additive
  "Neighborhoods in the quotient are precisely the map of neighborhoods in the prequotient."]
theorem QuotientGroup.nhds_eq (x : G) : 𝓝 (x : G ⧸ N) = Filter.map (↑) (𝓝 x) 
goal: 𝓝 ↑x = Filter.map QuotientGroup.mk (𝓝 x)

full_name: QuotientAddGroup.nhds_eq
code: /-- Neighborhoods in the quotient are precisely the map of neighborhoods in the prequotient. -/
@[to_additive
  "Neighborhoods in the quotient are precisely the map of neighborhoods in the prequotient."]
theorem QuotientGroup.nhds_eq (x : G) : 𝓝 (x : G ⧸ N) = Filter.map (↑) (𝓝 x) 
goal: 𝓝 ↑x = Filter.map QuotientAddGroup.mk (𝓝 x)

full_name: TopologicalAddGroup.exists_antitone_basis_nhds_zero
code: /-- Any first countable topological group has an antitone neighborhood basis `u : ℕ → Set G` for
which `(u (n + 1)) ^ 2 ⊆ u n`. The existence of such a neighborhood basis is a key tool for
`QuotientGroup.completeSpace` -/
@[to_additive
  "Any first countable topological additive group has an antitone neighborhood basis
  `u : ℕ → set G` for which `u (n + 1) + u (n + 1) ⊆ u n`.
  The existence of such a neighborhood basis is a key tool for `QuotientAddGroup.completeSpace`"]
theorem TopologicalGroup.exists_antitone_basis_nhds_one :
    ∃ u : ℕ → Set G, (𝓝 1).HasAntitoneBasis u ∧ ∀ n, u (n + 1) * u (n + 1) ⊆ u n 
goal: ∃ u, (𝓝 0).HasAntitoneBasis u ∧ ∀ (n : ℕ), u (n + 1) + u (n + 1) ⊆ u n

full_name: TopologicalGroup.exists_antitone_basis_nhds_one
code: /-- Any first countable topological group has an antitone neighborhood basis `u : ℕ → Set G` for
which `(u (n + 1)) ^ 2 ⊆ u n`. The existence of such a neighborhood basis is a key tool for
`QuotientGroup.completeSpace` -/
@[to_additive
  "Any first countable topological additive group has an antitone neighborhood basis
  `u : ℕ → set G` for which `u (n + 1) + u (n + 1) ⊆ u n`.
  The existence of such a neighborhood basis is a key tool for `QuotientAddGroup.completeSpace`"]
theorem TopologicalGroup.exists_antitone_basis_nhds_one :
    ∃ u : ℕ → Set G, (𝓝 1).HasAntitoneBasis u ∧ ∀ n, u (n + 1) * u (n + 1) ⊆ u n 
goal: ∃ u, (𝓝 1).HasAntitoneBasis u ∧ ∀ (n : ℕ), u (n + 1) * u (n + 1) ⊆ u n

full_name: QuotientGroup.nhds_one_isCountablyGenerated
code: /-- In a first countable topological group `G` with normal subgroup `N`, `1 : G ⧸ N` has a
countable neighborhood basis. -/
@[to_additive
  "In a first countable topological additive group `G` with normal additive subgroup
  `N`, `0 : G ⧸ N` has a countable neighborhood basis."]
instance QuotientGroup.nhds_one_isCountablyGenerated : (𝓝 (1 : G ⧸ N)).IsCountablyGenerated 
goal: (𝓝 1).IsCountablyGenerated

full_name: QuotientAddGroup.nhds_zero_isCountablyGenerated
code: /-- In a first countable topological group `G` with normal subgroup `N`, `1 : G ⧸ N` has a
countable neighborhood basis. -/
@[to_additive
  "In a first countable topological additive group `G` with normal additive subgroup
  `N`, `0 : G ⧸ N` has a countable neighborhood basis."]
instance QuotientGroup.nhds_one_isCountablyGenerated : (𝓝 (1 : G ⧸ N)).IsCountablyGenerated 
goal: (𝓝 0).IsCountablyGenerated

full_name: ContinuousSub.continuous_sub
code: /-- A typeclass saying that `p : G × G ↦ p.1 - p.2` is a continuous function. This property
automatically holds for topological additive groups but it also holds, e.g., for `ℝ≥0`. -/
class ContinuousSub (G : Type*) [TopologicalSpace G] [Sub G] : Prop where
  continuous_sub : Continuous fun p : G × G => p.1 - p.2
goal: Continuous fun p => p.1 - p.2

full_name: ContinuousSub
code: /-- A typeclass saying that `p : G × G ↦ p.1 - p.2` is a continuous function. This property
automatically holds for topological additive groups but it also holds, e.g., for `ℝ≥0`. -/
class ContinuousSub (G : Type*) [TopologicalSpace G] [Sub G] : Prop where
  continuous_sub : Continuous fun p : G × G => p.1 - p.2
goal: Prop

full_name: ContinuousDiv
code: /-- A typeclass saying that `p : G × G ↦ p.1 / p.2` is a continuous function. This property
automatically holds for topological groups. Lemmas using this class have primes.
The unprimed version is for `GroupWithZero`. -/
@[to_additive existing]
class ContinuousDiv (G : Type*) [TopologicalSpace G] [Div G] : Prop where
  continuous_div' : Continuous fun p : G × G => p.1 / p.2
goal: Prop

full_name: ContinuousDiv.continuous_div'
code: /-- A typeclass saying that `p : G × G ↦ p.1 / p.2` is a continuous function. This property
automatically holds for topological groups. Lemmas using this class have primes.
The unprimed version is for `GroupWithZero`. -/
@[to_additive existing]
class ContinuousDiv (G : Type*) [TopologicalSpace G] [Div G] : Prop where
  continuous_div' : Continuous fun p : G × G => p.1 / p.2
goal: Continuous fun p => p.1 / p.2

full_name: TopologicalAddGroup.to_continuousSub
code: @[to_additive]
instance (priority := 100) TopologicalGroup.to_continuousDiv [TopologicalSpace G] [Group G]
    [TopologicalGroup G] : ContinuousDiv G 
goal: ContinuousSub G

full_name: TopologicalGroup.to_continuousDiv
code: @[to_additive]
instance (priority := 100) TopologicalGroup.to_continuousDiv [TopologicalSpace G] [Group G]
    [TopologicalGroup G] : ContinuousDiv G 
goal: ContinuousDiv G

full_name: Filter.Tendsto.div'
code: @[to_additive sub]
theorem Filter.Tendsto.div' {f g : α → G} {l : Filter α} {a b : G} (hf : Tendsto f l (𝓝 a))
    (hg : Tendsto g l (𝓝 b)) : Tendsto (fun x => f x / g x) l (𝓝 (a / b)) 
goal: Filter.Tendsto (fun x => f x / g x) l (𝓝 (a / b))

full_name: Filter.Tendsto.sub
code: @[to_additive sub]
theorem Filter.Tendsto.div' {f g : α → G} {l : Filter α} {a b : G} (hf : Tendsto f l (𝓝 a))
    (hg : Tendsto g l (𝓝 b)) : Tendsto (fun x => f x / g x) l (𝓝 (a / b)) 
goal: Filter.Tendsto (fun x => f x - g x) l (𝓝 (a - b))

full_name: Filter.Tendsto.const_div'
code: @[to_additive const_sub]
theorem Filter.Tendsto.const_div' (b : G) {c : G} {f : α → G} {l : Filter α}
    (h : Tendsto f l (𝓝 c)) : Tendsto (fun k : α => b / f k) l (𝓝 (b / c)) 
goal: Filter.Tendsto (fun k => b / f k) l (𝓝 (b / c))

full_name: Filter.Tendsto.const_sub
code: @[to_additive const_sub]
theorem Filter.Tendsto.const_div' (b : G) {c : G} {f : α → G} {l : Filter α}
    (h : Tendsto f l (𝓝 c)) : Tendsto (fun k : α => b / f k) l (𝓝 (b / c)) 
goal: Filter.Tendsto (fun k => b - f k) l (𝓝 (b - c))

full_name: Filter.tendsto_const_div_iff
code: @[to_additive]
lemma Filter.tendsto_const_div_iff {G : Type*} [CommGroup G] [TopologicalSpace G] [ContinuousDiv G]
    (b : G) {c : G} {f : α → G} {l : Filter α} :
    Tendsto (fun k : α ↦ b / f k) l (𝓝 (b / c)) ↔ Tendsto f l (𝓝 c) 
goal: Filter.Tendsto (fun k => b / f k) l (𝓝 (b / c)) ↔ Filter.Tendsto f l (𝓝 c)

full_name: Filter.tendsto_const_sub_iff
code: @[to_additive]
lemma Filter.tendsto_const_div_iff {G : Type*} [CommGroup G] [TopologicalSpace G] [ContinuousDiv G]
    (b : G) {c : G} {f : α → G} {l : Filter α} :
    Tendsto (fun k : α ↦ b / f k) l (𝓝 (b / c)) ↔ Tendsto f l (𝓝 c) 
goal: Filter.Tendsto (fun k => b - f k) l (𝓝 (b - c)) ↔ Filter.Tendsto f l (𝓝 c)

full_name: Filter.Tendsto.div_const'
code: @[to_additive sub_const]
theorem Filter.Tendsto.div_const' {c : G} {f : α → G} {l : Filter α} (h : Tendsto f l (𝓝 c))
    (b : G) : Tendsto (f · / b) l (𝓝 (c / b)) 
goal: Filter.Tendsto (fun x => f x / b) l (𝓝 (c / b))

full_name: Filter.Tendsto.sub_const
code: @[to_additive sub_const]
theorem Filter.Tendsto.div_const' {c : G} {f : α → G} {l : Filter α} (h : Tendsto f l (𝓝 c))
    (b : G) : Tendsto (f · / b) l (𝓝 (c / b)) 
goal: Filter.Tendsto (fun x => f x - b) l (𝓝 (c - b))

full_name: Filter.tendsto_div_const_iff
code: lemma Filter.tendsto_div_const_iff {G : Type*}
    [CommGroupWithZero G] [TopologicalSpace G] [ContinuousDiv G]
    {b : G} (hb : b ≠ 0) {c : G} {f : α → G} {l : Filter α} :
    Tendsto (f · / b) l (𝓝 (c / b)) ↔ Tendsto f l (𝓝 c) 
goal: Filter.Tendsto (fun x => f x / b) l (𝓝 (c / b)) ↔ Filter.Tendsto f l (𝓝 c)

full_name: Filter.tendsto_sub_const_iff
code: lemma Filter.tendsto_sub_const_iff {G : Type*}
    [AddCommGroup G] [TopologicalSpace G] [ContinuousSub G]
    (b : G) {c : G} {f : α → G} {l : Filter α} :
    Tendsto (f · - b) l (𝓝 (c - b)) ↔ Tendsto f l (𝓝 c) 
goal: Filter.Tendsto (fun x => f x - b) l (𝓝 (c - b)) ↔ Filter.Tendsto f l (𝓝 c)

full_name: Continuous.div'
code: @[to_additive (attr := continuity, fun_prop) sub]
theorem Continuous.div' (hf : Continuous f) (hg : Continuous g) : Continuous fun x => f x / g x 
goal: Continuous fun x => f x / g x

full_name: Continuous.sub
code: @[to_additive (attr := continuity, fun_prop) sub]
theorem Continuous.div' (hf : Continuous f) (hg : Continuous g) : Continuous fun x => f x / g x 
goal: Continuous fun x => f x - g x

full_name: continuous_sub_left
code: @[to_additive (attr := continuity) continuous_sub_left]
lemma continuous_div_left' (a : G) : Continuous (a / ·) 
goal: Continuous fun x => a - x

full_name: continuous_div_left'
code: @[to_additive (attr := continuity) continuous_sub_left]
lemma continuous_div_left' (a : G) : Continuous (a / ·) 
goal: Continuous fun x => a / x

full_name: continuous_div_right'
code: @[to_additive (attr := continuity) continuous_sub_right]
lemma continuous_div_right' (a : G) : Continuous (· / a) 
goal: Continuous fun x => x / a

full_name: continuous_sub_right
code: @[to_additive (attr := continuity) continuous_sub_right]
lemma continuous_div_right' (a : G) : Continuous (· / a) 
goal: Continuous fun x => x - a

full_name: ContinuousAt.sub
code: @[to_additive (attr := fun_prop) sub]
theorem ContinuousAt.div' {f g : α → G} {x : α} (hf : ContinuousAt f x) (hg : ContinuousAt g x) :
    ContinuousAt (fun x => f x / g x) x 
goal: ContinuousAt (fun x => f x - g x) x

full_name: ContinuousAt.div'
code: @[to_additive (attr := fun_prop) sub]
theorem ContinuousAt.div' {f g : α → G} {x : α} (hf : ContinuousAt f x) (hg : ContinuousAt g x) :
    ContinuousAt (fun x => f x / g x) x 
goal: ContinuousAt (fun x => f x / g x) x

full_name: ContinuousWithinAt.sub
code: @[to_additive sub]
theorem ContinuousWithinAt.div' (hf : ContinuousWithinAt f s x) (hg : ContinuousWithinAt g s x) :
    ContinuousWithinAt (fun x => f x / g x) s x 
goal: ContinuousWithinAt (fun x => f x - g x) s x

full_name: ContinuousWithinAt.div'
code: @[to_additive sub]
theorem ContinuousWithinAt.div' (hf : ContinuousWithinAt f s x) (hg : ContinuousWithinAt g s x) :
    ContinuousWithinAt (fun x => f x / g x) s x 
goal: ContinuousWithinAt (fun x => f x / g x) s x

full_name: ContinuousOn.sub
code: @[to_additive (attr := fun_prop) sub]
theorem ContinuousOn.div' (hf : ContinuousOn f s) (hg : ContinuousOn g s) :
    ContinuousOn (fun x => f x / g x) s 
goal: ContinuousOn (fun x => f x - g x) s

full_name: ContinuousOn.div'
code: @[to_additive (attr := fun_prop) sub]
theorem ContinuousOn.div' (hf : ContinuousOn f s) (hg : ContinuousOn g s) :
    ContinuousOn (fun x => f x / g x) s 
goal: ContinuousOn (fun x => f x / g x) s

full_name: Homeomorph.divLeft
code: /-- A version of `Homeomorph.mulLeft a b⁻¹` that is defeq to `a / b`. -/
@[to_additive (attr := simps! (config := { simpRhs := true }))
  " A version of `Homeomorph.addLeft a (-b)` that is defeq to `a - b`. "]
def Homeomorph.divLeft (x : G) : G ≃ₜ G 
goal: G ≃ₜ G

full_name: Homeomorph.subLeft_symm_apply
code: /-- A version of `Homeomorph.mulLeft a b⁻¹` that is defeq to `a / b`. -/
@[to_additive (attr := simps! (config := { simpRhs := true }))
  " A version of `Homeomorph.addLeft a (-b)` that is defeq to `a - b`. "]
def Homeomorph.divLeft (x : G) : G ≃ₜ G 
goal: (Homeomorph.subLeft x).symm b = -b + x

full_name: Homeomorph.subLeft_apply
code: /-- A version of `Homeomorph.mulLeft a b⁻¹` that is defeq to `a / b`. -/
@[to_additive (attr := simps! (config := { simpRhs := true }))
  " A version of `Homeomorph.addLeft a (-b)` that is defeq to `a - b`. "]
def Homeomorph.divLeft (x : G) : G ≃ₜ G 
goal: (Homeomorph.subLeft x) b = x - b

full_name: Homeomorph.subLeft
code: /-- A version of `Homeomorph.mulLeft a b⁻¹` that is defeq to `a / b`. -/
@[to_additive (attr := simps! (config := { simpRhs := true }))
  " A version of `Homeomorph.addLeft a (-b)` that is defeq to `a - b`. "]
def Homeomorph.divLeft (x : G) : G ≃ₜ G 
goal: G ≃ₜ G

full_name: Homeomorph.divLeft_apply
code: /-- A version of `Homeomorph.mulLeft a b⁻¹` that is defeq to `a / b`. -/
@[to_additive (attr := simps! (config := { simpRhs := true }))
  " A version of `Homeomorph.addLeft a (-b)` that is defeq to `a - b`. "]
def Homeomorph.divLeft (x : G) : G ≃ₜ G 
goal: (Homeomorph.divLeft x) b = x / b

full_name: Homeomorph.divLeft_symm_apply
code: /-- A version of `Homeomorph.mulLeft a b⁻¹` that is defeq to `a / b`. -/
@[to_additive (attr := simps! (config := { simpRhs := true }))
  " A version of `Homeomorph.addLeft a (-b)` that is defeq to `a - b`. "]
def Homeomorph.divLeft (x : G) : G ≃ₜ G 
goal: (Homeomorph.divLeft x).symm b = b⁻¹ * x

full_name: isOpenMap_sub_left
code: @[to_additive]
theorem isOpenMap_div_left (a : G) : IsOpenMap (a / ·) 
goal: IsOpenMap fun x => a - x

full_name: isOpenMap_div_left
code: @[to_additive]
theorem isOpenMap_div_left (a : G) : IsOpenMap (a / ·) 
goal: IsOpenMap fun x => a / x

full_name: isClosedMap_sub_left
code: @[to_additive]
theorem isClosedMap_div_left (a : G) : IsClosedMap (a / ·) 
goal: IsClosedMap fun x => a - x

full_name: isClosedMap_div_left
code: @[to_additive]
theorem isClosedMap_div_left (a : G) : IsClosedMap (a / ·) 
goal: IsClosedMap fun x => a / x

full_name: Homeomorph.divRight_apply
code: /-- A version of `Homeomorph.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps! (config := { simpRhs := true }))
  "A version of `Homeomorph.addRight (-a) b` that is defeq to `b - a`. "]
def Homeomorph.divRight (x : G) : G ≃ₜ G 
goal: (Homeomorph.divRight x) b = b / x

full_name: Homeomorph.divRight
code: /-- A version of `Homeomorph.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps! (config := { simpRhs := true }))
  "A version of `Homeomorph.addRight (-a) b` that is defeq to `b - a`. "]
def Homeomorph.divRight (x : G) : G ≃ₜ G 
goal: G ≃ₜ G

full_name: Homeomorph.divRight_symm_apply
code: /-- A version of `Homeomorph.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps! (config := { simpRhs := true }))
  "A version of `Homeomorph.addRight (-a) b` that is defeq to `b - a`. "]
def Homeomorph.divRight (x : G) : G ≃ₜ G 
goal: (Homeomorph.divRight x).symm b = b * x

full_name: Homeomorph.subRight
code: /-- A version of `Homeomorph.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps! (config := { simpRhs := true }))
  "A version of `Homeomorph.addRight (-a) b` that is defeq to `b - a`. "]
def Homeomorph.divRight (x : G) : G ≃ₜ G 
goal: G ≃ₜ G

full_name: Homeomorph.subRight_symm_apply
code: /-- A version of `Homeomorph.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps! (config := { simpRhs := true }))
  "A version of `Homeomorph.addRight (-a) b` that is defeq to `b - a`. "]
def Homeomorph.divRight (x : G) : G ≃ₜ G 
goal: (Homeomorph.subRight x).symm b = b + x

full_name: Homeomorph.subRight_apply
code: /-- A version of `Homeomorph.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps! (config := { simpRhs := true }))
  "A version of `Homeomorph.addRight (-a) b` that is defeq to `b - a`. "]
def Homeomorph.divRight (x : G) : G ≃ₜ G 
goal: (Homeomorph.subRight x) b = b - x

full_name: isOpenMap_div_right
code: @[to_additive]
lemma isOpenMap_div_right (a : G) : IsOpenMap (· / a) 
goal: IsOpenMap fun x => x / a

full_name: isOpenMap_sub_right
code: @[to_additive]
lemma isOpenMap_div_right (a : G) : IsOpenMap (· / a) 
goal: IsOpenMap fun x => x - a

full_name: isClosedMap_sub_right
code: @[to_additive]
lemma isClosedMap_div_right (a : G) : IsClosedMap (· / a) 
goal: IsClosedMap fun x => x - a

full_name: isClosedMap_div_right
code: @[to_additive]
lemma isClosedMap_div_right (a : G) : IsClosedMap (· / a) 
goal: IsClosedMap fun x => x / a

full_name: tendsto_sub_nhds_zero_iff
code: @[to_additive]
theorem tendsto_div_nhds_one_iff {α : Type*} {l : Filter α} {x : G} {u : α → G} :
    Tendsto (u · / x) l (𝓝 1) ↔ Tendsto u l (𝓝 x) 
goal: Filter.Tendsto (fun x_1 => u x_1 - x) l (𝓝 0) ↔ Filter.Tendsto u l (𝓝 x)

full_name: tendsto_div_nhds_one_iff
code: @[to_additive]
theorem tendsto_div_nhds_one_iff {α : Type*} {l : Filter α} {x : G} {u : α → G} :
    Tendsto (u · / x) l (𝓝 1) ↔ Tendsto u l (𝓝 x) 
goal: Filter.Tendsto (fun x_1 => u x_1 / x) l (𝓝 1) ↔ Filter.Tendsto u l (𝓝 x)

full_name: nhds_translation_div
code: @[to_additive]
theorem nhds_translation_div (x : G) : comap (· / x) (𝓝 1) = 𝓝 x 
goal: Filter.comap (fun x_1 => x_1 / x) (𝓝 1) = 𝓝 x

full_name: nhds_translation_sub
code: @[to_additive]
theorem nhds_translation_div (x : G) : comap (· / x) (𝓝 1) = 𝓝 x 
goal: Filter.comap (fun x_1 => x_1 - x) (𝓝 0) = 𝓝 x

full_name: IsOpen.vadd_left
code: @[to_additive]
theorem IsOpen.smul_left (ht : IsOpen t) : IsOpen (s • t) 
goal: IsOpen (s +ᵥ t)

full_name: IsOpen.smul_left
code: @[to_additive]
theorem IsOpen.smul_left (ht : IsOpen t) : IsOpen (s • t) 
goal: IsOpen (s • t)

full_name: subset_interior_vadd_right
code: @[to_additive]
theorem subset_interior_smul_right : s • interior t ⊆ interior (s • t) 
goal: s +ᵥ interior t ⊆ interior (s +ᵥ t)

full_name: subset_interior_smul_right
code: @[to_additive]
theorem subset_interior_smul_right : s • interior t ⊆ interior (s • t) 
goal: s • interior t ⊆ interior (s • t)

full_name: vadd_mem_nhds
code: @[to_additive]
theorem smul_mem_nhds (a : α) {x : β} (ht : t ∈ 𝓝 x) : a • t ∈ 𝓝 (a • x) 
goal: a +ᵥ t ∈ 𝓝 (a +ᵥ x)

full_name: smul_mem_nhds
code: @[to_additive]
theorem smul_mem_nhds (a : α) {x : β} (ht : t ∈ 𝓝 x) : a • t ∈ 𝓝 (a • x) 
goal: a • t ∈ 𝓝 (a • x)

full_name: subset_interior_vadd
code: @[to_additive]
theorem subset_interior_smul : interior s • interior t ⊆ interior (s • t) 
goal: interior s +ᵥ interior t ⊆ interior (s +ᵥ t)

full_name: subset_interior_smul
code: @[to_additive]
theorem subset_interior_smul : interior s • interior t ⊆ interior (s • t) 
goal: interior s • interior t ⊆ interior (s • t)

full_name: IsClosed.vadd_left_of_isCompact
code: @[to_additive]
theorem IsClosed.smul_left_of_isCompact (ht : IsClosed t) (hs : IsCompact s) :
    IsClosed (s • t) 
goal: IsClosed (s +ᵥ t)

full_name: IsClosed.smul_left_of_isCompact
code: @[to_additive]
theorem IsClosed.smul_left_of_isCompact (ht : IsClosed t) (hs : IsCompact s) :
    IsClosed (s • t) 
goal: IsClosed (s • t)

full_name: AddAction.isClosedMap_quotient
code: @[to_additive]
theorem MulAction.isClosedMap_quotient [CompactSpace α] :
    letI := orbitRel α β
    IsClosedMap (Quotient.mk' : β → Quotient (orbitRel α β)) 
goal: IsClosedMap Quotient.mk'

full_name: MulAction.isClosedMap_quotient
code: @[to_additive]
theorem MulAction.isClosedMap_quotient [CompactSpace α] :
    letI := orbitRel α β
    IsClosedMap (Quotient.mk' : β → Quotient (orbitRel α β)) 
goal: IsClosedMap Quotient.mk'

full_name: IsOpen.add_left
code: @[to_additive]
theorem IsOpen.mul_left : IsOpen t → IsOpen (s * t) 
goal: IsOpen t → IsOpen (s + t)

full_name: IsOpen.mul_left
code: @[to_additive]
theorem IsOpen.mul_left : IsOpen t → IsOpen (s * t) 
goal: IsOpen t → IsOpen (s * t)

full_name: subset_interior_add_right
code: @[to_additive]
theorem subset_interior_mul_right : s * interior t ⊆ interior (s * t) 
goal: s + interior t ⊆ interior (s + t)

full_name: subset_interior_mul_right
code: @[to_additive]
theorem subset_interior_mul_right : s * interior t ⊆ interior (s * t) 
goal: s * interior t ⊆ interior (s * t)

full_name: subset_interior_add
code: @[to_additive]
theorem subset_interior_mul : interior s * interior t ⊆ interior (s * t) 
goal: interior s + interior t ⊆ interior (s + t)

full_name: subset_interior_mul
code: @[to_additive]
theorem subset_interior_mul : interior s * interior t ⊆ interior (s * t) 
goal: interior s * interior t ⊆ interior (s * t)

full_name: singleton_mul_mem_nhds
code: @[to_additive]
theorem singleton_mul_mem_nhds (a : α) {b : α} (h : s ∈ 𝓝 b) : {a} * s ∈ 𝓝 (a * b) 
goal: {a} * s ∈ 𝓝 (a * b)

full_name: singleton_add_mem_nhds
code: @[to_additive]
theorem singleton_mul_mem_nhds (a : α) {b : α} (h : s ∈ 𝓝 b) : {a} * s ∈ 𝓝 (a * b) 
goal: {a} + s ∈ 𝓝 (a + b)

full_name: singleton_mul_mem_nhds_of_nhds_one
code: @[to_additive]
theorem singleton_mul_mem_nhds_of_nhds_one (a : α) (h : s ∈ 𝓝 (1 : α)) : {a} * s ∈ 𝓝 a 
goal: {a} * s ∈ 𝓝 a

full_name: singleton_add_mem_nhds_of_nhds_zero
code: @[to_additive]
theorem singleton_mul_mem_nhds_of_nhds_one (a : α) (h : s ∈ 𝓝 (1 : α)) : {a} * s ∈ 𝓝 a 
goal: {a} + s ∈ 𝓝 a

full_name: IsOpen.add_right
code: @[to_additive]
theorem IsOpen.mul_right (hs : IsOpen s) : IsOpen (s * t) 
goal: IsOpen (s + t)

full_name: IsOpen.mul_right
code: @[to_additive]
theorem IsOpen.mul_right (hs : IsOpen s) : IsOpen (s * t) 
goal: IsOpen (s * t)

full_name: subset_interior_add_left
code: @[to_additive]
theorem subset_interior_mul_left : interior s * t ⊆ interior (s * t) 
goal: interior s + t ⊆ interior (s + t)

full_name: subset_interior_mul_left
code: @[to_additive]
theorem subset_interior_mul_left : interior s * t ⊆ interior (s * t) 
goal: interior s * t ⊆ interior (s * t)

full_name: subset_interior_add'
code: @[to_additive]
theorem subset_interior_mul' : interior s * interior t ⊆ interior (s * t) 
goal: interior s + interior t ⊆ interior (s + t)

full_name: subset_interior_mul'
code: @[to_additive]
theorem subset_interior_mul' : interior s * interior t ⊆ interior (s * t) 
goal: interior s * interior t ⊆ interior (s * t)

full_name: mul_singleton_mem_nhds
code: @[to_additive]
theorem mul_singleton_mem_nhds (a : α) {b : α} (h : s ∈ 𝓝 b) : s * {a} ∈ 𝓝 (b * a) 
goal: s * {a} ∈ 𝓝 (b * a)

full_name: add_singleton_mem_nhds
code: @[to_additive]
theorem mul_singleton_mem_nhds (a : α) {b : α} (h : s ∈ 𝓝 b) : s * {a} ∈ 𝓝 (b * a) 
goal: s + {a} ∈ 𝓝 (b + a)

full_name: add_singleton_mem_nhds_of_nhds_zero
code: @[to_additive]
theorem mul_singleton_mem_nhds_of_nhds_one (a : α) (h : s ∈ 𝓝 (1 : α)) : s * {a} ∈ 𝓝 a 
goal: s + {a} ∈ 𝓝 a

full_name: mul_singleton_mem_nhds_of_nhds_one
code: @[to_additive]
theorem mul_singleton_mem_nhds_of_nhds_one (a : α) (h : s ∈ 𝓝 (1 : α)) : s * {a} ∈ 𝓝 a 
goal: s * {a} ∈ 𝓝 a

full_name: IsOpen.sub_left
code: @[to_additive]
theorem IsOpen.div_left (ht : IsOpen t) : IsOpen (s / t) 
goal: IsOpen (s - t)

full_name: IsOpen.div_left
code: @[to_additive]
theorem IsOpen.div_left (ht : IsOpen t) : IsOpen (s / t) 
goal: IsOpen (s / t)

full_name: IsOpen.sub_right
code: @[to_additive]
theorem IsOpen.div_right (hs : IsOpen s) : IsOpen (s / t) 
goal: IsOpen (s - t)

full_name: IsOpen.div_right
code: @[to_additive]
theorem IsOpen.div_right (hs : IsOpen s) : IsOpen (s / t) 
goal: IsOpen (s / t)

full_name: subset_interior_sub_left
code: @[to_additive]
theorem subset_interior_div_left : interior s / t ⊆ interior (s / t) 
goal: interior s - t ⊆ interior (s - t)

full_name: subset_interior_div_left
code: @[to_additive]
theorem subset_interior_div_left : interior s / t ⊆ interior (s / t) 
goal: interior s / t ⊆ interior (s / t)

full_name: subset_interior_sub_right
code: @[to_additive]
theorem subset_interior_div_right : s / interior t ⊆ interior (s / t) 
goal: s - interior t ⊆ interior (s - t)

full_name: subset_interior_div_right
code: @[to_additive]
theorem subset_interior_div_right : s / interior t ⊆ interior (s / t) 
goal: s / interior t ⊆ interior (s / t)

full_name: subset_interior_sub
code: @[to_additive]
theorem subset_interior_div : interior s / interior t ⊆ interior (s / t) 
goal: interior s - interior t ⊆ interior (s - t)

full_name: subset_interior_div
code: @[to_additive]
theorem subset_interior_div : interior s / interior t ⊆ interior (s / t) 
goal: interior s / interior t ⊆ interior (s / t)

full_name: IsOpen.mul_closure
code: @[to_additive]
theorem IsOpen.mul_closure (hs : IsOpen s) (t : Set G) : s * closure t = s * t 
goal: s * closure t = s * t

full_name: IsOpen.add_closure
code: @[to_additive]
theorem IsOpen.mul_closure (hs : IsOpen s) (t : Set G) : s * closure t = s * t 
goal: s + closure t = s + t

full_name: IsOpen.closure_add
code: @[to_additive]
theorem IsOpen.closure_mul (ht : IsOpen t) (s : Set G) : closure s * t = s * t 
goal: closure s + t = s + t

full_name: IsOpen.closure_mul
code: @[to_additive]
theorem IsOpen.closure_mul (ht : IsOpen t) (s : Set G) : closure s * t = s * t 
goal: closure s * t = s * t

full_name: IsOpen.div_closure
code: @[to_additive]
theorem IsOpen.div_closure (hs : IsOpen s) (t : Set G) : s / closure t = s / t 
goal: s / closure t = s / t

full_name: IsOpen.sub_closure
code: @[to_additive]
theorem IsOpen.div_closure (hs : IsOpen s) (t : Set G) : s / closure t = s / t 
goal: s - closure t = s - t

full_name: IsOpen.closure_div
code: @[to_additive]
theorem IsOpen.closure_div (ht : IsOpen t) (s : Set G) : closure s / t = s / t 
goal: closure s / t = s / t

full_name: IsOpen.closure_sub
code: @[to_additive]
theorem IsOpen.closure_div (ht : IsOpen t) (s : Set G) : closure s / t = s / t 
goal: closure s - t = s - t

full_name: IsClosed.add_left_of_isCompact
code: @[to_additive]
theorem IsClosed.mul_left_of_isCompact (ht : IsClosed t) (hs : IsCompact s) : IsClosed (s * t) 
goal: IsClosed (s + t)

full_name: IsClosed.mul_left_of_isCompact
code: @[to_additive]
theorem IsClosed.mul_left_of_isCompact (ht : IsClosed t) (hs : IsCompact s) : IsClosed (s * t) 
goal: IsClosed (s * t)

full_name: IsClosed.add_right_of_isCompact
code: @[to_additive]
theorem IsClosed.mul_right_of_isCompact (ht : IsClosed t) (hs : IsCompact s) :
    IsClosed (t * s) 
goal: IsClosed (t + s)

full_name: IsClosed.mul_right_of_isCompact
code: @[to_additive]
theorem IsClosed.mul_right_of_isCompact (ht : IsClosed t) (hs : IsCompact s) :
    IsClosed (t * s) 
goal: IsClosed (t * s)

full_name: QuotientGroup.isClosedMap_coe
code: @[to_additive]
theorem QuotientGroup.isClosedMap_coe {H : Subgroup G} (hH : IsCompact (H : Set G)) :
    IsClosedMap ((↑) : G → G ⧸ H) 
goal: IsClosedMap QuotientGroup.mk

full_name: QuotientAddGroup.isClosedMap_coe
code: @[to_additive]
theorem QuotientGroup.isClosedMap_coe {H : Subgroup G} (hH : IsCompact (H : Set G)) :
    IsClosedMap ((↑) : G → G ⧸ H) 
goal: IsClosedMap QuotientAddGroup.mk

full_name: subset_add_closure_zero
code: @[to_additive]
lemma subset_mul_closure_one (s : Set G) : s ⊆ s * (closure {1} : Set G) 
goal: s ⊆ s + closure {0}

full_name: subset_mul_closure_one
code: @[to_additive]
lemma subset_mul_closure_one (s : Set G) : s ⊆ s * (closure {1} : Set G) 
goal: s ⊆ s * closure {1}

full_name: IsCompact.mul_closure_one_eq_closure
code: @[to_additive]
lemma IsCompact.mul_closure_one_eq_closure {K : Set G} (hK : IsCompact K) :
    K * (closure {1} : Set G) = closure K 
goal: K * closure {1} = closure K

full_name: IsCompact.add_closure_zero_eq_closure
code: @[to_additive]
lemma IsCompact.mul_closure_one_eq_closure {K : Set G} (hK : IsCompact K) :
    K * (closure {1} : Set G) = closure K 
goal: K + closure {0} = closure K

full_name: IsClosed.mul_closure_one_eq
code: @[to_additive]
lemma IsClosed.mul_closure_one_eq {F : Set G} (hF : IsClosed F) :
    F * (closure {1} : Set G) = F 
goal: F * closure {1} = F

full_name: IsClosed.add_closure_zero_eq
code: @[to_additive]
lemma IsClosed.mul_closure_one_eq {F : Set G} (hF : IsClosed F) :
    F * (closure {1} : Set G) = F 
goal: F + closure {0} = F

full_name: compl_mul_closure_one_eq
code: @[to_additive]
lemma compl_mul_closure_one_eq {t : Set G} (ht : t * (closure {1} : Set G) = t) :
    tᶜ * (closure {1} : Set G) = tᶜ 
goal: tᶜ * closure {1} = tᶜ

full_name: compl_add_closure_zero_eq
code: @[to_additive]
lemma compl_mul_closure_one_eq {t : Set G} (ht : t * (closure {1} : Set G) = t) :
    tᶜ * (closure {1} : Set G) = tᶜ 
goal: tᶜ + closure {0} = tᶜ

full_name: compl_add_closure_zero_eq_iff
code: @[to_additive]
lemma compl_mul_closure_one_eq_iff {t : Set G} :
    tᶜ * (closure {1} : Set G) = tᶜ ↔ t * (closure {1} : Set G) = t 
goal: tᶜ + closure {0} = tᶜ ↔ t + closure {0} = t

full_name: compl_mul_closure_one_eq_iff
code: @[to_additive]
lemma compl_mul_closure_one_eq_iff {t : Set G} :
    tᶜ * (closure {1} : Set G) = tᶜ ↔ t * (closure {1} : Set G) = t 
goal: tᶜ * closure {1} = tᶜ ↔ t * closure {1} = t

full_name: IsOpen.mul_closure_one_eq
code: @[to_additive]
lemma IsOpen.mul_closure_one_eq {U : Set G} (hU : IsOpen U) :
    U * (closure {1} : Set G) = U 
goal: U * closure {1} = U

full_name: IsOpen.add_closure_zero_eq
code: @[to_additive]
lemma IsOpen.mul_closure_one_eq {U : Set G} (hU : IsOpen U) :
    U * (closure {1} : Set G) = U 
goal: U + closure {0} = U

full_name: TopologicalAddGroup.t1Space
code: @[to_additive]
theorem TopologicalGroup.t1Space (h : @IsClosed G _ {1}) : T1Space G 
goal: T1Space G

full_name: TopologicalGroup.t1Space
code: @[to_additive]
theorem TopologicalGroup.t1Space (h : @IsClosed G _ {1}) : T1Space G 
goal: T1Space G

full_name: TopologicalGroup.regularSpace
code: @[to_additive]
instance (priority := 100) TopologicalGroup.regularSpace : RegularSpace G 
goal: RegularSpace G

full_name: TopologicalAddGroup.regularSpace
code: @[to_additive]
instance (priority := 100) TopologicalGroup.regularSpace : RegularSpace G 
goal: RegularSpace G

full_name: addGroup_inseparable_iff
code: @[to_additive]
theorem group_inseparable_iff {x y : G} : Inseparable x y ↔ x / y ∈ closure (1 : Set G) 
goal: Inseparable x y ↔ x - y ∈ closure 0

full_name: group_inseparable_iff
code: @[to_additive]
theorem group_inseparable_iff {x y : G} : Inseparable x y ↔ x / y ∈ closure (1 : Set G) 
goal: Inseparable x y ↔ x / y ∈ closure 1

full_name: TopologicalGroup.t2Space_iff_one_closed
code: @[to_additive]
theorem TopologicalGroup.t2Space_iff_one_closed : T2Space G ↔ IsClosed ({1} : Set G) 
goal: T2Space G ↔ IsClosed {1}

full_name: TopologicalAddGroup.t2Space_iff_zero_closed
code: @[to_additive]
theorem TopologicalGroup.t2Space_iff_one_closed : T2Space G ↔ IsClosed ({1} : Set G) 
goal: T2Space G ↔ IsClosed {0}

full_name: TopologicalGroup.t2Space_of_one_sep
code: @[to_additive]
theorem TopologicalGroup.t2Space_of_one_sep (H : ∀ x : G, x ≠ 1 → ∃ U ∈ 𝓝 (1 : G), x ∉ U) :
    T2Space G 
goal: T2Space G

full_name: TopologicalAddGroup.t2Space_of_zero_sep
code: @[to_additive]
theorem TopologicalGroup.t2Space_of_one_sep (H : ∀ x : G, x ≠ 1 → ∃ U ∈ 𝓝 (1 : G), x ∉ U) :
    T2Space G 
goal: T2Space G

full_name: exists_closed_nhds_one_inv_eq_mul_subset
code: /-- Given a neighborhood `U` of the identity, one may find a neighborhood `V` of the identity which
is closed, symmetric, and satisfies `V * V ⊆ U`. -/
@[to_additive "Given a neighborhood `U` of the identity, one may find a neighborhood `V` of the
identity which is closed, symmetric, and satisfies `V + V ⊆ U`."]
theorem exists_closed_nhds_one_inv_eq_mul_subset {U : Set G} (hU : U ∈ 𝓝 1) :
    ∃ V ∈ 𝓝 1, IsClosed V ∧ V⁻¹ = V ∧ V * V ⊆ U 
goal: ∃ V ∈ 𝓝 1, IsClosed V ∧ V⁻¹ = V ∧ V * V ⊆ U

full_name: exists_closed_nhds_zero_neg_eq_add_subset
code: /-- Given a neighborhood `U` of the identity, one may find a neighborhood `V` of the identity which
is closed, symmetric, and satisfies `V * V ⊆ U`. -/
@[to_additive "Given a neighborhood `U` of the identity, one may find a neighborhood `V` of the
identity which is closed, symmetric, and satisfies `V + V ⊆ U`."]
theorem exists_closed_nhds_one_inv_eq_mul_subset {U : Set G} (hU : U ∈ 𝓝 1) :
    ∃ V ∈ 𝓝 1, IsClosed V ∧ V⁻¹ = V ∧ V * V ⊆ U 
goal: ∃ V ∈ 𝓝 0, IsClosed V ∧ -V = V ∧ V + V ⊆ U

full_name: AddSubgroup.t3_quotient_of_isClosed
code: @[to_additive]
instance Subgroup.t3_quotient_of_isClosed (S : Subgroup G) [Subgroup.Normal S]
    [hS : IsClosed (S : Set G)] : T3Space (G ⧸ S) 
goal: T3Space (G ⧸ S)

full_name: Subgroup.t3_quotient_of_isClosed
code: @[to_additive]
instance Subgroup.t3_quotient_of_isClosed (S : Subgroup G) [Subgroup.Normal S]
    [hS : IsClosed (S : Set G)] : T3Space (G ⧸ S) 
goal: T3Space (G ⧸ S)

full_name: Subgroup.properlyDiscontinuousSMul_of_tendsto_cofinite
code: /-- A subgroup `S` of a topological group `G` acts on `G` properly discontinuously on the left, if
it is discrete in the sense that `S ∩ K` is finite for all compact `K`. (See also
`DiscreteTopology`.) -/
@[to_additive
  "A subgroup `S` of an additive topological group `G` acts on `G` properly
  discontinuously on the left, if it is discrete in the sense that `S ∩ K` is finite for all compact
  `K`. (See also `DiscreteTopology`."]
theorem Subgroup.properlyDiscontinuousSMul_of_tendsto_cofinite (S : Subgroup G)
    (hS : Tendsto S.subtype cofinite (cocompact G)) : ProperlyDiscontinuousSMul S G 
goal: ProperlyDiscontinuousSMul (↥S) G

full_name: AddSubgroup.properlyDiscontinuousVAdd_of_tendsto_cofinite
code: /-- A subgroup `S` of a topological group `G` acts on `G` properly discontinuously on the left, if
it is discrete in the sense that `S ∩ K` is finite for all compact `K`. (See also
`DiscreteTopology`.) -/
@[to_additive
  "A subgroup `S` of an additive topological group `G` acts on `G` properly
  discontinuously on the left, if it is discrete in the sense that `S ∩ K` is finite for all compact
  `K`. (See also `DiscreteTopology`."]
theorem Subgroup.properlyDiscontinuousSMul_of_tendsto_cofinite (S : Subgroup G)
    (hS : Tendsto S.subtype cofinite (cocompact G)) : ProperlyDiscontinuousSMul S G 
goal: ProperlyDiscontinuousVAdd (↥S) G

full_name: Subgroup.properlyDiscontinuousSMul_opposite_of_tendsto_cofinite
code: /-- A subgroup `S` of a topological group `G` acts on `G` properly discontinuously on the right, if
it is discrete in the sense that `S ∩ K` is finite for all compact `K`. (See also
`DiscreteTopology`.)

If `G` is Hausdorff, this can be combined with `t2Space_of_properlyDiscontinuousSMul_of_t2Space`
to show that the quotient group `G ⧸ S` is Hausdorff. -/
@[to_additive
  "A subgroup `S` of an additive topological group `G` acts on `G` properly discontinuously
  on the right, if it is discrete in the sense that `S ∩ K` is finite for all compact `K`.
  (See also `DiscreteTopology`.)

  If `G` is Hausdorff, this can be combined with `t2Space_of_properlyDiscontinuousVAdd_of_t2Space`
  to show that the quotient group `G ⧸ S` is Hausdorff."]
theorem Subgroup.properlyDiscontinuousSMul_opposite_of_tendsto_cofinite (S : Subgroup G)
    (hS : Tendsto S.subtype cofinite (cocompact G)) : ProperlyDiscontinuousSMul S.op G 
goal: ProperlyDiscontinuousSMul (↥S.op) G

full_name: AddSubgroup.properlyDiscontinuousVAdd_opposite_of_tendsto_cofinite
code: /-- A subgroup `S` of a topological group `G` acts on `G` properly discontinuously on the right, if
it is discrete in the sense that `S ∩ K` is finite for all compact `K`. (See also
`DiscreteTopology`.)

If `G` is Hausdorff, this can be combined with `t2Space_of_properlyDiscontinuousSMul_of_t2Space`
to show that the quotient group `G ⧸ S` is Hausdorff. -/
@[to_additive
  "A subgroup `S` of an additive topological group `G` acts on `G` properly discontinuously
  on the right, if it is discrete in the sense that `S ∩ K` is finite for all compact `K`.
  (See also `DiscreteTopology`.)

  If `G` is Hausdorff, this can be combined with `t2Space_of_properlyDiscontinuousVAdd_of_t2Space`
  to show that the quotient group `G ⧸ S` is Hausdorff."]
theorem Subgroup.properlyDiscontinuousSMul_opposite_of_tendsto_cofinite (S : Subgroup G)
    (hS : Tendsto S.subtype cofinite (cocompact G)) : ProperlyDiscontinuousSMul S.op G 
goal: ProperlyDiscontinuousVAdd (↥S.op) G

full_name: compact_open_separated_add_right
code: /-- Given a compact set `K` inside an open set `U`, there is an open neighborhood `V` of `1`
  such that `K * V ⊆ U`. -/
@[to_additive
  "Given a compact set `K` inside an open set `U`, there is an open neighborhood `V` of
  `0` such that `K + V ⊆ U`."]
theorem compact_open_separated_mul_right {K U : Set G} (hK : IsCompact K) (hU : IsOpen U)
    (hKU : K ⊆ U) : ∃ V ∈ 𝓝 (1 : G), K * V ⊆ U 
goal: ∃ V ∈ 𝓝 0, K + V ⊆ U

full_name: compact_open_separated_mul_right
code: /-- Given a compact set `K` inside an open set `U`, there is an open neighborhood `V` of `1`
  such that `K * V ⊆ U`. -/
@[to_additive
  "Given a compact set `K` inside an open set `U`, there is an open neighborhood `V` of
  `0` such that `K + V ⊆ U`."]
theorem compact_open_separated_mul_right {K U : Set G} (hK : IsCompact K) (hU : IsOpen U)
    (hKU : K ⊆ U) : ∃ V ∈ 𝓝 (1 : G), K * V ⊆ U 
goal: ∃ V ∈ 𝓝 1, K * V ⊆ U

full_name: compact_open_separated_add_left
code: /-- Given a compact set `K` inside an open set `U`, there is an open neighborhood `V` of `1`
  such that `V * K ⊆ U`. -/
@[to_additive
  "Given a compact set `K` inside an open set `U`, there is an open neighborhood `V` of
  `0` such that `V + K ⊆ U`."]
theorem compact_open_separated_mul_left {K U : Set G} (hK : IsCompact K) (hU : IsOpen U)
    (hKU : K ⊆ U) : ∃ V ∈ 𝓝 (1 : G), V * K ⊆ U 
goal: ∃ V ∈ 𝓝 0, V + K ⊆ U

full_name: compact_open_separated_mul_left
code: /-- Given a compact set `K` inside an open set `U`, there is an open neighborhood `V` of `1`
  such that `V * K ⊆ U`. -/
@[to_additive
  "Given a compact set `K` inside an open set `U`, there is an open neighborhood `V` of
  `0` such that `V + K ⊆ U`."]
theorem compact_open_separated_mul_left {K U : Set G} (hK : IsCompact K) (hU : IsOpen U)
    (hKU : K ⊆ U) : ∃ V ∈ 𝓝 (1 : G), V * K ⊆ U 
goal: ∃ V ∈ 𝓝 1, V * K ⊆ U

full_name: compact_covered_by_add_left_translates
code: /-- A compact set is covered by finitely many left multiplicative translates of a set
  with non-empty interior. -/
@[to_additive
  "A compact set is covered by finitely many left additive translates of a set
    with non-empty interior."]
theorem compact_covered_by_mul_left_translates {K V : Set G} (hK : IsCompact K)
    (hV : (interior V).Nonempty) : ∃ t : Finset G, K ⊆ ⋃ g ∈ t, (g * ·) ⁻¹' V 
goal: ∃ t, K ⊆ ⋃ g ∈ t, (fun x => g + x) ⁻¹' V

full_name: compact_covered_by_mul_left_translates
code: /-- A compact set is covered by finitely many left multiplicative translates of a set
  with non-empty interior. -/
@[to_additive
  "A compact set is covered by finitely many left additive translates of a set
    with non-empty interior."]
theorem compact_covered_by_mul_left_translates {K V : Set G} (hK : IsCompact K)
    (hV : (interior V).Nonempty) : ∃ t : Finset G, K ⊆ ⋃ g ∈ t, (g * ·) ⁻¹' V 
goal: ∃ t, K ⊆ ⋃ g ∈ t, (fun x => g * x) ⁻¹' V

full_name: SeparableWeaklyLocallyCompactGroup.sigmaCompactSpace
code: /-- Every weakly locally compact separable topological group is σ-compact.
  Note: this is not true if we drop the topological group hypothesis. -/
@[to_additive SeparableWeaklyLocallyCompactAddGroup.sigmaCompactSpace
  "Every weakly locally compact separable topological additive group is σ-compact.
  Note: this is not true if we drop the topological group hypothesis."]
instance (priority := 100) SeparableWeaklyLocallyCompactGroup.sigmaCompactSpace [SeparableSpace G]
    [WeaklyLocallyCompactSpace G] : SigmaCompactSpace G 
goal: SigmaCompactSpace G

full_name: SeparableWeaklyLocallyCompactAddGroup.sigmaCompactSpace
code: /-- Every weakly locally compact separable topological group is σ-compact.
  Note: this is not true if we drop the topological group hypothesis. -/
@[to_additive SeparableWeaklyLocallyCompactAddGroup.sigmaCompactSpace
  "Every weakly locally compact separable topological additive group is σ-compact.
  Note: this is not true if we drop the topological group hypothesis."]
instance (priority := 100) SeparableWeaklyLocallyCompactGroup.sigmaCompactSpace [SeparableSpace G]
    [WeaklyLocallyCompactSpace G] : SigmaCompactSpace G 
goal: SigmaCompactSpace G

full_name: exists_disjoint_vadd_of_isCompact
code: /-- Given two compact sets in a noncompact topological group, there is a translate of the second
one that is disjoint from the first one. -/
@[to_additive
  "Given two compact sets in a noncompact additive topological group, there is a
  translate of the second one that is disjoint from the first one."]
theorem exists_disjoint_smul_of_isCompact [NoncompactSpace G] {K L : Set G} (hK : IsCompact K)
    (hL : IsCompact L) : ∃ g : G, Disjoint K (g • L) 
goal: ∃ g, Disjoint K (g +ᵥ L)

full_name: exists_disjoint_smul_of_isCompact
code: /-- Given two compact sets in a noncompact topological group, there is a translate of the second
one that is disjoint from the first one. -/
@[to_additive
  "Given two compact sets in a noncompact additive topological group, there is a
  translate of the second one that is disjoint from the first one."]
theorem exists_disjoint_smul_of_isCompact [NoncompactSpace G] {K L : Set G} (hK : IsCompact K)
    (hL : IsCompact L) : ∃ g : G, Disjoint K (g • L) 
goal: ∃ g, Disjoint K (g • L)

full_name: exists_isCompact_isClosed_subset_isCompact_nhds_one
code: /-- A compact neighborhood of `1` in a topological group admits a closed compact subset
that is a neighborhood of `1`. -/
@[to_additive (attr := deprecated IsCompact.isCompact_isClosed_basis_nhds (since := "2024-01-28"))
  "A compact neighborhood of `0` in a topological additive group
admits a closed compact subset that is a neighborhood of `0`."]
theorem exists_isCompact_isClosed_subset_isCompact_nhds_one
    {L : Set G} (Lcomp : IsCompact L) (L1 : L ∈ 𝓝 (1 : G)) :
    ∃ K : Set G, IsCompact K ∧ IsClosed K ∧ K ⊆ L ∧ K ∈ 𝓝 (1 : G) 
goal: ∃ K, IsCompact K ∧ IsClosed K ∧ K ⊆ L ∧ K ∈ 𝓝 1

full_name: exists_isCompact_isClosed_subset_isCompact_nhds_zero
code: /-- A compact neighborhood of `1` in a topological group admits a closed compact subset
that is a neighborhood of `1`. -/
@[to_additive (attr := deprecated IsCompact.isCompact_isClosed_basis_nhds (since := "2024-01-28"))
  "A compact neighborhood of `0` in a topological additive group
admits a closed compact subset that is a neighborhood of `0`."]
theorem exists_isCompact_isClosed_subset_isCompact_nhds_one
    {L : Set G} (Lcomp : IsCompact L) (L1 : L ∈ 𝓝 (1 : G)) :
    ∃ K : Set G, IsCompact K ∧ IsClosed K ∧ K ⊆ L ∧ K ∈ 𝓝 (1 : G) 
goal: ∃ K, IsCompact K ∧ IsClosed K ∧ K ⊆ L ∧ K ∈ 𝓝 0

full_name: IsCompact.locallyCompactSpace_of_mem_nhds_of_addGroup
code: /-- If a point in a topological group has a compact neighborhood, then the group is
locally compact. -/
@[to_additive]
theorem IsCompact.locallyCompactSpace_of_mem_nhds_of_group {K : Set G} (hK : IsCompact K) {x : G}
    (h : K ∈ 𝓝 x) : LocallyCompactSpace G 
goal: LocallyCompactSpace G

full_name: IsCompact.locallyCompactSpace_of_mem_nhds_of_group
code: /-- If a point in a topological group has a compact neighborhood, then the group is
locally compact. -/
@[to_additive]
theorem IsCompact.locallyCompactSpace_of_mem_nhds_of_group {K : Set G} (hK : IsCompact K) {x : G}
    (h : K ∈ 𝓝 x) : LocallyCompactSpace G 
goal: LocallyCompactSpace G

full_name: instLocallyCompactSpaceOfWeaklyOfAddGroup
code: /-- A topological group which is weakly locally compact is automatically locally compact. -/
@[to_additive
  (attr := deprecated WeaklyLocallyCompactSpace.locallyCompactSpace (since := "2024-01-28"))]
theorem instLocallyCompactSpaceOfWeaklyOfGroup [WeaklyLocallyCompactSpace G] :
    LocallyCompactSpace G 
goal: LocallyCompactSpace G

full_name: instLocallyCompactSpaceOfWeaklyOfGroup
code: /-- A topological group which is weakly locally compact is automatically locally compact. -/
@[to_additive
  (attr := deprecated WeaklyLocallyCompactSpace.locallyCompactSpace (since := "2024-01-28"))]
theorem instLocallyCompactSpaceOfWeaklyOfGroup [WeaklyLocallyCompactSpace G] :
    LocallyCompactSpace G 
goal: LocallyCompactSpace G

full_name: eq_zero_or_locallyCompactSpace_of_support_subset_isCompact_of_group
code: /-- If a function defined on a topological group has a support contained in a
compact set, then either the function is trivial or the group is locally compact. -/
@[to_additive
      "If a function defined on a topological additive group has a support contained in a compact
      set, then either the function is trivial or the group is locally compact."]
theorem eq_zero_or_locallyCompactSpace_of_support_subset_isCompact_of_group
    [TopologicalSpace α] [Zero α] [T1Space α]
    {f : G → α} {k : Set G} (hk : IsCompact k) (hf : support f ⊆ k) (h'f : Continuous f) :
    f = 0 ∨ LocallyCompactSpace G 
goal: f = 0 ∨ LocallyCompactSpace G

full_name: eq_zero_or_locallyCompactSpace_of_support_subset_isCompact_of_addGroup
code: /-- If a function defined on a topological group has a support contained in a
compact set, then either the function is trivial or the group is locally compact. -/
@[to_additive
      "If a function defined on a topological additive group has a support contained in a compact
      set, then either the function is trivial or the group is locally compact."]
theorem eq_zero_or_locallyCompactSpace_of_support_subset_isCompact_of_group
    [TopologicalSpace α] [Zero α] [T1Space α]
    {f : G → α} {k : Set G} (hk : IsCompact k) (hf : support f ⊆ k) (h'f : Continuous f) :
    f = 0 ∨ LocallyCompactSpace G 
goal: f = 0 ∨ LocallyCompactSpace G

full_name: HasCompactSupport.eq_zero_or_locallyCompactSpace_of_group
code: /-- If a function defined on a topological group has compact support, then either
the function is trivial or the group is locally compact. -/
@[to_additive
      "If a function defined on a topological additive group has compact support,
      then either the function is trivial or the group is locally compact."]
theorem HasCompactSupport.eq_zero_or_locallyCompactSpace_of_group
    [TopologicalSpace α] [Zero α] [T1Space α]
    {f : G → α} (hf : HasCompactSupport f) (h'f : Continuous f) :
    f = 0 ∨ LocallyCompactSpace G 
goal: f = 0 ∨ LocallyCompactSpace G

full_name: HasCompactSupport.eq_zero_or_locallyCompactSpace_of_addGroup
code: /-- If a function defined on a topological group has compact support, then either
the function is trivial or the group is locally compact. -/
@[to_additive
      "If a function defined on a topological additive group has compact support,
      then either the function is trivial or the group is locally compact."]
theorem HasCompactSupport.eq_zero_or_locallyCompactSpace_of_group
    [TopologicalSpace α] [Zero α] [T1Space α]
    {f : G → α} (hf : HasCompactSupport f) (h'f : Continuous f) :
    f = 0 ∨ LocallyCompactSpace G 
goal: f = 0 ∨ LocallyCompactSpace G

full_name: local_isCompact_isClosed_nhds_of_addGroup
code: /-- In a locally compact group, any neighborhood of the identity contains a compact closed
neighborhood of the identity, even without separation assumptions on the space. -/
@[to_additive (attr := deprecated isCompact_isClosed_basis_nhds (since := "2024-01-28"))
  "In a locally compact additive group, any neighborhood of the identity contains a
  compact closed neighborhood of the identity, even without separation assumptions on the space."]
theorem local_isCompact_isClosed_nhds_of_group [LocallyCompactSpace G] {U : Set G}
    (hU : U ∈ 𝓝 (1 : G)) :
    ∃ K : Set G, IsCompact K ∧ IsClosed K ∧ K ⊆ U ∧ (1 : G) ∈ interior K 
goal: ∃ K, IsCompact K ∧ IsClosed K ∧ K ⊆ U ∧ 0 ∈ interior K

full_name: local_isCompact_isClosed_nhds_of_group
code: /-- In a locally compact group, any neighborhood of the identity contains a compact closed
neighborhood of the identity, even without separation assumptions on the space. -/
@[to_additive (attr := deprecated isCompact_isClosed_basis_nhds (since := "2024-01-28"))
  "In a locally compact additive group, any neighborhood of the identity contains a
  compact closed neighborhood of the identity, even without separation assumptions on the space."]
theorem local_isCompact_isClosed_nhds_of_group [LocallyCompactSpace G] {U : Set G}
    (hU : U ∈ 𝓝 (1 : G)) :
    ∃ K : Set G, IsCompact K ∧ IsClosed K ∧ K ⊆ U ∧ (1 : G) ∈ interior K 
goal: ∃ K, IsCompact K ∧ IsClosed K ∧ K ⊆ U ∧ 1 ∈ interior K

full_name: exists_isCompact_isClosed_nhds_zero
code: @[to_additive (attr := deprecated exists_mem_nhds_isCompact_isClosed (since := "2024-01-28"))]
theorem exists_isCompact_isClosed_nhds_one [WeaklyLocallyCompactSpace G] :
    ∃ K : Set G, IsCompact K ∧ IsClosed K ∧ K ∈ 𝓝 1 
goal: ∃ K, IsCompact K ∧ IsClosed K ∧ K ∈ 𝓝 0

full_name: exists_isCompact_isClosed_nhds_one
code: @[to_additive (attr := deprecated exists_mem_nhds_isCompact_isClosed (since := "2024-01-28"))]
theorem exists_isCompact_isClosed_nhds_one [WeaklyLocallyCompactSpace G] :
    ∃ K : Set G, IsCompact K ∧ IsClosed K ∧ K ∈ 𝓝 1 
goal: ∃ K, IsCompact K ∧ IsClosed K ∧ K ∈ 𝓝 1

full_name: instLocallyCompactSpaceQuotientSubgroup
code: /-- A quotient of a locally compact group is locally compact. -/
@[to_additive]
instance [LocallyCompactSpace G] (N : Subgroup G) : LocallyCompactSpace (G ⧸ N) 
goal: LocallyCompactSpace (G ⧸ N)

full_name: instLocallyCompactSpaceQuotientAddSubgroup
code: /-- A quotient of a locally compact group is locally compact. -/
@[to_additive]
instance [LocallyCompactSpace G] (N : Subgroup G) : LocallyCompactSpace (G ⧸ N) 
goal: LocallyCompactSpace (G ⧸ N)

full_name: nhds_add
code: @[to_additive]
theorem nhds_mul (x y : G) : 𝓝 (x * y) = 𝓝 x * 𝓝 y 
goal: 𝓝 (x + y) = 𝓝 x + 𝓝 y

full_name: nhds_mul
code: @[to_additive]
theorem nhds_mul (x y : G) : 𝓝 (x * y) = 𝓝 x * 𝓝 y 
goal: 𝓝 (x * y) = 𝓝 x * 𝓝 y

full_name: nhdsAddHom_apply
code: /-- On a topological group, `𝓝 : G → Filter G` can be promoted to a `MulHom`. -/
@[to_additive (attr := simps)
  "On an additive topological group, `𝓝 : G → Filter G` can be promoted to an `AddHom`."]
def nhdsMulHom : G →ₙ* Filter G 
goal: nhdsAddHom x = 𝓝 x

full_name: nhdsMulHom_apply
code: /-- On a topological group, `𝓝 : G → Filter G` can be promoted to a `MulHom`. -/
@[to_additive (attr := simps)
  "On an additive topological group, `𝓝 : G → Filter G` can be promoted to an `AddHom`."]
def nhdsMulHom : G →ₙ* Filter G 
goal: nhdsMulHom x = 𝓝 x

full_name: nhdsAddHom
code: /-- On a topological group, `𝓝 : G → Filter G` can be promoted to a `MulHom`. -/
@[to_additive (attr := simps)
  "On an additive topological group, `𝓝 : G → Filter G` can be promoted to an `AddHom`."]
def nhdsMulHom : G →ₙ* Filter G 
goal: AddHom G (Filter G)

full_name: nhdsMulHom
code: /-- On a topological group, `𝓝 : G → Filter G` can be promoted to a `MulHom`. -/
@[to_additive (attr := simps)
  "On an additive topological group, `𝓝 : G → Filter G` can be promoted to an `AddHom`."]
def nhdsMulHom : G →ₙ* Filter G 
goal: G →ₙ* Filter G

full_name: instTopologicalAddGroupAdditiveOfTopologicalGroup
code: instance {G} [TopologicalSpace G] [Group G] [TopologicalGroup G] :
    TopologicalAddGroup (Additive G) 
goal: TopologicalAddGroup (Additive G)

full_name: instTopologicalGroupMultiplicativeOfTopologicalAddGroup
code: instance {G} [TopologicalSpace G] [AddGroup G] [TopologicalAddGroup G] :
    TopologicalGroup (Multiplicative G) 
goal: TopologicalGroup (Multiplicative G)

full_name: QuotientGroup.continuousConstSMul
code: @[to_additive]
instance QuotientGroup.continuousConstSMul : ContinuousConstSMul G (G ⧸ Γ) 
goal: ContinuousConstSMul G (G ⧸ Γ)

full_name: QuotientAddGroup.continuousConstVAdd
code: @[to_additive]
instance QuotientGroup.continuousConstSMul : ContinuousConstSMul G (G ⧸ Γ) 
goal: ContinuousConstVAdd G (G ⧸ Γ)

full_name: QuotientAddGroup.continuous_smul₁
code: @[to_additive]
theorem QuotientGroup.continuous_smul₁ (x : G ⧸ Γ) : Continuous fun g : G => g • x 
goal: Continuous fun g => g +ᵥ x

full_name: QuotientGroup.continuous_smul₁
code: @[to_additive]
theorem QuotientGroup.continuous_smul₁ (x : G ⧸ Γ) : Continuous fun g : G => g • x 
goal: Continuous fun g => g • x

full_name: QuotientGroup.secondCountableTopology
code: /-- The quotient of a second countable topological group by a subgroup is second countable. -/
@[to_additive
  "The quotient of a second countable additive topological group by a subgroup is second
  countable."]
instance QuotientGroup.secondCountableTopology [SecondCountableTopology G] :
    SecondCountableTopology (G ⧸ Γ) 
goal: SecondCountableTopology (G ⧸ Γ)

full_name: QuotientAddGroup.secondCountableTopology
code: /-- The quotient of a second countable topological group by a subgroup is second countable. -/
@[to_additive
  "The quotient of a second countable additive topological group by a subgroup is second
  countable."]
instance QuotientGroup.secondCountableTopology [SecondCountableTopology G] :
    SecondCountableTopology (G ⧸ Γ) 
goal: SecondCountableTopology (G ⧸ Γ)

full_name: toAddUnits_homeomorph
code: /-- If `G` is a group with topological `⁻¹`, then it is homeomorphic to its units. -/
@[to_additive " If `G` is an additive group with topological negation, then it is homeomorphic to
its additive units."]
def toUnits_homeomorph [Group G] [TopologicalSpace G] [ContinuousInv G] : G ≃ₜ Gˣ 
goal: G ≃ₜ AddUnits G

full_name: toUnits_homeomorph
code: /-- If `G` is a group with topological `⁻¹`, then it is homeomorphic to its units. -/
@[to_additive " If `G` is an additive group with topological negation, then it is homeomorphic to
its additive units."]
def toUnits_homeomorph [Group G] [TopologicalSpace G] [ContinuousInv G] : G ≃ₜ Gˣ 
goal: G ≃ₜ Gˣ

full_name: Units.embedding_val
code: @[to_additive] theorem Units.embedding_val [Group G] [TopologicalSpace G] [ContinuousInv G] :
    Embedding (val : Gˣ → G) 
goal: Embedding Units.val

full_name: AddUnits.embedding_val
code: @[to_additive] theorem Units.embedding_val [Group G] [TopologicalSpace G] [ContinuousInv G] :
    Embedding (val : Gˣ → G) 
goal: Embedding AddUnits.val

full_name: Units.instTopologicalGroupOfContinuousMul
code: @[to_additive]
instance [ContinuousMul α] : TopologicalGroup αˣ 
goal: TopologicalGroup αˣ

full_name: AddUnits.instTopologicalAddGroupOfContinuousAdd
code: @[to_additive]
instance [ContinuousMul α] : TopologicalGroup αˣ 
goal: TopologicalAddGroup (AddUnits α)

full_name: Units.Homeomorph.prodUnits
code: /-- The topological group isomorphism between the units of a product of two monoids, and the product
of the units of each monoid. -/
@[to_additive
  "The topological group isomorphism between the additive units of a product of two
  additive monoids, and the product of the additive units of each additive monoid."]
def Homeomorph.prodUnits : (α × β)ˣ ≃ₜ αˣ × βˣ 
goal: (α × β)ˣ ≃ₜ αˣ × βˣ

full_name: AddUnits.Homeomorph.sumAddUnits
code: /-- The topological group isomorphism between the units of a product of two monoids, and the product
of the units of each monoid. -/
@[to_additive
  "The topological group isomorphism between the additive units of a product of two
  additive monoids, and the product of the additive units of each additive monoid."]
def Homeomorph.prodUnits : (α × β)ˣ ≃ₜ αˣ × βˣ 
goal: AddUnits (α × β) ≃ₜ AddUnits α × AddUnits β

full_name: topologicalGroup_sInf
code: @[to_additive]
theorem topologicalGroup_sInf {ts : Set (TopologicalSpace G)}
    (h : ∀ t ∈ ts, @TopologicalGroup G t _) : @TopologicalGroup G (sInf ts) _ 
goal: TopologicalGroup G

full_name: topologicalAddGroup_sInf
code: @[to_additive]
theorem topologicalGroup_sInf {ts : Set (TopologicalSpace G)}
    (h : ∀ t ∈ ts, @TopologicalGroup G t _) : @TopologicalGroup G (sInf ts) _ 
goal: TopologicalAddGroup G

full_name: topologicalGroup_iInf
code: @[to_additive]
theorem topologicalGroup_iInf {ts' : ι → TopologicalSpace G}
    (h' : ∀ i, @TopologicalGroup G (ts' i) _) : @TopologicalGroup G (⨅ i, ts' i) _ 
goal: TopologicalGroup G

full_name: topologicalAddGroup_iInf
code: @[to_additive]
theorem topologicalGroup_iInf {ts' : ι → TopologicalSpace G}
    (h' : ∀ i, @TopologicalGroup G (ts' i) _) : @TopologicalGroup G (⨅ i, ts' i) _ 
goal: TopologicalAddGroup G

full_name: topologicalAddGroup_inf
code: @[to_additive]
theorem topologicalGroup_inf {t₁ t₂ : TopologicalSpace G} (h₁ : @TopologicalGroup G t₁ _)
    (h₂ : @TopologicalGroup G t₂ _) : @TopologicalGroup G (t₁ ⊓ t₂) _ 
goal: TopologicalAddGroup G

full_name: topologicalGroup_inf
code: @[to_additive]
theorem topologicalGroup_inf {t₁ t₂ : TopologicalSpace G} (h₁ : @TopologicalGroup G t₁ _)
    (h₂ : @TopologicalGroup G t₂ _) : @TopologicalGroup G (t₁ ⊓ t₂) _ 
goal: TopologicalGroup G

full_name: GroupTopology
code: /-- A group topology on a group `α` is a topology for which multiplication and inversion
are continuous. -/
structure GroupTopology (α : Type u) [Group α] extends TopologicalSpace α, TopologicalGroup α :
  Type u
goal: Type u

full_name: AddGroupTopology
code: /-- An additive group topology on an additive group `α` is a topology for which addition and
  negation are continuous. -/
structure AddGroupTopology (α : Type u) [AddGroup α] extends TopologicalSpace α,
  TopologicalAddGroup α : Type u
goal: Type u

full_name: GroupTopology.continuous_mul'
code: /-- A version of the global `continuous_mul` suitable for dot notation. -/
@[to_additive "A version of the global `continuous_add` suitable for dot notation."]
theorem continuous_mul' (g : GroupTopology α) :
    haveI := g.toTopologicalSpace
    Continuous fun p : α × α => p.1 * p.2 
goal: Continuous fun p => p.1 * p.2

full_name: AddGroupTopology.continuous_add'
code: /-- A version of the global `continuous_mul` suitable for dot notation. -/
@[to_additive "A version of the global `continuous_add` suitable for dot notation."]
theorem continuous_mul' (g : GroupTopology α) :
    haveI := g.toTopologicalSpace
    Continuous fun p : α × α => p.1 * p.2 
goal: Continuous fun p => p.1 + p.2

full_name: AddGroupTopology.continuous_neg'
code: /-- A version of the global `continuous_inv` suitable for dot notation. -/
@[to_additive "A version of the global `continuous_neg` suitable for dot notation."]
theorem continuous_inv' (g : GroupTopology α) :
    haveI := g.toTopologicalSpace
    Continuous (Inv.inv : α → α) 
goal: Continuous Neg.neg

full_name: GroupTopology.continuous_inv'
code: /-- A version of the global `continuous_inv` suitable for dot notation. -/
@[to_additive "A version of the global `continuous_neg` suitable for dot notation."]
theorem continuous_inv' (g : GroupTopology α) :
    haveI := g.toTopologicalSpace
    Continuous (Inv.inv : α → α) 
goal: Continuous Inv.inv

full_name: GroupTopology.toTopologicalSpace_injective
code: @[to_additive]
theorem toTopologicalSpace_injective :
    Function.Injective (toTopologicalSpace : GroupTopology α → TopologicalSpace α) 
goal: Function.Injective GroupTopology.toTopologicalSpace

full_name: AddGroupTopology.toTopologicalSpace_injective
code: @[to_additive]
theorem toTopologicalSpace_injective :
    Function.Injective (toTopologicalSpace : GroupTopology α → TopologicalSpace α) 
goal: Function.Injective AddGroupTopology.toTopologicalSpace

full_name: GroupTopology.ext'
code: @[to_additive (attr := ext)]
theorem ext' {f g : GroupTopology α} (h : f.IsOpen = g.IsOpen) : f = g 
goal: f = g

full_name: AddGroupTopology.ext'
code: @[to_additive (attr := ext)]
theorem ext' {f g : GroupTopology α} (h : f.IsOpen = g.IsOpen) : f = g 
goal: f = g

full_name: AddGroupTopology.instPartialOrder
code: /-- The ordering on group topologies on the group `γ`. `t ≤ s` if every set open in `s` is also open
in `t` (`t` is finer than `s`). -/
@[to_additive
  "The ordering on group topologies on the group `γ`. `t ≤ s` if every set open in `s`
  is also open in `t` (`t` is finer than `s`)."]
instance : PartialOrder (GroupTopology α) 
goal: PartialOrder (AddGroupTopology α)

full_name: GroupTopology.instPartialOrder
code: /-- The ordering on group topologies on the group `γ`. `t ≤ s` if every set open in `s` is also open
in `t` (`t` is finer than `s`). -/
@[to_additive
  "The ordering on group topologies on the group `γ`. `t ≤ s` if every set open in `s`
  is also open in `t` (`t` is finer than `s`)."]
instance : PartialOrder (GroupTopology α) 
goal: PartialOrder (GroupTopology α)

full_name: GroupTopology.toTopologicalSpace_le
code: @[to_additive (attr := simp)]
theorem toTopologicalSpace_le {x y : GroupTopology α} :
    x.toTopologicalSpace ≤ y.toTopologicalSpace ↔ x ≤ y 
goal: x.toTopologicalSpace ≤ y.toTopologicalSpace ↔ x ≤ y

full_name: AddGroupTopology.toTopologicalSpace_le
code: @[to_additive (attr := simp)]
theorem toTopologicalSpace_le {x y : GroupTopology α} :
    x.toTopologicalSpace ≤ y.toTopologicalSpace ↔ x ≤ y 
goal: x.toTopologicalSpace ≤ y.toTopologicalSpace ↔ x ≤ y

full_name: AddGroupTopology.instTop
code: @[to_additive]
instance : Top (GroupTopology α) 
goal: Top (AddGroupTopology α)

full_name: GroupTopology.instTop
code: @[to_additive]
instance : Top (GroupTopology α) 
goal: Top (GroupTopology α)

full_name: GroupTopology.toTopologicalSpace_top
code: @[to_additive (attr := simp)]
theorem toTopologicalSpace_top : (⊤ : GroupTopology α).toTopologicalSpace = ⊤ 
goal: ⊤.toTopologicalSpace = ⊤

full_name: AddGroupTopology.toTopologicalSpace_top
code: @[to_additive (attr := simp)]
theorem toTopologicalSpace_top : (⊤ : GroupTopology α).toTopologicalSpace = ⊤ 
goal: ⊤.toTopologicalSpace = ⊤

full_name: AddGroupTopology.instBot
code: @[to_additive]
instance : Bot (GroupTopology α) 
goal: Bot (AddGroupTopology α)

full_name: GroupTopology.instBot
code: @[to_additive]
instance : Bot (GroupTopology α) 
goal: Bot (GroupTopology α)

full_name: GroupTopology.toTopologicalSpace_bot
code: @[to_additive (attr := simp)]
theorem toTopologicalSpace_bot : (⊥ : GroupTopology α).toTopologicalSpace = ⊥ 
goal: ⊥.toTopologicalSpace = ⊥

full_name: AddGroupTopology.toTopologicalSpace_bot
code: @[to_additive (attr := simp)]
theorem toTopologicalSpace_bot : (⊥ : GroupTopology α).toTopologicalSpace = ⊥ 
goal: ⊥.toTopologicalSpace = ⊥

full_name: AddGroupTopology.instBoundedOrder
code: @[to_additive]
instance : BoundedOrder (GroupTopology α) 
goal: BoundedOrder (AddGroupTopology α)

full_name: GroupTopology.instBoundedOrder
code: @[to_additive]
instance : BoundedOrder (GroupTopology α) 
goal: BoundedOrder (GroupTopology α)

full_name: AddGroupTopology.instInf
code: @[to_additive]
instance : Inf (GroupTopology α) 
goal: Inf (AddGroupTopology α)

full_name: GroupTopology.instInf
code: @[to_additive]
instance : Inf (GroupTopology α) 
goal: Inf (GroupTopology α)

full_name: AddGroupTopology.toTopologicalSpace_inf
code: @[to_additive (attr := simp)]
theorem toTopologicalSpace_inf (x y : GroupTopology α) :
    (x ⊓ y).toTopologicalSpace = x.toTopologicalSpace ⊓ y.toTopologicalSpace 
goal: (x ⊓ y).toTopologicalSpace = x.toTopologicalSpace ⊓ y.toTopologicalSpace

full_name: GroupTopology.toTopologicalSpace_inf
code: @[to_additive (attr := simp)]
theorem toTopologicalSpace_inf (x y : GroupTopology α) :
    (x ⊓ y).toTopologicalSpace = x.toTopologicalSpace ⊓ y.toTopologicalSpace 
goal: (x ⊓ y).toTopologicalSpace = x.toTopologicalSpace ⊓ y.toTopologicalSpace

full_name: GroupTopology.instSemilatticeInf
code: @[to_additive]
instance : SemilatticeInf (GroupTopology α) 
goal: SemilatticeInf (GroupTopology α)

full_name: AddGroupTopology.instSemilatticeInf
code: @[to_additive]
instance : SemilatticeInf (GroupTopology α) 
goal: SemilatticeInf (AddGroupTopology α)

full_name: GroupTopology.instInhabited
code: @[to_additive]
instance : Inhabited (GroupTopology α) 
goal: Inhabited (GroupTopology α)

full_name: AddGroupTopology.instInhabited
code: @[to_additive]
instance : Inhabited (GroupTopology α) 
goal: Inhabited (AddGroupTopology α)

full_name: GroupTopology._aux_Mathlib_Topology_Algebra_Group_Basic___macroRules_GroupTopology_termCont_1
code: local notation "cont" => @Continuous _ _
goal: Lean.Macro

full_name: GroupTopology.instInfSet
code: /-- Infimum of a collection of group topologies. -/
@[to_additive "Infimum of a collection of additive group topologies"]
instance : InfSet (GroupTopology α) 
goal: InfSet (GroupTopology α)

full_name: AddGroupTopology.instInfSet
code: /-- Infimum of a collection of group topologies. -/
@[to_additive "Infimum of a collection of additive group topologies"]
instance : InfSet (GroupTopology α) 
goal: InfSet (AddGroupTopology α)

full_name: GroupTopology.toTopologicalSpace_sInf
code: @[to_additive (attr := simp)]
theorem toTopologicalSpace_sInf (s : Set (GroupTopology α)) :
    (sInf s).toTopologicalSpace = sInf (toTopologicalSpace '' s) 
goal: (sInf s).toTopologicalSpace = sInf (GroupTopology.toTopologicalSpace '' s)

full_name: AddGroupTopology.toTopologicalSpace_sInf
code: @[to_additive (attr := simp)]
theorem toTopologicalSpace_sInf (s : Set (GroupTopology α)) :
    (sInf s).toTopologicalSpace = sInf (toTopologicalSpace '' s) 
goal: (sInf s).toTopologicalSpace = sInf (AddGroupTopology.toTopologicalSpace '' s)

full_name: AddGroupTopology.toTopologicalSpace_iInf
code: @[to_additive (attr := simp)]
theorem toTopologicalSpace_iInf {ι} (s : ι → GroupTopology α) :
    (⨅ i, s i).toTopologicalSpace = ⨅ i, (s i).toTopologicalSpace 
goal: (⨅ i, s i).toTopologicalSpace = ⨅ i, (s i).toTopologicalSpace

full_name: GroupTopology.toTopologicalSpace_iInf
code: @[to_additive (attr := simp)]
theorem toTopologicalSpace_iInf {ι} (s : ι → GroupTopology α) :
    (⨅ i, s i).toTopologicalSpace = ⨅ i, (s i).toTopologicalSpace 
goal: (⨅ i, s i).toTopologicalSpace = ⨅ i, (s i).toTopologicalSpace

full_name: GroupTopology.instCompleteSemilatticeInf
code: /-- Group topologies on `γ` form a complete lattice, with `⊥` the discrete topology and `⊤` the
indiscrete topology.

The infimum of a collection of group topologies is the topology generated by all their open sets
(which is a group topology).

The supremum of two group topologies `s` and `t` is the infimum of the family of all group
topologies contained in the intersection of `s` and `t`. -/
@[to_additive
  "Group topologies on `γ` form a complete lattice, with `⊥` the discrete topology and
  `⊤` the indiscrete topology.

  The infimum of a collection of group topologies is the topology generated by all their open sets
  (which is a group topology).

  The supremum of two group topologies `s` and `t` is the infimum of the family of all group
  topologies contained in the intersection of `s` and `t`."]
instance : CompleteSemilatticeInf (GroupTopology α) 
goal: CompleteSemilatticeInf (GroupTopology α)

full_name: AddGroupTopology.instCompleteSemilatticeInf
code: /-- Group topologies on `γ` form a complete lattice, with `⊥` the discrete topology and `⊤` the
indiscrete topology.

The infimum of a collection of group topologies is the topology generated by all their open sets
(which is a group topology).

The supremum of two group topologies `s` and `t` is the infimum of the family of all group
topologies contained in the intersection of `s` and `t`. -/
@[to_additive
  "Group topologies on `γ` form a complete lattice, with `⊥` the discrete topology and
  `⊤` the indiscrete topology.

  The infimum of a collection of group topologies is the topology generated by all their open sets
  (which is a group topology).

  The supremum of two group topologies `s` and `t` is the infimum of the family of all group
  topologies contained in the intersection of `s` and `t`."]
instance : CompleteSemilatticeInf (GroupTopology α) 
goal: CompleteSemilatticeInf (AddGroupTopology α)

full_name: GroupTopology.instCompleteLattice
code: @[to_additive]
instance : CompleteLattice (GroupTopology α) 
goal: CompleteLattice (GroupTopology α)

full_name: AddGroupTopology.instCompleteLattice
code: @[to_additive]
instance : CompleteLattice (GroupTopology α) 
goal: CompleteLattice (AddGroupTopology α)

full_name: AddGroupTopology.coinduced
code: /-- Given `f : α → β` and a topology on `α`, the coinduced group topology on `β` is the finest
topology such that `f` is continuous and `β` is a topological group. -/
@[to_additive
  "Given `f : α → β` and a topology on `α`, the coinduced additive group topology on `β`
  is the finest topology such that `f` is continuous and `β` is a topological additive group."]
def coinduced {α β : Type*} [t : TopologicalSpace α] [Group β] (f : α → β) : GroupTopology β 
goal: AddGroupTopology β

full_name: GroupTopology.coinduced
code: /-- Given `f : α → β` and a topology on `α`, the coinduced group topology on `β` is the finest
topology such that `f` is continuous and `β` is a topological group. -/
@[to_additive
  "Given `f : α → β` and a topology on `α`, the coinduced additive group topology on `β`
  is the finest topology such that `f` is continuous and `β` is a topological additive group."]
def coinduced {α β : Type*} [t : TopologicalSpace α] [Group β] (f : α → β) : GroupTopology β 
goal: GroupTopology β

full_name: GroupTopology.coinduced_continuous
code: @[to_additive]
theorem coinduced_continuous {α β : Type*} [t : TopologicalSpace α] [Group β] (f : α → β) :
    Continuous[t, (coinduced f).toTopologicalSpace] f 
goal: Continuous f

full_name: AddGroupTopology.coinduced_continuous
code: @[to_additive]
theorem coinduced_continuous {α β : Type*} [t : TopologicalSpace α] [Group β] (f : α → β) :
    Continuous[t, (coinduced f).toTopologicalSpace] f 
goal: Continuous f