File: Mathlib/Topology/Algebra/OpenSubgroup.lean

full_name: OpenAddSubgroup.isOpen'
code: /-- The type of open subgroups of a topological additive group. -/
structure OpenAddSubgroup (G : Type*) [AddGroup G] [TopologicalSpace G] extends AddSubgroup G where
  isOpen' : IsOpen carrier
goal: IsOpen (↑self).carrier

full_name: OpenAddSubgroup
code: /-- The type of open subgroups of a topological additive group. -/
structure OpenAddSubgroup (G : Type*) [AddGroup G] [TopologicalSpace G] extends AddSubgroup G where
  isOpen' : IsOpen carrier
goal: Type u_1

full_name: OpenSubgroup
code: /-- The type of open subgroups of a topological group. -/
@[to_additive]
structure OpenSubgroup (G : Type*) [Group G] [TopologicalSpace G] extends Subgroup G where
  isOpen' : IsOpen carrier
goal: Type u_1

full_name: OpenSubgroup.isOpen'
code: /-- The type of open subgroups of a topological group. -/
@[to_additive]
structure OpenSubgroup (G : Type*) [Group G] [TopologicalSpace G] extends Subgroup G where
  isOpen' : IsOpen carrier
goal: IsOpen (↑self).carrier

full_name: OpenSubgroup.hasCoeSubgroup
code: @[to_additive]
instance hasCoeSubgroup : CoeTC (OpenSubgroup G) (Subgroup G) 
goal: CoeTC (OpenSubgroup G) (Subgroup G)

full_name: OpenAddSubgroup.hasCoeAddSubgroup
code: @[to_additive]
instance hasCoeSubgroup : CoeTC (OpenSubgroup G) (Subgroup G) 
goal: CoeTC (OpenAddSubgroup G) (AddSubgroup G)

full_name: OpenSubgroup.toSubgroup_injective
code: @[to_additive]
theorem toSubgroup_injective : Injective ((↑) : OpenSubgroup G → Subgroup G)
  
goal: Function.Injective OpenSubgroup.toSubgroup

full_name: OpenAddSubgroup.toAddSubgroup_injective
code: @[to_additive]
theorem toSubgroup_injective : Injective ((↑) : OpenSubgroup G → Subgroup G)
  
goal: Function.Injective OpenAddSubgroup.toAddSubgroup

full_name: OpenAddSubgroup.instSetLike
code: @[to_additive]
instance : SetLike (OpenSubgroup G) G 
goal: SetLike (OpenAddSubgroup G) G

full_name: OpenSubgroup.instSetLike
code: @[to_additive]
instance : SetLike (OpenSubgroup G) G 
goal: SetLike (OpenSubgroup G) G

full_name: OpenAddSubgroup.instAddSubgroupClass
code: @[to_additive]
instance : SubgroupClass (OpenSubgroup G) G 
goal: AddSubgroupClass (OpenAddSubgroup G) G

full_name: OpenSubgroup.instSubgroupClass
code: @[to_additive]
instance : SubgroupClass (OpenSubgroup G) G 
goal: SubgroupClass (OpenSubgroup G) G

full_name: OpenSubgroup.toOpens
code: /-- Coercion from `OpenSubgroup G` to `Opens G`. -/
@[to_additive (attr := coe) "Coercion from `OpenAddSubgroup G` to `Opens G`."]
def toOpens (U : OpenSubgroup G) : Opens G 
goal: TopologicalSpace.Opens G

full_name: OpenAddSubgroup.toOpens
code: /-- Coercion from `OpenSubgroup G` to `Opens G`. -/
@[to_additive (attr := coe) "Coercion from `OpenAddSubgroup G` to `Opens G`."]
def toOpens (U : OpenSubgroup G) : Opens G 
goal: TopologicalSpace.Opens G

full_name: OpenAddSubgroup.hasCoeOpens
code: @[to_additive]
instance hasCoeOpens : CoeTC (OpenSubgroup G) (Opens G) 
goal: CoeTC (OpenAddSubgroup G) (TopologicalSpace.Opens G)

full_name: OpenSubgroup.hasCoeOpens
code: @[to_additive]
instance hasCoeOpens : CoeTC (OpenSubgroup G) (Opens G) 
goal: CoeTC (OpenSubgroup G) (TopologicalSpace.Opens G)

full_name: OpenAddSubgroup.coe_toOpens
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_toOpens : ((U : Opens G) : Set G) = U 
goal: ↑↑U = ↑U

full_name: OpenSubgroup.coe_toOpens
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_toOpens : ((U : Opens G) : Set G) = U 
goal: ↑↑U = ↑U

full_name: OpenSubgroup.coe_toSubgroup
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_toSubgroup : ((U : Subgroup G) : Set G) = U 
goal: ↑↑U = ↑U

full_name: OpenAddSubgroup.coe_toAddSubgroup
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_toSubgroup : ((U : Subgroup G) : Set G) = U 
goal: ↑↑U = ↑U

full_name: OpenAddSubgroup.mem_toOpens
code: @[to_additive (attr := simp, norm_cast)]
theorem mem_toOpens : g ∈ (U : Opens G) ↔ g ∈ U 
goal: g ∈ ↑U ↔ g ∈ U

full_name: OpenSubgroup.mem_toOpens
code: @[to_additive (attr := simp, norm_cast)]
theorem mem_toOpens : g ∈ (U : Opens G) ↔ g ∈ U 
goal: g ∈ ↑U ↔ g ∈ U

full_name: OpenAddSubgroup.mem_toAddSubgroup
code: @[to_additive (attr := simp, norm_cast)]
theorem mem_toSubgroup : g ∈ (U : Subgroup G) ↔ g ∈ U 
goal: g ∈ ↑U ↔ g ∈ U

full_name: OpenSubgroup.mem_toSubgroup
code: @[to_additive (attr := simp, norm_cast)]
theorem mem_toSubgroup : g ∈ (U : Subgroup G) ↔ g ∈ U 
goal: g ∈ ↑U ↔ g ∈ U

full_name: OpenSubgroup.ext
code: @[to_additive (attr := ext)]
theorem ext (h : ∀ x, x ∈ U ↔ x ∈ V) : U = V 
goal: U = V

full_name: OpenAddSubgroup.ext
code: @[to_additive (attr := ext)]
theorem ext (h : ∀ x, x ∈ U ↔ x ∈ V) : U = V 
goal: U = V

full_name: OpenAddSubgroup.isOpen
code: @[to_additive]
protected theorem isOpen : IsOpen (U : Set G) 
goal: IsOpen ↑U

full_name: OpenSubgroup.isOpen
code: @[to_additive]
protected theorem isOpen : IsOpen (U : Set G) 
goal: IsOpen ↑U

full_name: OpenSubgroup.mem_nhds_one
code: @[to_additive]
theorem mem_nhds_one : (U : Set G) ∈ 𝓝 (1 : G) 
goal: ↑U ∈ 𝓝 1

full_name: OpenAddSubgroup.mem_nhds_zero
code: @[to_additive]
theorem mem_nhds_one : (U : Set G) ∈ 𝓝 (1 : G) 
goal: ↑U ∈ 𝓝 0

full_name: OpenAddSubgroup.instTop
code: @[to_additive] instance : Top (OpenSubgroup G) 
goal: Top (OpenAddSubgroup G)

full_name: OpenSubgroup.instTop
code: @[to_additive] instance : Top (OpenSubgroup G) 
goal: Top (OpenSubgroup G)

full_name: OpenAddSubgroup.mem_top
code: @[to_additive (attr := simp)]
theorem mem_top (x : G) : x ∈ (⊤ : OpenSubgroup G) 
goal: x ∈ ⊤

full_name: OpenSubgroup.mem_top
code: @[to_additive (attr := simp)]
theorem mem_top (x : G) : x ∈ (⊤ : OpenSubgroup G) 
goal: x ∈ ⊤

full_name: OpenAddSubgroup.coe_top
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_top : ((⊤ : OpenSubgroup G) : Set G) = Set.univ 
goal: ↑⊤ = Set.univ

full_name: OpenSubgroup.coe_top
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_top : ((⊤ : OpenSubgroup G) : Set G) = Set.univ 
goal: ↑⊤ = Set.univ

full_name: OpenSubgroup.toSubgroup_top
code: @[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_top : ((⊤ : OpenSubgroup G) : Subgroup G) = ⊤ 
goal: ↑⊤ = ⊤

full_name: OpenAddSubgroup.toAddSubgroup_top
code: @[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_top : ((⊤ : OpenSubgroup G) : Subgroup G) = ⊤ 
goal: ↑⊤ = ⊤

full_name: OpenAddSubgroup.toOpens_top
code: @[to_additive (attr := simp, norm_cast)]
theorem toOpens_top : ((⊤ : OpenSubgroup G) : Opens G) = ⊤ 
goal: ↑⊤ = ⊤

full_name: OpenSubgroup.toOpens_top
code: @[to_additive (attr := simp, norm_cast)]
theorem toOpens_top : ((⊤ : OpenSubgroup G) : Opens G) = ⊤ 
goal: ↑⊤ = ⊤

full_name: OpenAddSubgroup.instInhabited
code: @[to_additive]
instance : Inhabited (OpenSubgroup G) 
goal: Inhabited (OpenAddSubgroup G)

full_name: OpenSubgroup.instInhabited
code: @[to_additive]
instance : Inhabited (OpenSubgroup G) 
goal: Inhabited (OpenSubgroup G)

full_name: OpenSubgroup.isClosed
code: @[to_additive]
theorem isClosed [ContinuousMul G] (U : OpenSubgroup G) : IsClosed (U : Set G) 
goal: IsClosed ↑U

full_name: OpenAddSubgroup.isClosed
code: @[to_additive]
theorem isClosed [ContinuousMul G] (U : OpenSubgroup G) : IsClosed (U : Set G) 
goal: IsClosed ↑U

full_name: OpenAddSubgroup.isClopen
code: @[to_additive]
theorem isClopen [ContinuousMul G] (U : OpenSubgroup G) : IsClopen (U : Set G) 
goal: IsClopen ↑U

full_name: OpenSubgroup.isClopen
code: @[to_additive]
theorem isClopen [ContinuousMul G] (U : OpenSubgroup G) : IsClopen (U : Set G) 
goal: IsClopen ↑U

full_name: OpenAddSubgroup.sum
code: /-- The product of two open subgroups as an open subgroup of the product group. -/
@[to_additive "The product of two open subgroups as an open subgroup of the product group."]
def prod (U : OpenSubgroup G) (V : OpenSubgroup H) : OpenSubgroup (G × H) 
goal: OpenAddSubgroup (G × H)

full_name: OpenSubgroup.prod
code: /-- The product of two open subgroups as an open subgroup of the product group. -/
@[to_additive "The product of two open subgroups as an open subgroup of the product group."]
def prod (U : OpenSubgroup G) (V : OpenSubgroup H) : OpenSubgroup (G × H) 
goal: OpenSubgroup (G × H)

full_name: OpenAddSubgroup.coe_sum
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_prod (U : OpenSubgroup G) (V : OpenSubgroup H) :
    (U.prod V : Set (G × H)) = (U : Set G) ×ˢ (V : Set H) 
goal: ↑(U.sum V) = ↑U ×ˢ ↑V

full_name: OpenSubgroup.coe_prod
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_prod (U : OpenSubgroup G) (V : OpenSubgroup H) :
    (U.prod V : Set (G × H)) = (U : Set G) ×ˢ (V : Set H) 
goal: ↑(U.prod V) = ↑U ×ˢ ↑V

full_name: OpenSubgroup.toSubgroup_prod
code: @[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_prod (U : OpenSubgroup G) (V : OpenSubgroup H) :
    (U.prod V : Subgroup (G × H)) = (U : Subgroup G).prod V 
goal: ↑(U.prod V) = (↑U).prod ↑V

full_name: OpenAddSubgroup.toAddSubgroup_sum
code: @[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_prod (U : OpenSubgroup G) (V : OpenSubgroup H) :
    (U.prod V : Subgroup (G × H)) = (U : Subgroup G).prod V 
goal: ↑(U.sum V) = (↑U).prod ↑V

full_name: OpenAddSubgroup.instInfOpenAddSubgroup
code: @[to_additive]
instance instInfOpenSubgroup : Inf (OpenSubgroup G) 
goal: Inf (OpenAddSubgroup G)

full_name: OpenSubgroup.instInfOpenSubgroup
code: @[to_additive]
instance instInfOpenSubgroup : Inf (OpenSubgroup G) 
goal: Inf (OpenSubgroup G)

full_name: OpenSubgroup.coe_inf
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_inf : (↑(U ⊓ V) : Set G) = (U : Set G) ∩ V 
goal: ↑(U ⊓ V) = ↑U ∩ ↑V

full_name: OpenAddSubgroup.coe_inf
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_inf : (↑(U ⊓ V) : Set G) = (U : Set G) ∩ V 
goal: ↑(U ⊓ V) = ↑U ∩ ↑V

full_name: OpenSubgroup.toSubgroup_inf
code: @[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_inf : (↑(U ⊓ V) : Subgroup G) = ↑U ⊓ ↑V 
goal: ↑(U ⊓ V) = ↑U ⊓ ↑V

full_name: OpenAddSubgroup.toAddSubgroup_inf
code: @[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_inf : (↑(U ⊓ V) : Subgroup G) = ↑U ⊓ ↑V 
goal: ↑(U ⊓ V) = ↑U ⊓ ↑V

full_name: OpenAddSubgroup.toOpens_inf
code: @[to_additive (attr := simp, norm_cast)]
theorem toOpens_inf : (↑(U ⊓ V) : Opens G) = ↑U ⊓ ↑V 
goal: ↑(U ⊓ V) = ↑U ⊓ ↑V

full_name: OpenSubgroup.toOpens_inf
code: @[to_additive (attr := simp, norm_cast)]
theorem toOpens_inf : (↑(U ⊓ V) : Opens G) = ↑U ⊓ ↑V 
goal: ↑(U ⊓ V) = ↑U ⊓ ↑V

full_name: OpenSubgroup.mem_inf
code: @[to_additive (attr := simp)]
theorem mem_inf {x} : x ∈ U ⊓ V ↔ x ∈ U ∧ x ∈ V 
goal: x ∈ U ⊓ V ↔ x ∈ U ∧ x ∈ V

full_name: OpenAddSubgroup.mem_inf
code: @[to_additive (attr := simp)]
theorem mem_inf {x} : x ∈ U ⊓ V ↔ x ∈ U ∧ x ∈ V 
goal: x ∈ U ⊓ V ↔ x ∈ U ∧ x ∈ V

full_name: OpenSubgroup.instPartialOrderOpenSubgroup
code: @[to_additive]
instance instPartialOrderOpenSubgroup : PartialOrder (OpenSubgroup G) 
goal: PartialOrder (OpenSubgroup G)

full_name: OpenAddSubgroup.instPartialOrderOpenAddSubgroup
code: @[to_additive]
instance instPartialOrderOpenSubgroup : PartialOrder (OpenSubgroup G) 
goal: PartialOrder (OpenAddSubgroup G)

full_name: OpenAddSubgroup.instSemilatticeInfOpenAddSubgroup
code: @[to_additive]
instance instSemilatticeInfOpenSubgroup : SemilatticeInf (OpenSubgroup G) 
goal: SemilatticeInf (OpenAddSubgroup G)

full_name: OpenSubgroup.instSemilatticeInfOpenSubgroup
code: @[to_additive]
instance instSemilatticeInfOpenSubgroup : SemilatticeInf (OpenSubgroup G) 
goal: SemilatticeInf (OpenSubgroup G)

full_name: OpenSubgroup.instOrderTop
code: @[to_additive]
instance : OrderTop (OpenSubgroup G) 
goal: OrderTop (OpenSubgroup G)

full_name: OpenAddSubgroup.instOrderTop
code: @[to_additive]
instance : OrderTop (OpenSubgroup G) 
goal: OrderTop (OpenAddSubgroup G)

full_name: OpenAddSubgroup.toAddSubgroup_le
code: @[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_le : (U : Subgroup G) ≤ (V : Subgroup G) ↔ U ≤ V 
goal: ↑U ≤ ↑V ↔ U ≤ V

full_name: OpenSubgroup.toSubgroup_le
code: @[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_le : (U : Subgroup G) ≤ (V : Subgroup G) ↔ U ≤ V 
goal: ↑U ≤ ↑V ↔ U ≤ V

full_name: OpenSubgroup.comap
code: /-- The preimage of an `OpenSubgroup` along a continuous `Monoid` homomorphism
  is an `OpenSubgroup`. -/
@[to_additive "The preimage of an `OpenAddSubgroup` along a continuous `AddMonoid` homomorphism
is an `OpenAddSubgroup`."]
def comap (f : G →* N) (hf : Continuous f) (H : OpenSubgroup N) : OpenSubgroup G 
goal: OpenSubgroup G

full_name: OpenAddSubgroup.comap
code: /-- The preimage of an `OpenSubgroup` along a continuous `Monoid` homomorphism
  is an `OpenSubgroup`. -/
@[to_additive "The preimage of an `OpenAddSubgroup` along a continuous `AddMonoid` homomorphism
is an `OpenAddSubgroup`."]
def comap (f : G →* N) (hf : Continuous f) (H : OpenSubgroup N) : OpenSubgroup G 
goal: OpenAddSubgroup G

full_name: OpenAddSubgroup.coe_comap
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_comap (H : OpenSubgroup N) (f : G →* N) (hf : Continuous f) :
    (H.comap f hf : Set G) = f ⁻¹' H 
goal: ↑(OpenAddSubgroup.comap f hf H) = ⇑f ⁻¹' ↑H

full_name: OpenSubgroup.coe_comap
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_comap (H : OpenSubgroup N) (f : G →* N) (hf : Continuous f) :
    (H.comap f hf : Set G) = f ⁻¹' H 
goal: ↑(OpenSubgroup.comap f hf H) = ⇑f ⁻¹' ↑H

full_name: OpenSubgroup.toSubgroup_comap
code: @[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_comap (H : OpenSubgroup N) (f : G →* N) (hf : Continuous f) :
    (H.comap f hf : Subgroup G) = (H : Subgroup N).comap f 
goal: ↑(OpenSubgroup.comap f hf H) = Subgroup.comap f ↑H

full_name: OpenAddSubgroup.toAddSubgroup_comap
code: @[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_comap (H : OpenSubgroup N) (f : G →* N) (hf : Continuous f) :
    (H.comap f hf : Subgroup G) = (H : Subgroup N).comap f 
goal: ↑(OpenAddSubgroup.comap f hf H) = AddSubgroup.comap f ↑H

full_name: OpenAddSubgroup.mem_comap
code: @[to_additive (attr := simp)]
theorem mem_comap {H : OpenSubgroup N} {f : G →* N} {hf : Continuous f} {x : G} :
    x ∈ H.comap f hf ↔ f x ∈ H 
goal: x ∈ OpenAddSubgroup.comap f hf H ↔ f x ∈ H

full_name: OpenSubgroup.mem_comap
code: @[to_additive (attr := simp)]
theorem mem_comap {H : OpenSubgroup N} {f : G →* N} {hf : Continuous f} {x : G} :
    x ∈ H.comap f hf ↔ f x ∈ H 
goal: x ∈ OpenSubgroup.comap f hf H ↔ f x ∈ H

full_name: OpenSubgroup.comap_comap
code: @[to_additive]
theorem comap_comap {P : Type*} [Group P] [TopologicalSpace P] (K : OpenSubgroup P) (f₂ : N →* P)
    (hf₂ : Continuous f₂) (f₁ : G →* N) (hf₁ : Continuous f₁) :
    (K.comap f₂ hf₂).comap f₁ hf₁ = K.comap (f₂.comp f₁) (hf₂.comp hf₁) 
goal: OpenSubgroup.comap f₁ hf₁ (OpenSubgroup.comap f₂ hf₂ K) = OpenSubgroup.comap (f₂.comp f₁) ⋯ K

full_name: OpenAddSubgroup.comap_comap
code: @[to_additive]
theorem comap_comap {P : Type*} [Group P] [TopologicalSpace P] (K : OpenSubgroup P) (f₂ : N →* P)
    (hf₂ : Continuous f₂) (f₁ : G →* N) (hf₁ : Continuous f₁) :
    (K.comap f₂ hf₂).comap f₁ hf₁ = K.comap (f₂.comp f₁) (hf₂.comp hf₁) 
goal: OpenAddSubgroup.comap f₁ hf₁ (OpenAddSubgroup.comap f₂ hf₂ K) = OpenAddSubgroup.comap (f₂.comp f₁) ⋯ K

full_name: AddSubgroup.isOpen_of_mem_nhds
code: @[to_additive]
theorem isOpen_of_mem_nhds [ContinuousMul G] (H : Subgroup G) {g : G} (hg : (H : Set G) ∈ 𝓝 g) :
    IsOpen (H : Set G) 
goal: IsOpen ↑H

full_name: Subgroup.isOpen_of_mem_nhds
code: @[to_additive]
theorem isOpen_of_mem_nhds [ContinuousMul G] (H : Subgroup G) {g : G} (hg : (H : Set G) ∈ 𝓝 g) :
    IsOpen (H : Set G) 
goal: IsOpen ↑H

full_name: Subgroup.isOpen_mono
code: @[to_additive]
theorem isOpen_mono [ContinuousMul G] {H₁ H₂ : Subgroup G} (h : H₁ ≤ H₂)
    (h₁ : IsOpen (H₁ : Set G)) : IsOpen (H₂ : Set G) 
goal: IsOpen ↑H₂

full_name: AddSubgroup.isOpen_mono
code: @[to_additive]
theorem isOpen_mono [ContinuousMul G] {H₁ H₂ : Subgroup G} (h : H₁ ≤ H₂)
    (h₁ : IsOpen (H₁ : Set G)) : IsOpen (H₂ : Set G) 
goal: IsOpen ↑H₂

full_name: Subgroup.isOpen_of_openSubgroup
code: @[to_additive]
theorem isOpen_of_openSubgroup [ContinuousMul G] (H: Subgroup G) {U : OpenSubgroup G} (h : ↑U ≤ H) :
    IsOpen (H : Set G) 
goal: IsOpen ↑H

full_name: AddSubgroup.isOpen_of_openAddSubgroup
code: @[to_additive]
theorem isOpen_of_openSubgroup [ContinuousMul G] (H: Subgroup G) {U : OpenSubgroup G} (h : ↑U ≤ H) :
    IsOpen (H : Set G) 
goal: IsOpen ↑H

full_name: AddSubgroup.isOpen_of_zero_mem_interior
code: /-- If a subgroup of a topological group has `1` in its interior, then it is open. -/
@[to_additive "If a subgroup of an additive topological group has `0` in its interior, then it is
open."]
theorem isOpen_of_one_mem_interior [ContinuousMul G] (H: Subgroup G)
    (h_1_int : (1 : G) ∈ interior (H : Set G)) : IsOpen (H : Set G) 
goal: IsOpen ↑H

full_name: Subgroup.isOpen_of_one_mem_interior
code: /-- If a subgroup of a topological group has `1` in its interior, then it is open. -/
@[to_additive "If a subgroup of an additive topological group has `0` in its interior, then it is
open."]
theorem isOpen_of_one_mem_interior [ContinuousMul G] (H: Subgroup G)
    (h_1_int : (1 : G) ∈ interior (H : Set G)) : IsOpen (H : Set G) 
goal: IsOpen ↑H

full_name: OpenAddSubgroup.instSup
code: @[to_additive]
instance : Sup (OpenSubgroup G) 
goal: Sup (OpenAddSubgroup G)

full_name: OpenSubgroup.instSup
code: @[to_additive]
instance : Sup (OpenSubgroup G) 
goal: Sup (OpenSubgroup G)

full_name: OpenAddSubgroup.toAddSubgroup_sup
code: @[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_sup (U V : OpenSubgroup G) : (↑(U ⊔ V) : Subgroup G) = ↑U ⊔ ↑V 
goal: ↑(U ⊔ V) = ↑U ⊔ ↑V

full_name: OpenSubgroup.toSubgroup_sup
code: @[to_additive (attr := simp, norm_cast)]
theorem toSubgroup_sup (U V : OpenSubgroup G) : (↑(U ⊔ V) : Subgroup G) = ↑U ⊔ ↑V 
goal: ↑(U ⊔ V) = ↑U ⊔ ↑V

full_name: OpenAddSubgroup.instLattice
code: @[to_additive]
instance : Lattice (OpenSubgroup G) 
goal: Lattice (OpenAddSubgroup G)

full_name: OpenSubgroup.instLattice
code: @[to_additive]
instance : Lattice (OpenSubgroup G) 
goal: Lattice (OpenSubgroup G)

full_name: Submodule.isOpen_mono
code: theorem isOpen_mono {U P : Submodule R M} (h : U ≤ P) (hU : IsOpen (U : Set M)) :
    IsOpen (P : Set M) 
goal: IsOpen ↑P

full_name: Ideal.isOpen_of_isOpen_subideal
code: theorem isOpen_of_isOpen_subideal {U I : Ideal R} (h : U ≤ I) (hU : IsOpen (U : Set R)) :
    IsOpen (I : Set R) 
goal: IsOpen ↑I