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

full_name: InvMemClass.inv_mem
code: /-- `InvMemClass S G` states `S` is a type of subsets `s ⊆ G` closed under inverses. -/
class InvMemClass (S G : Type*) [Inv G] [SetLike S G] : Prop where
  /-- `s` is closed under inverses -/
  inv_mem : ∀ {s : S} {x}, x ∈ s → x⁻¹ ∈ s
goal: x ∈ s → x⁻¹ ∈ s

full_name: InvMemClass
code: /-- `InvMemClass S G` states `S` is a type of subsets `s ⊆ G` closed under inverses. -/
class InvMemClass (S G : Type*) [Inv G] [SetLike S G] : Prop where
  /-- `s` is closed under inverses -/
  inv_mem : ∀ {s : S} {x}, x ∈ s → x⁻¹ ∈ s
goal: Prop

full_name: NegMemClass.neg_mem
code: /-- `NegMemClass S G` states `S` is a type of subsets `s ⊆ G` closed under negation. -/
class NegMemClass (S G : Type*) [Neg G] [SetLike S G] : Prop where
  /-- `s` is closed under negation -/
  neg_mem : ∀ {s : S} {x}, x ∈ s → -x ∈ s
goal: x ∈ s → -x ∈ s

full_name: NegMemClass
code: /-- `NegMemClass S G` states `S` is a type of subsets `s ⊆ G` closed under negation. -/
class NegMemClass (S G : Type*) [Neg G] [SetLike S G] : Prop where
  /-- `s` is closed under negation -/
  neg_mem : ∀ {s : S} {x}, x ∈ s → -x ∈ s
goal: Prop

full_name: SubgroupClass
code: /-- `SubgroupClass S G` states `S` is a type of subsets `s ⊆ G` that are subgroups of `G`. -/
class SubgroupClass (S G : Type*) [DivInvMonoid G] [SetLike S G] extends SubmonoidClass S G,
  InvMemClass S G : Prop
goal: Prop

full_name: AddSubgroupClass
code: /-- `AddSubgroupClass S G` states `S` is a type of subsets `s ⊆ G` that are
additive subgroups of `G`. -/
class AddSubgroupClass (S G : Type*) [SubNegMonoid G] [SetLike S G] extends AddSubmonoidClass S G,
  NegMemClass S G : Prop
goal: Prop

full_name: inv_mem_iff
code: @[to_additive (attr := simp)]
theorem inv_mem_iff {S G} [InvolutiveInv G] {_ : SetLike S G} [InvMemClass S G] {H : S}
    {x : G} : x⁻¹ ∈ H ↔ x ∈ H 
goal: ∀ {x : SetLike S G} [inst : InvMemClass S G] {H : S} {x_1 : G}, x_1⁻¹ ∈ H ↔ x_1 ∈ H

full_name: neg_mem_iff
code: @[to_additive (attr := simp)]
theorem inv_mem_iff {S G} [InvolutiveInv G] {_ : SetLike S G} [InvMemClass S G] {H : S}
    {x : G} : x⁻¹ ∈ H ↔ x ∈ H 
goal: ∀ {x : SetLike S G} [inst : NegMemClass S G] {H : S} {x_1 : G}, -x_1 ∈ H ↔ x_1 ∈ H

full_name: div_mem
code: /-- A subgroup is closed under division. -/
@[to_additive (attr := aesop safe apply (rule_sets := [SetLike]))
  "An additive subgroup is closed under subtraction."]
theorem div_mem {x y : M} (hx : x ∈ H) (hy : y ∈ H) : x / y ∈ H 
goal: x / y ∈ H

full_name: sub_mem
code: /-- A subgroup is closed under division. -/
@[to_additive (attr := aesop safe apply (rule_sets := [SetLike]))
  "An additive subgroup is closed under subtraction."]
theorem div_mem {x y : M} (hx : x ∈ H) (hy : y ∈ H) : x / y ∈ H 
goal: x - y ∈ H

full_name: zsmul_mem
code: @[to_additive (attr := aesop safe apply (rule_sets := [SetLike]))]
theorem zpow_mem {x : M} (hx : x ∈ K) : ∀ n : ℤ, x ^ n ∈ K
  
goal: n • x ∈ K

full_name: zpow_mem
code: @[to_additive (attr := aesop safe apply (rule_sets := [SetLike]))]
theorem zpow_mem {x : M} (hx : x ∈ K) : ∀ n : ℤ, x ^ n ∈ K
  
goal: x ^ n ∈ K

full_name: sub_mem_comm_iff
code: @[to_additive]
theorem div_mem_comm_iff {a b : G} : a / b ∈ H ↔ b / a ∈ H 
goal: a - b ∈ H ↔ b - a ∈ H

full_name: div_mem_comm_iff
code: @[to_additive]
theorem div_mem_comm_iff {a b : G} : a / b ∈ H ↔ b / a ∈ H 
goal: a / b ∈ H ↔ b / a ∈ H

full_name: exists_neg_mem_iff_exists_mem
code: @[to_additive /-(attr := simp)-/] -- Porting note: `simp` cannot simplify LHS
theorem exists_inv_mem_iff_exists_mem {P : G → Prop} :
    (∃ x : G, x ∈ H ∧ P x⁻¹) ↔ ∃ x ∈ H, P x 
goal: (∃ x ∈ H, P (-x)) ↔ ∃ x ∈ H, P x

full_name: exists_inv_mem_iff_exists_mem
code: @[to_additive /-(attr := simp)-/] -- Porting note: `simp` cannot simplify LHS
theorem exists_inv_mem_iff_exists_mem {P : G → Prop} :
    (∃ x : G, x ∈ H ∧ P x⁻¹) ↔ ∃ x ∈ H, P x 
goal: (∃ x ∈ H, P x⁻¹) ↔ ∃ x ∈ H, P x

full_name: add_mem_cancel_right
code: @[to_additive]
theorem mul_mem_cancel_right {x y : G} (h : x ∈ H) : y * x ∈ H ↔ y ∈ H 
goal: y + x ∈ H ↔ y ∈ H

full_name: mul_mem_cancel_right
code: @[to_additive]
theorem mul_mem_cancel_right {x y : G} (h : x ∈ H) : y * x ∈ H ↔ y ∈ H 
goal: y * x ∈ H ↔ y ∈ H

full_name: add_mem_cancel_left
code: @[to_additive]
theorem mul_mem_cancel_left {x y : G} (h : x ∈ H) : x * y ∈ H ↔ y ∈ H 
goal: x + y ∈ H ↔ y ∈ H

full_name: mul_mem_cancel_left
code: @[to_additive]
theorem mul_mem_cancel_left {x y : G} (h : x ∈ H) : x * y ∈ H ↔ y ∈ H 
goal: x * y ∈ H ↔ y ∈ H

full_name: NegMemClass.neg
code: /-- A subgroup of a group inherits an inverse. -/
@[to_additive "An additive subgroup of an `AddGroup` inherits an inverse."]
instance inv {G : Type u_1} {S : Type u_2} [Inv G] [SetLike S G]
  [InvMemClass S G] {H : S} : Inv H 
goal: Neg ↥H

full_name: InvMemClass.inv
code: /-- A subgroup of a group inherits an inverse. -/
@[to_additive "An additive subgroup of an `AddGroup` inherits an inverse."]
instance inv {G : Type u_1} {S : Type u_2} [Inv G] [SetLike S G]
  [InvMemClass S G] {H : S} : Inv H 
goal: Inv ↥H

full_name: InvMemClass.coe_inv
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_inv (x : H) : (x⁻¹).1 = x.1⁻¹ 
goal: ↑x⁻¹ = (↑x)⁻¹

full_name: NegMemClass.coe_neg
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_inv (x : H) : (x⁻¹).1 = x.1⁻¹ 
goal: ↑(-x) = -↑x

full_name: SubgroupClass.subset_union
code: @[to_additive]
theorem subset_union {H K L : S} : (H : Set G) ⊆ K ∪ L ↔ H ≤ K ∨ H ≤ L 
goal: ↑H ⊆ ↑K ∪ ↑L ↔ H ≤ K ∨ H ≤ L

full_name: AddSubgroupClass.subset_union
code: @[to_additive]
theorem subset_union {H K L : S} : (H : Set G) ⊆ K ∪ L ↔ H ≤ K ∨ H ≤ L 
goal: ↑H ⊆ ↑K ∪ ↑L ↔ H ≤ K ∨ H ≤ L

full_name: SubgroupClass.div
code: /-- A subgroup of a group inherits a division -/
@[to_additive "An additive subgroup of an `AddGroup` inherits a subtraction."]
instance div {G : Type u_1} {S : Type u_2} [DivInvMonoid G] [SetLike S G]
  [SubgroupClass S G] {H : S} : Div H 
goal: Div ↥H

full_name: AddSubgroupClass.sub
code: /-- A subgroup of a group inherits a division -/
@[to_additive "An additive subgroup of an `AddGroup` inherits a subtraction."]
instance div {G : Type u_1} {S : Type u_2} [DivInvMonoid G] [SetLike S G]
  [SubgroupClass S G] {H : S} : Div H 
goal: Sub ↥H

full_name: AddSubgroupClass.zsmul
code: /-- An additive subgroup of an `AddGroup` inherits an integer scaling. -/
instance _root_.AddSubgroupClass.zsmul {M S} [SubNegMonoid M] [SetLike S M]
    [AddSubgroupClass S M] {H : S} : SMul ℤ H 
goal: SMul ℤ ↥H

full_name: SubgroupClass.zpow
code: /-- A subgroup of a group inherits an integer power. -/
@[to_additive existing]
instance zpow {M S} [DivInvMonoid M] [SetLike S M] [SubgroupClass S M] {H : S} : Pow H ℤ 
goal: Pow ↥H ℤ

full_name: AddSubgroupClass.coe_sub
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_div (x y : H) : (x / y).1 = x.1 / y.1 
goal: ↑(x - y) = ↑x - ↑y

full_name: SubgroupClass.coe_div
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_div (x y : H) : (x / y).1 = x.1 / y.1 
goal: ↑(x / y) = ↑x / ↑y

full_name: SubgroupClass.toGroup
code: /-- A subgroup of a group inherits a group structure. -/
@[to_additive "An additive subgroup of an `AddGroup` inherits an `AddGroup` structure."]
instance (priority := 75) toGroup : Group H 
goal: Group ↥H

full_name: AddSubgroupClass.toAddGroup
code: /-- A subgroup of a group inherits a group structure. -/
@[to_additive "An additive subgroup of an `AddGroup` inherits an `AddGroup` structure."]
instance (priority := 75) toGroup : Group H 
goal: AddGroup ↥H

full_name: AddSubgroupClass.toAddCommGroup
code: /-- A subgroup of a `CommGroup` is a `CommGroup`. -/
@[to_additive "An additive subgroup of an `AddCommGroup` is an `AddCommGroup`."]
instance (priority := 75) toCommGroup {G : Type*} [CommGroup G] [SetLike S G] [SubgroupClass S G] :
    CommGroup H 
goal: AddCommGroup ↥H

full_name: SubgroupClass.toCommGroup
code: /-- A subgroup of a `CommGroup` is a `CommGroup`. -/
@[to_additive "An additive subgroup of an `AddCommGroup` is an `AddCommGroup`."]
instance (priority := 75) toCommGroup {G : Type*} [CommGroup G] [SetLike S G] [SubgroupClass S G] :
    CommGroup H 
goal: CommGroup ↥H

full_name: AddSubgroupClass.subtype
code: /-- The natural group hom from a subgroup of group `G` to `G`. -/
@[to_additive (attr := coe)
  "The natural group hom from an additive subgroup of `AddGroup` `G` to `G`."]
protected def subtype : H →* G 
goal: ↥H →+ G

full_name: SubgroupClass.subtype
code: /-- The natural group hom from a subgroup of group `G` to `G`. -/
@[to_additive (attr := coe)
  "The natural group hom from an additive subgroup of `AddGroup` `G` to `G`."]
protected def subtype : H →* G 
goal: ↥H →* G

full_name: SubgroupClass.coeSubtype
code: @[to_additive (attr := simp)]
theorem coeSubtype : (SubgroupClass.subtype H : H → G) = ((↑) : H → G) 
goal: ⇑↑H = Subtype.val

full_name: AddSubgroupClass.coeSubtype
code: @[to_additive (attr := simp)]
theorem coeSubtype : (SubgroupClass.subtype H : H → G) = ((↑) : H → G) 
goal: ⇑↑H = Subtype.val

full_name: SubgroupClass.coe_pow
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_pow (x : H) (n : ℕ) : ((x ^ n : H) : G) = (x : G) ^ n 
goal: ↑(x ^ n) = ↑x ^ n

full_name: AddSubgroupClass.coe_nsmul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_pow (x : H) (n : ℕ) : ((x ^ n : H) : G) = (x : G) ^ n 
goal: ↑(n • x) = n • ↑x

full_name: AddSubgroupClass.coe_zsmul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_zpow (x : H) (n : ℤ) : ((x ^ n : H) : G) = (x : G) ^ n 
goal: ↑(n • x) = n • ↑x

full_name: SubgroupClass.coe_zpow
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_zpow (x : H) (n : ℤ) : ((x ^ n : H) : G) = (x : G) ^ n 
goal: ↑(x ^ n) = ↑x ^ n

full_name: SubgroupClass.inclusion
code: /-- The inclusion homomorphism from a subgroup `H` contained in `K` to `K`. -/
@[to_additive "The inclusion homomorphism from an additive subgroup `H` contained in `K` to `K`."]
def inclusion {H K : S} (h : H ≤ K) : H →* K 
goal: ↥H →* ↥K

full_name: AddSubgroupClass.inclusion
code: /-- The inclusion homomorphism from a subgroup `H` contained in `K` to `K`. -/
@[to_additive "The inclusion homomorphism from an additive subgroup `H` contained in `K` to `K`."]
def inclusion {H K : S} (h : H ≤ K) : H →* K 
goal: ↥H →+ ↥K

full_name: AddSubgroupClass.inclusion_self
code: @[to_additive (attr := simp)]
theorem inclusion_self (x : H) : inclusion le_rfl x = x 
goal: (AddSubgroupClass.inclusion ⋯) x = x

full_name: SubgroupClass.inclusion_self
code: @[to_additive (attr := simp)]
theorem inclusion_self (x : H) : inclusion le_rfl x = x 
goal: (SubgroupClass.inclusion ⋯) x = x

full_name: SubgroupClass.inclusion_mk
code: @[to_additive (attr := simp)]
theorem inclusion_mk {h : H ≤ K} (x : G) (hx : x ∈ H) : inclusion h ⟨x, hx⟩ = ⟨x, h hx⟩ 
goal: (SubgroupClass.inclusion h) ⟨x, hx⟩ = ⟨x, ⋯⟩

full_name: AddSubgroupClass.inclusion_mk
code: @[to_additive (attr := simp)]
theorem inclusion_mk {h : H ≤ K} (x : G) (hx : x ∈ H) : inclusion h ⟨x, hx⟩ = ⟨x, h hx⟩ 
goal: (AddSubgroupClass.inclusion h) ⟨x, hx⟩ = ⟨x, ⋯⟩

full_name: SubgroupClass.inclusion_right
code: @[to_additive]
theorem inclusion_right (h : H ≤ K) (x : K) (hx : (x : G) ∈ H) : inclusion h ⟨x, hx⟩ = x 
goal: (SubgroupClass.inclusion h) ⟨↑x, hx⟩ = x

full_name: AddSubgroupClass.inclusion_right
code: @[to_additive]
theorem inclusion_right (h : H ≤ K) (x : K) (hx : (x : G) ∈ H) : inclusion h ⟨x, hx⟩ = x 
goal: (AddSubgroupClass.inclusion h) ⟨↑x, hx⟩ = x

full_name: SubgroupClass.inclusion_inclusion
code: @[simp]
theorem inclusion_inclusion {L : S} (hHK : H ≤ K) (hKL : K ≤ L) (x : H) :
    inclusion hKL (inclusion hHK x) = inclusion (hHK.trans hKL) x 
goal: (SubgroupClass.inclusion hKL) ((SubgroupClass.inclusion hHK) x) = (SubgroupClass.inclusion ⋯) x

full_name: SubgroupClass.coe_inclusion
code: @[to_additive (attr := simp)]
theorem coe_inclusion {H K : S} {h : H ≤ K} (a : H) : (inclusion h a : G) = a 
goal: ↑((SubgroupClass.inclusion h) a) = ↑a

full_name: AddSubgroupClass.coe_inclusion
code: @[to_additive (attr := simp)]
theorem coe_inclusion {H K : S} {h : H ≤ K} (a : H) : (inclusion h a : G) = a 
goal: ↑((AddSubgroupClass.inclusion h) a) = ↑a

full_name: SubgroupClass.subtype_comp_inclusion
code: @[to_additive (attr := simp)]
theorem subtype_comp_inclusion {H K : S} (hH : H ≤ K) :
    (SubgroupClass.subtype K).comp (inclusion hH) = SubgroupClass.subtype H 
goal: (↑K).comp (SubgroupClass.inclusion hH) = ↑H

full_name: AddSubgroupClass.subtype_comp_inclusion
code: @[to_additive (attr := simp)]
theorem subtype_comp_inclusion {H K : S} (hH : H ≤ K) :
    (SubgroupClass.subtype K).comp (inclusion hH) = SubgroupClass.subtype H 
goal: (↑K).comp (AddSubgroupClass.inclusion hH) = ↑H

full_name: Subgroup.inv_mem'
code: /-- A subgroup of a group `G` is a subset containing 1, closed under multiplication
and closed under multiplicative inverse. -/
structure Subgroup (G : Type*) [Group G] extends Submonoid G where
  /-- `G` is closed under inverses -/
  inv_mem' {x} : x ∈ carrier → x⁻¹ ∈ carrier
goal: x ∈ self.carrier → x⁻¹ ∈ self.carrier

full_name: Subgroup
code: /-- A subgroup of a group `G` is a subset containing 1, closed under multiplication
and closed under multiplicative inverse. -/
structure Subgroup (G : Type*) [Group G] extends Submonoid G where
  /-- `G` is closed under inverses -/
  inv_mem' {x} : x ∈ carrier → x⁻¹ ∈ carrier
goal: Type u_5

full_name: AddSubgroup.neg_mem'
code: /-- An additive subgroup of an additive group `G` is a subset containing 0, closed
under addition and additive inverse. -/
structure AddSubgroup (G : Type*) [AddGroup G] extends AddSubmonoid G where
  /-- `G` is closed under negation -/
  neg_mem' {x} : x ∈ carrier → -x ∈ carrier
goal: x ∈ self.carrier → -x ∈ self.carrier

full_name: AddSubgroup
code: /-- An additive subgroup of an additive group `G` is a subset containing 0, closed
under addition and additive inverse. -/
structure AddSubgroup (G : Type*) [AddGroup G] extends AddSubmonoid G where
  /-- `G` is closed under negation -/
  neg_mem' {x} : x ∈ carrier → -x ∈ carrier
goal: Type u_5

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

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

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

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

full_name: Subgroup.mem_carrier
code: @[to_additive (attr := simp, nolint simpNF)] -- Porting note (#10675): dsimp can not prove this
theorem mem_carrier {s : Subgroup G} {x : G} : x ∈ s.carrier ↔ x ∈ s 
goal: x ∈ s.carrier ↔ x ∈ s

full_name: AddSubgroup.mem_carrier
code: @[to_additive (attr := simp, nolint simpNF)] -- Porting note (#10675): dsimp can not prove this
theorem mem_carrier {s : Subgroup G} {x : G} : x ∈ s.carrier ↔ x ∈ s 
goal: x ∈ s.carrier ↔ x ∈ s

full_name: Subgroup.mem_mk
code: @[to_additive (attr := simp)]
theorem mem_mk {s : Set G} {x : G} (h_one) (h_mul) (h_inv) :
    x ∈ mk ⟨⟨s, h_one⟩, h_mul⟩ h_inv ↔ x ∈ s 
goal: x ∈ { carrier := s, mul_mem' := h_one, one_mem' := h_mul, inv_mem' := h_inv } ↔ x ∈ s

full_name: AddSubgroup.mem_mk
code: @[to_additive (attr := simp)]
theorem mem_mk {s : Set G} {x : G} (h_one) (h_mul) (h_inv) :
    x ∈ mk ⟨⟨s, h_one⟩, h_mul⟩ h_inv ↔ x ∈ s 
goal: x ∈ { carrier := s, add_mem' := h_one, zero_mem' := h_mul, neg_mem' := h_inv } ↔ x ∈ s

full_name: AddSubgroup.coe_set_mk
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_set_mk {s : Set G} (h_one) (h_mul) (h_inv) :
    (mk ⟨⟨s, h_one⟩, h_mul⟩ h_inv : Set G) = s 
goal: ↑{ carrier := s, add_mem' := h_one, zero_mem' := h_mul, neg_mem' := h_inv } = s

full_name: Subgroup.coe_set_mk
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_set_mk {s : Set G} (h_one) (h_mul) (h_inv) :
    (mk ⟨⟨s, h_one⟩, h_mul⟩ h_inv : Set G) = s 
goal: ↑{ carrier := s, mul_mem' := h_one, one_mem' := h_mul, inv_mem' := h_inv } = s

full_name: AddSubgroup.mk_le_mk
code: @[to_additive (attr := simp)]
theorem mk_le_mk {s t : Set G} (h_one) (h_mul) (h_inv) (h_one') (h_mul') (h_inv') :
    mk ⟨⟨s, h_one⟩, h_mul⟩ h_inv ≤ mk ⟨⟨t, h_one'⟩, h_mul'⟩ h_inv' ↔ s ⊆ t 
goal: { carrier := s, add_mem' := h_one, zero_mem' := h_mul, neg_mem' := h_inv } ≤
    { carrier := t, add_mem' := h_one', zero_mem' := h_mul', neg_mem' := h_inv' } ↔
  s ⊆ t

full_name: Subgroup.mk_le_mk
code: @[to_additive (attr := simp)]
theorem mk_le_mk {s t : Set G} (h_one) (h_mul) (h_inv) (h_one') (h_mul') (h_inv') :
    mk ⟨⟨s, h_one⟩, h_mul⟩ h_inv ≤ mk ⟨⟨t, h_one'⟩, h_mul'⟩ h_inv' ↔ s ⊆ t 
goal: { carrier := s, mul_mem' := h_one, one_mem' := h_mul, inv_mem' := h_inv } ≤
    { carrier := t, mul_mem' := h_one', one_mem' := h_mul', inv_mem' := h_inv' } ↔
  s ⊆ t

full_name: Subgroup.coe_toSubmonoid
code: @[to_additive (attr := simp)]
theorem coe_toSubmonoid (K : Subgroup G) : (K.toSubmonoid : Set G) = K 
goal: ↑K.toSubmonoid = ↑K

full_name: AddSubgroup.coe_toAddSubmonoid
code: @[to_additive (attr := simp)]
theorem coe_toSubmonoid (K : Subgroup G) : (K.toSubmonoid : Set G) = K 
goal: ↑K.toAddSubmonoid = ↑K

full_name: Subgroup.mem_toSubmonoid
code: @[to_additive (attr := simp)]
theorem mem_toSubmonoid (K : Subgroup G) (x : G) : x ∈ K.toSubmonoid ↔ x ∈ K 
goal: x ∈ K.toSubmonoid ↔ x ∈ K

full_name: AddSubgroup.mem_toAddSubmonoid
code: @[to_additive (attr := simp)]
theorem mem_toSubmonoid (K : Subgroup G) (x : G) : x ∈ K.toSubmonoid ↔ x ∈ K 
goal: x ∈ K.toAddSubmonoid ↔ x ∈ K

full_name: Subgroup.toSubmonoid_injective
code: @[to_additive]
theorem toSubmonoid_injective : Function.Injective (toSubmonoid : Subgroup G → Submonoid G) 
goal: Function.Injective Subgroup.toSubmonoid

full_name: AddSubgroup.toAddSubmonoid_injective
code: @[to_additive]
theorem toSubmonoid_injective : Function.Injective (toSubmonoid : Subgroup G → Submonoid G) 
goal: Function.Injective AddSubgroup.toAddSubmonoid

full_name: AddSubgroup.toAddSubmonoid_eq
code: @[to_additive (attr := simp)]
theorem toSubmonoid_eq {p q : Subgroup G} : p.toSubmonoid = q.toSubmonoid ↔ p = q 
goal: p.toAddSubmonoid = q.toAddSubmonoid ↔ p = q

full_name: Subgroup.toSubmonoid_eq
code: @[to_additive (attr := simp)]
theorem toSubmonoid_eq {p q : Subgroup G} : p.toSubmonoid = q.toSubmonoid ↔ p = q 
goal: p.toSubmonoid = q.toSubmonoid ↔ p = q

full_name: Subgroup.toSubmonoid_strictMono
code: @[to_additive (attr := mono)]
theorem toSubmonoid_strictMono : StrictMono (toSubmonoid : Subgroup G → Submonoid G) 
goal: StrictMono Subgroup.toSubmonoid

full_name: AddSubgroup.toAddSubmonoid_strictMono
code: @[to_additive (attr := mono)]
theorem toSubmonoid_strictMono : StrictMono (toSubmonoid : Subgroup G → Submonoid G) 
goal: StrictMono AddSubgroup.toAddSubmonoid

full_name: AddSubgroup.toAddSubmonoid_mono
code: @[to_additive (attr := mono)]
theorem toSubmonoid_mono : Monotone (toSubmonoid : Subgroup G → Submonoid G) 
goal: Monotone AddSubgroup.toAddSubmonoid

full_name: Subgroup.toSubmonoid_mono
code: @[to_additive (attr := mono)]
theorem toSubmonoid_mono : Monotone (toSubmonoid : Subgroup G → Submonoid G) 
goal: Monotone Subgroup.toSubmonoid

full_name: AddSubgroup.toAddSubmonoid_le
code: @[to_additive (attr := simp)]
theorem toSubmonoid_le {p q : Subgroup G} : p.toSubmonoid ≤ q.toSubmonoid ↔ p ≤ q 
goal: p.toAddSubmonoid ≤ q.toAddSubmonoid ↔ p ≤ q

full_name: Subgroup.toSubmonoid_le
code: @[to_additive (attr := simp)]
theorem toSubmonoid_le {p q : Subgroup G} : p.toSubmonoid ≤ q.toSubmonoid ↔ p ≤ q 
goal: p.toSubmonoid ≤ q.toSubmonoid ↔ p ≤ q

full_name: AddSubgroup.coe_nonempty
code: @[to_additive (attr := simp)]
lemma coe_nonempty (s : Subgroup G) : (s : Set G).Nonempty 
goal: (↑s).Nonempty

full_name: Subgroup.coe_nonempty
code: @[to_additive (attr := simp)]
lemma coe_nonempty (s : Subgroup G) : (s : Set G).Nonempty 
goal: (↑s).Nonempty

full_name: Subgroup.toAddSubgroup_apply_coe
code: /-- Subgroups of a group `G` are isomorphic to additive subgroups of `Additive G`. -/
@[simps!]
def Subgroup.toAddSubgroup : Subgroup G ≃o AddSubgroup (Additive G) 
goal: ↑(Subgroup.toAddSubgroup S) = ⇑Additive.toMul ⁻¹' ↑S

full_name: Subgroup.toAddSubgroup
code: /-- Subgroups of a group `G` are isomorphic to additive subgroups of `Additive G`. -/
@[simps!]
def Subgroup.toAddSubgroup : Subgroup G ≃o AddSubgroup (Additive G) 
goal: Subgroup G ≃o AddSubgroup (Additive G)

full_name: Subgroup.toAddSubgroup_symm_apply_coe
code: /-- Subgroups of a group `G` are isomorphic to additive subgroups of `Additive G`. -/
@[simps!]
def Subgroup.toAddSubgroup : Subgroup G ≃o AddSubgroup (Additive G) 
goal: ↑((RelIso.symm Subgroup.toAddSubgroup) S) = ⇑Multiplicative.toAdd ⁻¹' ↑S

full_name: AddSubgroup.toSubgroup'
code: /-- Additive subgroup of an additive group `Additive G` are isomorphic to subgroup of `G`. -/
abbrev AddSubgroup.toSubgroup' : AddSubgroup (Additive G) ≃o Subgroup G 
goal: AddSubgroup (Additive G) ≃o Subgroup G

full_name: AddSubgroup.toSubgroup
code: /-- Additive subgroups of an additive group `A` are isomorphic to subgroups of `Multiplicative A`.
-/
@[simps!]
def AddSubgroup.toSubgroup : AddSubgroup A ≃o Subgroup (Multiplicative A) 
goal: AddSubgroup A ≃o Subgroup (Multiplicative A)

full_name: AddSubgroup.toSubgroup_symm_apply_coe
code: /-- Additive subgroups of an additive group `A` are isomorphic to subgroups of `Multiplicative A`.
-/
@[simps!]
def AddSubgroup.toSubgroup : AddSubgroup A ≃o Subgroup (Multiplicative A) 
goal: ↑((RelIso.symm AddSubgroup.toSubgroup) S) = ⇑Additive.toMul ⁻¹' ↑S

full_name: AddSubgroup.toSubgroup_apply_coe
code: /-- Additive subgroups of an additive group `A` are isomorphic to subgroups of `Multiplicative A`.
-/
@[simps!]
def AddSubgroup.toSubgroup : AddSubgroup A ≃o Subgroup (Multiplicative A) 
goal: ↑(AddSubgroup.toSubgroup S) = ⇑Multiplicative.toAdd ⁻¹' ↑S

full_name: Subgroup.toAddSubgroup'
code: /-- Subgroups of an additive group `Multiplicative A` are isomorphic to additive subgroups of `A`.
-/
abbrev Subgroup.toAddSubgroup' : Subgroup (Multiplicative A) ≃o AddSubgroup A 
goal: Subgroup (Multiplicative A) ≃o AddSubgroup A

full_name: Subgroup.copy
code: /-- Copy of a subgroup with a new `carrier` equal to the old one. Useful to fix definitional
equalities. -/
@[to_additive
      "Copy of an additive subgroup with a new `carrier` equal to the old one.
      Useful to fix definitional equalities"]
protected def copy (K : Subgroup G) (s : Set G) (hs : s = K) : Subgroup G 
goal: Subgroup G

full_name: AddSubgroup.copy
code: /-- Copy of a subgroup with a new `carrier` equal to the old one. Useful to fix definitional
equalities. -/
@[to_additive
      "Copy of an additive subgroup with a new `carrier` equal to the old one.
      Useful to fix definitional equalities"]
protected def copy (K : Subgroup G) (s : Set G) (hs : s = K) : Subgroup G 
goal: AddSubgroup G

full_name: Subgroup.coe_copy
code: @[to_additive (attr := simp)]
theorem coe_copy (K : Subgroup G) (s : Set G) (hs : s = ↑K) : (K.copy s hs : Set G) = s 
goal: ↑(K.copy s hs) = s

full_name: AddSubgroup.coe_copy
code: @[to_additive (attr := simp)]
theorem coe_copy (K : Subgroup G) (s : Set G) (hs : s = ↑K) : (K.copy s hs : Set G) = s 
goal: ↑(K.copy s hs) = s

full_name: AddSubgroup.copy_eq
code: @[to_additive]
theorem copy_eq (K : Subgroup G) (s : Set G) (hs : s = ↑K) : K.copy s hs = K 
goal: K.copy s hs = K

full_name: Subgroup.copy_eq
code: @[to_additive]
theorem copy_eq (K : Subgroup G) (s : Set G) (hs : s = ↑K) : K.copy s hs = K 
goal: K.copy s hs = K

full_name: Subgroup.ext
code: /-- Two subgroups are equal if they have the same elements. -/
@[to_additive (attr := ext) "Two `AddSubgroup`s are equal if they have the same elements."]
theorem ext {H K : Subgroup G} (h : ∀ x, x ∈ H ↔ x ∈ K) : H = K 
goal: H = K

full_name: AddSubgroup.ext
code: /-- Two subgroups are equal if they have the same elements. -/
@[to_additive (attr := ext) "Two `AddSubgroup`s are equal if they have the same elements."]
theorem ext {H K : Subgroup G} (h : ∀ x, x ∈ H ↔ x ∈ K) : H = K 
goal: H = K

full_name: Subgroup.one_mem
code: /-- A subgroup contains the group's 1. -/
@[to_additive "An `AddSubgroup` contains the group's 0."]
protected theorem one_mem : (1 : G) ∈ H 
goal: 1 ∈ H

full_name: AddSubgroup.zero_mem
code: /-- A subgroup contains the group's 1. -/
@[to_additive "An `AddSubgroup` contains the group's 0."]
protected theorem one_mem : (1 : G) ∈ H 
goal: 0 ∈ H

full_name: AddSubgroup.add_mem
code: /-- A subgroup is closed under multiplication. -/
@[to_additive "An `AddSubgroup` is closed under addition."]
protected theorem mul_mem {x y : G} : x ∈ H → y ∈ H → x * y ∈ H 
goal: x ∈ H → y ∈ H → x + y ∈ H

full_name: Subgroup.mul_mem
code: /-- A subgroup is closed under multiplication. -/
@[to_additive "An `AddSubgroup` is closed under addition."]
protected theorem mul_mem {x y : G} : x ∈ H → y ∈ H → x * y ∈ H 
goal: x ∈ H → y ∈ H → x * y ∈ H

full_name: AddSubgroup.neg_mem
code: /-- A subgroup is closed under inverse. -/
@[to_additive "An `AddSubgroup` is closed under inverse."]
protected theorem inv_mem {x : G} : x ∈ H → x⁻¹ ∈ H 
goal: x ∈ H → -x ∈ H

full_name: Subgroup.inv_mem
code: /-- A subgroup is closed under inverse. -/
@[to_additive "An `AddSubgroup` is closed under inverse."]
protected theorem inv_mem {x : G} : x ∈ H → x⁻¹ ∈ H 
goal: x ∈ H → x⁻¹ ∈ H

full_name: AddSubgroup.sub_mem
code: /-- A subgroup is closed under division. -/
@[to_additive "An `AddSubgroup` is closed under subtraction."]
protected theorem div_mem {x y : G} (hx : x ∈ H) (hy : y ∈ H) : x / y ∈ H 
goal: x - y ∈ H

full_name: Subgroup.div_mem
code: /-- A subgroup is closed under division. -/
@[to_additive "An `AddSubgroup` is closed under subtraction."]
protected theorem div_mem {x y : G} (hx : x ∈ H) (hy : y ∈ H) : x / y ∈ H 
goal: x / y ∈ H

full_name: Subgroup.inv_mem_iff
code: @[to_additive]
protected theorem inv_mem_iff {x : G} : x⁻¹ ∈ H ↔ x ∈ H 
goal: x⁻¹ ∈ H ↔ x ∈ H

full_name: AddSubgroup.neg_mem_iff
code: @[to_additive]
protected theorem inv_mem_iff {x : G} : x⁻¹ ∈ H ↔ x ∈ H 
goal: -x ∈ H ↔ x ∈ H

full_name: Subgroup.div_mem_comm_iff
code: @[to_additive]
protected theorem div_mem_comm_iff {a b : G} : a / b ∈ H ↔ b / a ∈ H 
goal: a / b ∈ H ↔ b / a ∈ H

full_name: AddSubgroup.sub_mem_comm_iff
code: @[to_additive]
protected theorem div_mem_comm_iff {a b : G} : a / b ∈ H ↔ b / a ∈ H 
goal: a - b ∈ H ↔ b - a ∈ H

full_name: AddSubgroup.exists_neg_mem_iff_exists_mem
code: @[to_additive]
protected theorem exists_inv_mem_iff_exists_mem (K : Subgroup G) {P : G → Prop} :
    (∃ x : G, x ∈ K ∧ P x⁻¹) ↔ ∃ x ∈ K, P x 
goal: (∃ x ∈ K, P (-x)) ↔ ∃ x ∈ K, P x

full_name: Subgroup.exists_inv_mem_iff_exists_mem
code: @[to_additive]
protected theorem exists_inv_mem_iff_exists_mem (K : Subgroup G) {P : G → Prop} :
    (∃ x : G, x ∈ K ∧ P x⁻¹) ↔ ∃ x ∈ K, P x 
goal: (∃ x ∈ K, P x⁻¹) ↔ ∃ x ∈ K, P x

full_name: AddSubgroup.add_mem_cancel_right
code: @[to_additive]
protected theorem mul_mem_cancel_right {x y : G} (h : x ∈ H) : y * x ∈ H ↔ y ∈ H 
goal: y + x ∈ H ↔ y ∈ H

full_name: Subgroup.mul_mem_cancel_right
code: @[to_additive]
protected theorem mul_mem_cancel_right {x y : G} (h : x ∈ H) : y * x ∈ H ↔ y ∈ H 
goal: y * x ∈ H ↔ y ∈ H

full_name: AddSubgroup.add_mem_cancel_left
code: @[to_additive]
protected theorem mul_mem_cancel_left {x y : G} (h : x ∈ H) : x * y ∈ H ↔ y ∈ H 
goal: x + y ∈ H ↔ y ∈ H

full_name: Subgroup.mul_mem_cancel_left
code: @[to_additive]
protected theorem mul_mem_cancel_left {x y : G} (h : x ∈ H) : x * y ∈ H ↔ y ∈ H 
goal: x * y ∈ H ↔ y ∈ H

full_name: Subgroup.pow_mem
code: @[to_additive]
protected theorem pow_mem {x : G} (hx : x ∈ K) : ∀ n : ℕ, x ^ n ∈ K 
goal: x ^ n ∈ K

full_name: AddSubgroup.nsmul_mem
code: @[to_additive]
protected theorem pow_mem {x : G} (hx : x ∈ K) : ∀ n : ℕ, x ^ n ∈ K 
goal: n • x ∈ K

full_name: Subgroup.zpow_mem
code: @[to_additive]
protected theorem zpow_mem {x : G} (hx : x ∈ K) : ∀ n : ℤ, x ^ n ∈ K 
goal: x ^ n ∈ K

full_name: AddSubgroup.zsmul_mem
code: @[to_additive]
protected theorem zpow_mem {x : G} (hx : x ∈ K) : ∀ n : ℤ, x ^ n ∈ K 
goal: n • x ∈ K

full_name: Subgroup.ofDiv
code: /-- Construct a subgroup from a nonempty set that is closed under division. -/
@[to_additive "Construct a subgroup from a nonempty set that is closed under subtraction"]
def ofDiv (s : Set G) (hsn : s.Nonempty) (hs : ∀ᵉ (x ∈ s) (y ∈ s), x * y⁻¹ ∈ s) :
    Subgroup G 
goal: Subgroup G

full_name: AddSubgroup.ofSub
code: /-- Construct a subgroup from a nonempty set that is closed under division. -/
@[to_additive "Construct a subgroup from a nonempty set that is closed under subtraction"]
def ofDiv (s : Set G) (hsn : s.Nonempty) (hs : ∀ᵉ (x ∈ s) (y ∈ s), x * y⁻¹ ∈ s) :
    Subgroup G 
goal: AddSubgroup G

full_name: Subgroup.mul
code: /-- A subgroup of a group inherits a multiplication. -/
@[to_additive "An `AddSubgroup` of an `AddGroup` inherits an addition."]
instance mul : Mul H 
goal: Mul ↥H

full_name: AddSubgroup.add
code: /-- A subgroup of a group inherits a multiplication. -/
@[to_additive "An `AddSubgroup` of an `AddGroup` inherits an addition."]
instance mul : Mul H 
goal: Add ↥H

full_name: Subgroup.one
code: /-- A subgroup of a group inherits a 1. -/
@[to_additive "An `AddSubgroup` of an `AddGroup` inherits a zero."]
instance one : One H 
goal: One ↥H

full_name: AddSubgroup.zero
code: /-- A subgroup of a group inherits a 1. -/
@[to_additive "An `AddSubgroup` of an `AddGroup` inherits a zero."]
instance one : One H 
goal: Zero ↥H

full_name: Subgroup.inv
code: /-- A subgroup of a group inherits an inverse. -/
@[to_additive "An `AddSubgroup` of an `AddGroup` inherits an inverse."]
instance inv : Inv H 
goal: Inv ↥H

full_name: AddSubgroup.neg
code: /-- A subgroup of a group inherits an inverse. -/
@[to_additive "An `AddSubgroup` of an `AddGroup` inherits an inverse."]
instance inv : Inv H 
goal: Neg ↥H

full_name: AddSubgroup.sub
code: /-- A subgroup of a group inherits a division -/
@[to_additive "An `AddSubgroup` of an `AddGroup` inherits a subtraction."]
instance div : Div H 
goal: Sub ↥H

full_name: Subgroup.div
code: /-- A subgroup of a group inherits a division -/
@[to_additive "An `AddSubgroup` of an `AddGroup` inherits a subtraction."]
instance div : Div H 
goal: Div ↥H

full_name: AddSubgroup.nsmul
code: /-- An `AddSubgroup` of an `AddGroup` inherits a natural scaling. -/
instance _root_.AddSubgroup.nsmul {G} [AddGroup G] {H : AddSubgroup G} : SMul ℕ H 
goal: SMul ℕ ↥H

full_name: Subgroup.npow
code: /-- A subgroup of a group inherits a natural power -/
@[to_additive existing]
protected instance npow : Pow H ℕ 
goal: Pow ↥H ℕ

full_name: AddSubgroup.zsmul
code: /-- An `AddSubgroup` of an `AddGroup` inherits an integer scaling. -/
instance _root_.AddSubgroup.zsmul {G} [AddGroup G] {H : AddSubgroup G} : SMul ℤ H 
goal: SMul ℤ ↥H

full_name: Subgroup.zpow
code: /-- A subgroup of a group inherits an integer power -/
@[to_additive existing]
instance zpow : Pow H ℤ 
goal: Pow ↥H ℤ

full_name: AddSubgroup.coe_add
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_mul (x y : H) : (↑(x * y) : G) = ↑x * ↑y 
goal: ↑(x + y) = ↑x + ↑y

full_name: Subgroup.coe_mul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_mul (x y : H) : (↑(x * y) : G) = ↑x * ↑y 
goal: ↑(x * y) = ↑x * ↑y

full_name: AddSubgroup.coe_zero
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_one : ((1 : H) : G) = 1 
goal: ↑0 = 0

full_name: Subgroup.coe_one
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_one : ((1 : H) : G) = 1 
goal: ↑1 = 1

full_name: AddSubgroup.coe_neg
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_inv (x : H) : ↑(x⁻¹ : H) = (x⁻¹ : G) 
goal: ↑(-x) = -↑x

full_name: Subgroup.coe_inv
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_inv (x : H) : ↑(x⁻¹ : H) = (x⁻¹ : G) 
goal: ↑x⁻¹ = (↑x)⁻¹

full_name: Subgroup.coe_div
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_div (x y : H) : (↑(x / y) : G) = ↑x / ↑y 
goal: ↑(x / y) = ↑x / ↑y

full_name: AddSubgroup.coe_sub
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_div (x y : H) : (↑(x / y) : G) = ↑x / ↑y 
goal: ↑(x - y) = ↑x - ↑y

full_name: Subgroup.coe_mk
code: @[to_additive (attr := norm_cast)]
theorem coe_mk (x : G) (hx : x ∈ H) : ((⟨x, hx⟩ : H) : G) = x 
goal: ↑⟨x, hx⟩ = x

full_name: AddSubgroup.coe_mk
code: @[to_additive (attr := norm_cast)]
theorem coe_mk (x : G) (hx : x ∈ H) : ((⟨x, hx⟩ : H) : G) = x 
goal: ↑⟨x, hx⟩ = x

full_name: AddSubgroup.coe_nsmul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_pow (x : H) (n : ℕ) : ((x ^ n : H) : G) = (x : G) ^ n 
goal: ↑(n • x) = n • ↑x

full_name: Subgroup.coe_pow
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_pow (x : H) (n : ℕ) : ((x ^ n : H) : G) = (x : G) ^ n 
goal: ↑(x ^ n) = ↑x ^ n

full_name: AddSubgroup.coe_zsmul
code: @[to_additive (attr := norm_cast)] -- Porting note (#10685): dsimp can prove this
theorem coe_zpow (x : H) (n : ℤ) : ((x ^ n : H) : G) = (x : G) ^ n 
goal: ↑(n • x) = n • ↑x

full_name: Subgroup.coe_zpow
code: @[to_additive (attr := norm_cast)] -- Porting note (#10685): dsimp can prove this
theorem coe_zpow (x : H) (n : ℤ) : ((x ^ n : H) : G) = (x : G) ^ n 
goal: ↑(x ^ n) = ↑x ^ n

full_name: Subgroup.mk_eq_one
code: @[to_additive] -- This can be proved by `Submonoid.mk_eq_one`
theorem mk_eq_one {g : G} {h} : (⟨g, h⟩ : H) = 1 ↔ g = 1 
goal: ⟨g, h⟩ = 1 ↔ g = 1

full_name: AddSubgroup.mk_eq_zero
code: @[to_additive] -- This can be proved by `Submonoid.mk_eq_one`
theorem mk_eq_one {g : G} {h} : (⟨g, h⟩ : H) = 1 ↔ g = 1 
goal: ⟨g, h⟩ = 0 ↔ g = 0

full_name: Subgroup.toGroup
code: /-- A subgroup of a group inherits a group structure. -/
@[to_additive "An `AddSubgroup` of an `AddGroup` inherits an `AddGroup` structure."]
instance toGroup {G : Type*} [Group G] (H : Subgroup G) : Group H 
goal: Group ↥H

full_name: AddSubgroup.toAddGroup
code: /-- A subgroup of a group inherits a group structure. -/
@[to_additive "An `AddSubgroup` of an `AddGroup` inherits an `AddGroup` structure."]
instance toGroup {G : Type*} [Group G] (H : Subgroup G) : Group H 
goal: AddGroup ↥H

full_name: AddSubgroup.toAddCommGroup
code: /-- A subgroup of a `CommGroup` is a `CommGroup`. -/
@[to_additive "An `AddSubgroup` of an `AddCommGroup` is an `AddCommGroup`."]
instance toCommGroup {G : Type*} [CommGroup G] (H : Subgroup G) : CommGroup H 
goal: AddCommGroup ↥H

full_name: Subgroup.toCommGroup
code: /-- A subgroup of a `CommGroup` is a `CommGroup`. -/
@[to_additive "An `AddSubgroup` of an `AddCommGroup` is an `AddCommGroup`."]
instance toCommGroup {G : Type*} [CommGroup G] (H : Subgroup G) : CommGroup H 
goal: CommGroup ↥H

full_name: AddSubgroup.subtype
code: /-- The natural group hom from a subgroup of group `G` to `G`. -/
@[to_additive "The natural group hom from an `AddSubgroup` of `AddGroup` `G` to `G`."]
protected def subtype : H →* G 
goal: ↥H →+ G

full_name: Subgroup.subtype
code: /-- The natural group hom from a subgroup of group `G` to `G`. -/
@[to_additive "The natural group hom from an `AddSubgroup` of `AddGroup` `G` to `G`."]
protected def subtype : H →* G 
goal: ↥H →* G

full_name: Subgroup.coeSubtype
code: @[to_additive (attr := simp)]
theorem coeSubtype : ⇑ H.subtype = ((↑) : H → G) 
goal: ⇑H.subtype = Subtype.val

full_name: AddSubgroup.coeSubtype
code: @[to_additive (attr := simp)]
theorem coeSubtype : ⇑ H.subtype = ((↑) : H → G) 
goal: ⇑H.subtype = Subtype.val

full_name: Subgroup.subtype_injective
code: @[to_additive]
theorem subtype_injective : Function.Injective (Subgroup.subtype H) 
goal: Function.Injective ⇑H.subtype

full_name: AddSubgroup.subtype_injective
code: @[to_additive]
theorem subtype_injective : Function.Injective (Subgroup.subtype H) 
goal: Function.Injective ⇑H.subtype

full_name: Subgroup.inclusion
code: /-- The inclusion homomorphism from a subgroup `H` contained in `K` to `K`. -/
@[to_additive "The inclusion homomorphism from an additive subgroup `H` contained in `K` to `K`."]
def inclusion {H K : Subgroup G} (h : H ≤ K) : H →* K 
goal: ↥H →* ↥K

full_name: AddSubgroup.inclusion
code: /-- The inclusion homomorphism from a subgroup `H` contained in `K` to `K`. -/
@[to_additive "The inclusion homomorphism from an additive subgroup `H` contained in `K` to `K`."]
def inclusion {H K : Subgroup G} (h : H ≤ K) : H →* K 
goal: ↥H →+ ↥K

full_name: AddSubgroup.coe_inclusion
code: @[to_additive (attr := simp)]
theorem coe_inclusion {H K : Subgroup G} {h : H ≤ K} (a : H) : (inclusion h a : G) = a 
goal: ↑((AddSubgroup.inclusion h) a) = ↑a

full_name: Subgroup.coe_inclusion
code: @[to_additive (attr := simp)]
theorem coe_inclusion {H K : Subgroup G} {h : H ≤ K} (a : H) : (inclusion h a : G) = a 
goal: ↑((Subgroup.inclusion h) a) = ↑a

full_name: AddSubgroup.inclusion_injective
code: @[to_additive]
theorem inclusion_injective {H K : Subgroup G} (h : H ≤ K) : Function.Injective <| inclusion h 
goal: Function.Injective ⇑(AddSubgroup.inclusion h)

full_name: Subgroup.inclusion_injective
code: @[to_additive]
theorem inclusion_injective {H K : Subgroup G} (h : H ≤ K) : Function.Injective <| inclusion h 
goal: Function.Injective ⇑(Subgroup.inclusion h)

full_name: AddSubgroup.subtype_comp_inclusion
code: @[to_additive (attr := simp)]
theorem subtype_comp_inclusion {H K : Subgroup G} (hH : H ≤ K) :
    K.subtype.comp (inclusion hH) = H.subtype 
goal: K.subtype.comp (AddSubgroup.inclusion hH) = H.subtype

full_name: Subgroup.subtype_comp_inclusion
code: @[to_additive (attr := simp)]
theorem subtype_comp_inclusion {H K : Subgroup G} (hH : H ≤ K) :
    K.subtype.comp (inclusion hH) = H.subtype 
goal: K.subtype.comp (Subgroup.inclusion hH) = H.subtype

full_name: Subgroup.instTop
code: /-- The subgroup `G` of the group `G`. -/
@[to_additive "The `AddSubgroup G` of the `AddGroup G`."]
instance : Top (Subgroup G) 
goal: Top (Subgroup G)

full_name: AddSubgroup.instTop
code: /-- The subgroup `G` of the group `G`. -/
@[to_additive "The `AddSubgroup G` of the `AddGroup G`."]
instance : Top (Subgroup G) 
goal: Top (AddSubgroup G)

full_name: Subgroup.topEquiv_symm_apply_coe
code: /-- The top subgroup is isomorphic to the group.

This is the group version of `Submonoid.topEquiv`. -/
@[to_additive (attr := simps!)
      "The top additive subgroup is isomorphic to the additive group.

      This is the additive group version of `AddSubmonoid.topEquiv`."]
def topEquiv : (⊤ : Subgroup G) ≃* G 
goal: ↑(Subgroup.topEquiv.symm x) = x

full_name: AddSubgroup.topEquiv_apply
code: /-- The top subgroup is isomorphic to the group.

This is the group version of `Submonoid.topEquiv`. -/
@[to_additive (attr := simps!)
      "The top additive subgroup is isomorphic to the additive group.

      This is the additive group version of `AddSubmonoid.topEquiv`."]
def topEquiv : (⊤ : Subgroup G) ≃* G 
goal: AddSubgroup.topEquiv x = ↑x

full_name: Subgroup.topEquiv_apply
code: /-- The top subgroup is isomorphic to the group.

This is the group version of `Submonoid.topEquiv`. -/
@[to_additive (attr := simps!)
      "The top additive subgroup is isomorphic to the additive group.

      This is the additive group version of `AddSubmonoid.topEquiv`."]
def topEquiv : (⊤ : Subgroup G) ≃* G 
goal: Subgroup.topEquiv x = ↑x

full_name: AddSubgroup.topEquiv
code: /-- The top subgroup is isomorphic to the group.

This is the group version of `Submonoid.topEquiv`. -/
@[to_additive (attr := simps!)
      "The top additive subgroup is isomorphic to the additive group.

      This is the additive group version of `AddSubmonoid.topEquiv`."]
def topEquiv : (⊤ : Subgroup G) ≃* G 
goal: ↥⊤ ≃+ G

full_name: AddSubgroup.topEquiv_symm_apply_coe
code: /-- The top subgroup is isomorphic to the group.

This is the group version of `Submonoid.topEquiv`. -/
@[to_additive (attr := simps!)
      "The top additive subgroup is isomorphic to the additive group.

      This is the additive group version of `AddSubmonoid.topEquiv`."]
def topEquiv : (⊤ : Subgroup G) ≃* G 
goal: ↑(AddSubgroup.topEquiv.symm x) = x

full_name: Subgroup.topEquiv
code: /-- The top subgroup is isomorphic to the group.

This is the group version of `Submonoid.topEquiv`. -/
@[to_additive (attr := simps!)
      "The top additive subgroup is isomorphic to the additive group.

      This is the additive group version of `AddSubmonoid.topEquiv`."]
def topEquiv : (⊤ : Subgroup G) ≃* G 
goal: ↥⊤ ≃* G

full_name: AddSubgroup.instBot
code: /-- The trivial subgroup `{1}` of a group `G`. -/
@[to_additive "The trivial `AddSubgroup` `{0}` of an `AddGroup` `G`."]
instance : Bot (Subgroup G) 
goal: Bot (AddSubgroup G)

full_name: Subgroup.instBot
code: /-- The trivial subgroup `{1}` of a group `G`. -/
@[to_additive "The trivial `AddSubgroup` `{0}` of an `AddGroup` `G`."]
instance : Bot (Subgroup G) 
goal: Bot (Subgroup G)

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

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

full_name: Subgroup.mem_bot
code: @[to_additive (attr := simp)]
theorem mem_bot {x : G} : x ∈ (⊥ : Subgroup G) ↔ x = 1 
goal: x ∈ ⊥ ↔ x = 1

full_name: AddSubgroup.mem_bot
code: @[to_additive (attr := simp)]
theorem mem_bot {x : G} : x ∈ (⊥ : Subgroup G) ↔ x = 1 
goal: x ∈ ⊥ ↔ x = 0

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

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

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

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

full_name: Subgroup.coe_bot
code: @[to_additive (attr := simp)]
theorem coe_bot : ((⊥ : Subgroup G) : Set G) = {1} 
goal: ↑⊥ = {1}

full_name: AddSubgroup.coe_bot
code: @[to_additive (attr := simp)]
theorem coe_bot : ((⊥ : Subgroup G) : Set G) = {1} 
goal: ↑⊥ = {0}

full_name: Subgroup.instUniqueSubtypeMemBot
code: @[to_additive]
instance : Unique (⊥ : Subgroup G) 
goal: Unique ↥⊥

full_name: AddSubgroup.instUniqueSubtypeMemBot
code: @[to_additive]
instance : Unique (⊥ : Subgroup G) 
goal: Unique ↥⊥

full_name: AddSubgroup.top_toAddSubmonoid
code: @[to_additive (attr := simp)]
theorem top_toSubmonoid : (⊤ : Subgroup G).toSubmonoid = ⊤ 
goal: ⊤.toAddSubmonoid = ⊤

full_name: Subgroup.top_toSubmonoid
code: @[to_additive (attr := simp)]
theorem top_toSubmonoid : (⊤ : Subgroup G).toSubmonoid = ⊤ 
goal: ⊤.toSubmonoid = ⊤

full_name: Subgroup.bot_toSubmonoid
code: @[to_additive (attr := simp)]
theorem bot_toSubmonoid : (⊥ : Subgroup G).toSubmonoid = ⊥ 
goal: ⊥.toSubmonoid = ⊥

full_name: AddSubgroup.bot_toAddSubmonoid
code: @[to_additive (attr := simp)]
theorem bot_toSubmonoid : (⊥ : Subgroup G).toSubmonoid = ⊥ 
goal: ⊥.toAddSubmonoid = ⊥

full_name: AddSubgroup.eq_bot_iff_forall
code: @[to_additive]
theorem eq_bot_iff_forall : H = ⊥ ↔ ∀ x ∈ H, x = (1 : G) 
goal: H = ⊥ ↔ ∀ x ∈ H, x = 0

full_name: Subgroup.eq_bot_iff_forall
code: @[to_additive]
theorem eq_bot_iff_forall : H = ⊥ ↔ ∀ x ∈ H, x = (1 : G) 
goal: H = ⊥ ↔ ∀ x ∈ H, x = 1

full_name: AddSubgroup.eq_bot_of_subsingleton
code: @[to_additive]
theorem eq_bot_of_subsingleton [Subsingleton H] : H = ⊥ 
goal: H = ⊥

full_name: Subgroup.eq_bot_of_subsingleton
code: @[to_additive]
theorem eq_bot_of_subsingleton [Subsingleton H] : H = ⊥ 
goal: H = ⊥

full_name: AddSubgroup.coe_eq_univ
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_eq_univ {H : Subgroup G} : (H : Set G) = Set.univ ↔ H = ⊤ 
goal: ↑H = Set.univ ↔ H = ⊤

full_name: Subgroup.coe_eq_univ
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_eq_univ {H : Subgroup G} : (H : Set G) = Set.univ ↔ H = ⊤ 
goal: ↑H = Set.univ ↔ H = ⊤

full_name: AddSubgroup.coe_eq_singleton
code: @[to_additive]
theorem coe_eq_singleton {H : Subgroup G} : (∃ g : G, (H : Set G) = {g}) ↔ H = ⊥ 
goal: (∃ g, ↑H = {g}) ↔ H = ⊥

full_name: Subgroup.coe_eq_singleton
code: @[to_additive]
theorem coe_eq_singleton {H : Subgroup G} : (∃ g : G, (H : Set G) = {g}) ↔ H = ⊥ 
goal: (∃ g, ↑H = {g}) ↔ H = ⊥

full_name: AddSubgroup.nontrivial_iff_exists_ne_zero
code: @[to_additive]
theorem nontrivial_iff_exists_ne_one (H : Subgroup G) : Nontrivial H ↔ ∃ x ∈ H, x ≠ (1 : G) 
goal: Nontrivial ↥H ↔ ∃ x ∈ H, x ≠ 0

full_name: Subgroup.nontrivial_iff_exists_ne_one
code: @[to_additive]
theorem nontrivial_iff_exists_ne_one (H : Subgroup G) : Nontrivial H ↔ ∃ x ∈ H, x ≠ (1 : G) 
goal: Nontrivial ↥H ↔ ∃ x ∈ H, x ≠ 1

full_name: AddSubgroup.exists_ne_zero_of_nontrivial
code: @[to_additive]
theorem exists_ne_one_of_nontrivial (H : Subgroup G) [Nontrivial H] :
    ∃ x ∈ H, x ≠ 1 
goal: ∃ x ∈ H, x ≠ 0

full_name: Subgroup.exists_ne_one_of_nontrivial
code: @[to_additive]
theorem exists_ne_one_of_nontrivial (H : Subgroup G) [Nontrivial H] :
    ∃ x ∈ H, x ≠ 1 
goal: ∃ x ∈ H, x ≠ 1

full_name: AddSubgroup.nontrivial_iff_ne_bot
code: @[to_additive]
theorem nontrivial_iff_ne_bot (H : Subgroup G) : Nontrivial H ↔ H ≠ ⊥ 
goal: Nontrivial ↥H ↔ H ≠ ⊥

full_name: Subgroup.nontrivial_iff_ne_bot
code: @[to_additive]
theorem nontrivial_iff_ne_bot (H : Subgroup G) : Nontrivial H ↔ H ≠ ⊥ 
goal: Nontrivial ↥H ↔ H ≠ ⊥

full_name: AddSubgroup.bot_or_nontrivial
code: /-- A subgroup is either the trivial subgroup or nontrivial. -/
@[to_additive "A subgroup is either the trivial subgroup or nontrivial."]
theorem bot_or_nontrivial (H : Subgroup G) : H = ⊥ ∨ Nontrivial H 
goal: H = ⊥ ∨ Nontrivial ↥H

full_name: Subgroup.bot_or_nontrivial
code: /-- A subgroup is either the trivial subgroup or nontrivial. -/
@[to_additive "A subgroup is either the trivial subgroup or nontrivial."]
theorem bot_or_nontrivial (H : Subgroup G) : H = ⊥ ∨ Nontrivial H 
goal: H = ⊥ ∨ Nontrivial ↥H

full_name: AddSubgroup.bot_or_exists_ne_zero
code: /-- A subgroup is either the trivial subgroup or contains a non-identity element. -/
@[to_additive "A subgroup is either the trivial subgroup or contains a nonzero element."]
theorem bot_or_exists_ne_one (H : Subgroup G) : H = ⊥ ∨ ∃ x ∈ H, x ≠ (1 : G) 
goal: H = ⊥ ∨ ∃ x ∈ H, x ≠ 0

full_name: Subgroup.bot_or_exists_ne_one
code: /-- A subgroup is either the trivial subgroup or contains a non-identity element. -/
@[to_additive "A subgroup is either the trivial subgroup or contains a nonzero element."]
theorem bot_or_exists_ne_one (H : Subgroup G) : H = ⊥ ∨ ∃ x ∈ H, x ≠ (1 : G) 
goal: H = ⊥ ∨ ∃ x ∈ H, x ≠ 1

full_name: Subgroup.ne_bot_iff_exists_ne_one
code: @[to_additive]
lemma ne_bot_iff_exists_ne_one {H : Subgroup G} : H ≠ ⊥ ↔ ∃ a : ↥H, a ≠ 1 
goal: H ≠ ⊥ ↔ ∃ a, a ≠ 1

full_name: AddSubgroup.ne_bot_iff_exists_ne_zero
code: @[to_additive]
lemma ne_bot_iff_exists_ne_one {H : Subgroup G} : H ≠ ⊥ ↔ ∃ a : ↥H, a ≠ 1 
goal: H ≠ ⊥ ↔ ∃ a, a ≠ 0

full_name: Subgroup.instInf
code: /-- The inf of two subgroups is their intersection. -/
@[to_additive "The inf of two `AddSubgroup`s is their intersection."]
instance : Inf (Subgroup G) 
goal: Inf (Subgroup G)

full_name: AddSubgroup.instInf
code: /-- The inf of two subgroups is their intersection. -/
@[to_additive "The inf of two `AddSubgroup`s is their intersection."]
instance : Inf (Subgroup G) 
goal: Inf (AddSubgroup G)

full_name: AddSubgroup.coe_inf
code: @[to_additive (attr := simp)]
theorem coe_inf (p p' : Subgroup G) : ((p ⊓ p' : Subgroup G) : Set G) = (p : Set G) ∩ p' 
goal: ↑(p ⊓ p') = ↑p ∩ ↑p'

full_name: Subgroup.coe_inf
code: @[to_additive (attr := simp)]
theorem coe_inf (p p' : Subgroup G) : ((p ⊓ p' : Subgroup G) : Set G) = (p : Set G) ∩ p' 
goal: ↑(p ⊓ p') = ↑p ∩ ↑p'

full_name: AddSubgroup.mem_inf
code: @[to_additive (attr := simp)]
theorem mem_inf {p p' : Subgroup G} {x : G} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p' 
goal: x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p'

full_name: Subgroup.mem_inf
code: @[to_additive (attr := simp)]
theorem mem_inf {p p' : Subgroup G} {x : G} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p' 
goal: x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p'

full_name: AddSubgroup.instInfSet
code: @[to_additive]
instance : InfSet (Subgroup G) 
goal: InfSet (AddSubgroup G)

full_name: Subgroup.instInfSet
code: @[to_additive]
instance : InfSet (Subgroup G) 
goal: InfSet (Subgroup G)

full_name: Subgroup.coe_sInf
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_sInf (H : Set (Subgroup G)) : ((sInf H : Subgroup G) : Set G) = ⋂ s ∈ H, ↑s 
goal: ↑(sInf H) = ⋂ s ∈ H, ↑s

full_name: AddSubgroup.coe_sInf
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_sInf (H : Set (Subgroup G)) : ((sInf H : Subgroup G) : Set G) = ⋂ s ∈ H, ↑s 
goal: ↑(sInf H) = ⋂ s ∈ H, ↑s

full_name: Subgroup.mem_sInf
code: @[to_additive (attr := simp)]
theorem mem_sInf {S : Set (Subgroup G)} {x : G} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p 
goal: x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p

full_name: AddSubgroup.mem_sInf
code: @[to_additive (attr := simp)]
theorem mem_sInf {S : Set (Subgroup G)} {x : G} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p 
goal: x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p

full_name: Subgroup.mem_iInf
code: @[to_additive]
theorem mem_iInf {ι : Sort*} {S : ι → Subgroup G} {x : G} : (x ∈ ⨅ i, S i) ↔ ∀ i, x ∈ S i 
goal: x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i

full_name: AddSubgroup.mem_iInf
code: @[to_additive]
theorem mem_iInf {ι : Sort*} {S : ι → Subgroup G} {x : G} : (x ∈ ⨅ i, S i) ↔ ∀ i, x ∈ S i 
goal: x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i

full_name: AddSubgroup.coe_iInf
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_iInf {ι : Sort*} {S : ι → Subgroup G} : (↑(⨅ i, S i) : Set G) = ⋂ i, S i 
goal: ↑(⨅ i, S i) = ⋂ i, ↑(S i)

full_name: Subgroup.coe_iInf
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_iInf {ι : Sort*} {S : ι → Subgroup G} : (↑(⨅ i, S i) : Set G) = ⋂ i, S i 
goal: ↑(⨅ i, S i) = ⋂ i, ↑(S i)

full_name: AddSubgroup.instCompleteLattice
code: /-- Subgroups of a group form a complete lattice. -/
@[to_additive "The `AddSubgroup`s of an `AddGroup` form a complete lattice."]
instance : CompleteLattice (Subgroup G) 
goal: CompleteLattice (AddSubgroup G)

full_name: Subgroup.instCompleteLattice
code: /-- Subgroups of a group form a complete lattice. -/
@[to_additive "The `AddSubgroup`s of an `AddGroup` form a complete lattice."]
instance : CompleteLattice (Subgroup G) 
goal: CompleteLattice (Subgroup G)

full_name: Subgroup.mem_sup_left
code: @[to_additive]
theorem mem_sup_left {S T : Subgroup G} : ∀ {x : G}, x ∈ S → x ∈ S ⊔ T 
goal: x ∈ S → x ∈ S ⊔ T

full_name: AddSubgroup.mem_sup_left
code: @[to_additive]
theorem mem_sup_left {S T : Subgroup G} : ∀ {x : G}, x ∈ S → x ∈ S ⊔ T 
goal: x ∈ S → x ∈ S ⊔ T

full_name: AddSubgroup.mem_sup_right
code: @[to_additive]
theorem mem_sup_right {S T : Subgroup G} : ∀ {x : G}, x ∈ T → x ∈ S ⊔ T 
goal: x ∈ T → x ∈ S ⊔ T

full_name: Subgroup.mem_sup_right
code: @[to_additive]
theorem mem_sup_right {S T : Subgroup G} : ∀ {x : G}, x ∈ T → x ∈ S ⊔ T 
goal: x ∈ T → x ∈ S ⊔ T

full_name: AddSubgroup.add_mem_sup
code: @[to_additive]
theorem mul_mem_sup {S T : Subgroup G} {x y : G} (hx : x ∈ S) (hy : y ∈ T) : x * y ∈ S ⊔ T 
goal: x + y ∈ S ⊔ T

full_name: Subgroup.mul_mem_sup
code: @[to_additive]
theorem mul_mem_sup {S T : Subgroup G} {x y : G} (hx : x ∈ S) (hy : y ∈ T) : x * y ∈ S ⊔ T 
goal: x * y ∈ S ⊔ T

full_name: AddSubgroup.mem_iSup_of_mem
code: @[to_additive]
theorem mem_iSup_of_mem {ι : Sort*} {S : ι → Subgroup G} (i : ι) :
    ∀ {x : G}, x ∈ S i → x ∈ iSup S 
goal: x ∈ S i → x ∈ iSup S

full_name: Subgroup.mem_iSup_of_mem
code: @[to_additive]
theorem mem_iSup_of_mem {ι : Sort*} {S : ι → Subgroup G} (i : ι) :
    ∀ {x : G}, x ∈ S i → x ∈ iSup S 
goal: x ∈ S i → x ∈ iSup S

full_name: AddSubgroup.mem_sSup_of_mem
code: @[to_additive]
theorem mem_sSup_of_mem {S : Set (Subgroup G)} {s : Subgroup G} (hs : s ∈ S) :
    ∀ {x : G}, x ∈ s → x ∈ sSup S 
goal: x ∈ s → x ∈ sSup S

full_name: Subgroup.mem_sSup_of_mem
code: @[to_additive]
theorem mem_sSup_of_mem {S : Set (Subgroup G)} {s : Subgroup G} (hs : s ∈ S) :
    ∀ {x : G}, x ∈ s → x ∈ sSup S 
goal: x ∈ s → x ∈ sSup S

full_name: Subgroup.subsingleton_iff
code: @[to_additive (attr := simp)]
theorem subsingleton_iff : Subsingleton (Subgroup G) ↔ Subsingleton G 
goal: Subsingleton (Subgroup G) ↔ Subsingleton G

full_name: AddSubgroup.subsingleton_iff
code: @[to_additive (attr := simp)]
theorem subsingleton_iff : Subsingleton (Subgroup G) ↔ Subsingleton G 
goal: Subsingleton (AddSubgroup G) ↔ Subsingleton G

full_name: Subgroup.nontrivial_iff
code: @[to_additive (attr := simp)]
theorem nontrivial_iff : Nontrivial (Subgroup G) ↔ Nontrivial G 
goal: Nontrivial (Subgroup G) ↔ Nontrivial G

full_name: AddSubgroup.nontrivial_iff
code: @[to_additive (attr := simp)]
theorem nontrivial_iff : Nontrivial (Subgroup G) ↔ Nontrivial G 
goal: Nontrivial (AddSubgroup G) ↔ Nontrivial G

full_name: AddSubgroup.instUniqueOfSubsingleton
code: @[to_additive]
instance [Subsingleton G] : Unique (Subgroup G) 
goal: Unique (AddSubgroup G)

full_name: Subgroup.instUniqueOfSubsingleton
code: @[to_additive]
instance [Subsingleton G] : Unique (Subgroup G) 
goal: Unique (Subgroup G)

full_name: AddSubgroup.instNontrivial
code: @[to_additive]
instance [Nontrivial G] : Nontrivial (Subgroup G) 
goal: Nontrivial (AddSubgroup G)

full_name: Subgroup.instNontrivial
code: @[to_additive]
instance [Nontrivial G] : Nontrivial (Subgroup G) 
goal: Nontrivial (Subgroup G)

full_name: Subgroup.eq_top_iff'
code: @[to_additive]
theorem eq_top_iff' : H = ⊤ ↔ ∀ x : G, x ∈ H 
goal: H = ⊤ ↔ ∀ (x : G), x ∈ H

full_name: AddSubgroup.eq_top_iff'
code: @[to_additive]
theorem eq_top_iff' : H = ⊤ ↔ ∀ x : G, x ∈ H 
goal: H = ⊤ ↔ ∀ (x : G), x ∈ H

full_name: AddSubgroup.closure
code: /-- The `Subgroup` generated by a set. -/
@[to_additive "The `AddSubgroup` generated by a set"]
def closure (k : Set G) : Subgroup G 
goal: AddSubgroup G

full_name: Subgroup.closure
code: /-- The `Subgroup` generated by a set. -/
@[to_additive "The `AddSubgroup` generated by a set"]
def closure (k : Set G) : Subgroup G 
goal: Subgroup G

full_name: Subgroup.mem_closure
code: @[to_additive]
theorem mem_closure {x : G} : x ∈ closure k ↔ ∀ K : Subgroup G, k ⊆ K → x ∈ K 
goal: x ∈ Subgroup.closure k ↔ ∀ (K : Subgroup G), k ⊆ ↑K → x ∈ K

full_name: AddSubgroup.mem_closure
code: @[to_additive]
theorem mem_closure {x : G} : x ∈ closure k ↔ ∀ K : Subgroup G, k ⊆ K → x ∈ K 
goal: x ∈ AddSubgroup.closure k ↔ ∀ (K : AddSubgroup G), k ⊆ ↑K → x ∈ K

full_name: AddSubgroup.subset_closure
code: /-- The subgroup generated by a set includes the set. -/
@[to_additive (attr := simp, aesop safe 20 apply (rule_sets := [SetLike]))
  "The `AddSubgroup` generated by a set includes the set."]
theorem subset_closure : k ⊆ closure k 
goal: k ⊆ ↑(AddSubgroup.closure k)

full_name: Subgroup.subset_closure
code: /-- The subgroup generated by a set includes the set. -/
@[to_additive (attr := simp, aesop safe 20 apply (rule_sets := [SetLike]))
  "The `AddSubgroup` generated by a set includes the set."]
theorem subset_closure : k ⊆ closure k 
goal: k ⊆ ↑(Subgroup.closure k)

full_name: Subgroup.not_mem_of_not_mem_closure
code: @[to_additive]
theorem not_mem_of_not_mem_closure {P : G} (hP : P ∉ closure k) : P ∉ k 
goal: P ∉ k

full_name: AddSubgroup.not_mem_of_not_mem_closure
code: @[to_additive]
theorem not_mem_of_not_mem_closure {P : G} (hP : P ∉ closure k) : P ∉ k 
goal: P ∉ k

full_name: Subgroup.closure_le
code: /-- A subgroup `K` includes `closure k` if and only if it includes `k`. -/
@[to_additive (attr := simp)
  "An additive subgroup `K` includes `closure k` if and only if it includes `k`"]
theorem closure_le : closure k ≤ K ↔ k ⊆ K 
goal: Subgroup.closure k ≤ K ↔ k ⊆ ↑K

full_name: AddSubgroup.closure_le
code: /-- A subgroup `K` includes `closure k` if and only if it includes `k`. -/
@[to_additive (attr := simp)
  "An additive subgroup `K` includes `closure k` if and only if it includes `k`"]
theorem closure_le : closure k ≤ K ↔ k ⊆ K 
goal: AddSubgroup.closure k ≤ K ↔ k ⊆ ↑K

full_name: Subgroup.closure_eq_of_le
code: @[to_additive]
theorem closure_eq_of_le (h₁ : k ⊆ K) (h₂ : K ≤ closure k) : closure k = K 
goal: Subgroup.closure k = K

full_name: AddSubgroup.closure_eq_of_le
code: @[to_additive]
theorem closure_eq_of_le (h₁ : k ⊆ K) (h₂ : K ≤ closure k) : closure k = K 
goal: AddSubgroup.closure k = K

full_name: Subgroup.closure_induction
code: /-- An induction principle for closure membership. If `p` holds for `1` and all elements of `k`, and
is preserved under multiplication and inverse, then `p` holds for all elements of the closure
of `k`. -/
@[to_additive (attr := elab_as_elim)
      "An induction principle for additive closure membership. If `p`
      holds for `0` and all elements of `k`, and is preserved under addition and inverses, then `p`
      holds for all elements of the additive closure of `k`."]
theorem closure_induction {p : G → Prop} {x} (h : x ∈ closure k) (mem : ∀ x ∈ k, p x) (one : p 1)
    (mul : ∀ x y, p x → p y → p (x * y)) (inv : ∀ x, p x → p x⁻¹) : p x 
goal: p x

full_name: AddSubgroup.closure_induction
code: /-- An induction principle for closure membership. If `p` holds for `1` and all elements of `k`, and
is preserved under multiplication and inverse, then `p` holds for all elements of the closure
of `k`. -/
@[to_additive (attr := elab_as_elim)
      "An induction principle for additive closure membership. If `p`
      holds for `0` and all elements of `k`, and is preserved under addition and inverses, then `p`
      holds for all elements of the additive closure of `k`."]
theorem closure_induction {p : G → Prop} {x} (h : x ∈ closure k) (mem : ∀ x ∈ k, p x) (one : p 1)
    (mul : ∀ x y, p x → p y → p (x * y)) (inv : ∀ x, p x → p x⁻¹) : p x 
goal: p x

full_name: Subgroup.closure_induction'
code: /-- A dependent version of `Subgroup.closure_induction`.  -/
@[to_additive (attr := elab_as_elim) "A dependent version of `AddSubgroup.closure_induction`. "]
theorem closure_induction' {p : ∀ x, x ∈ closure k → Prop}
    (mem : ∀ (x) (h : x ∈ k), p x (subset_closure h)) (one : p 1 (one_mem _))
    (mul : ∀ x hx y hy, p x hx → p y hy → p (x * y) (mul_mem hx hy))
    (inv : ∀ x hx, p x hx → p x⁻¹ (inv_mem hx)) {x} (hx : x ∈ closure k) : p x hx 
goal: p x hx

full_name: AddSubgroup.closure_induction'
code: /-- A dependent version of `Subgroup.closure_induction`.  -/
@[to_additive (attr := elab_as_elim) "A dependent version of `AddSubgroup.closure_induction`. "]
theorem closure_induction' {p : ∀ x, x ∈ closure k → Prop}
    (mem : ∀ (x) (h : x ∈ k), p x (subset_closure h)) (one : p 1 (one_mem _))
    (mul : ∀ x hx y hy, p x hx → p y hy → p (x * y) (mul_mem hx hy))
    (inv : ∀ x hx, p x hx → p x⁻¹ (inv_mem hx)) {x} (hx : x ∈ closure k) : p x hx 
goal: p x hx

full_name: Subgroup.closure_induction₂
code: /-- An induction principle for closure membership for predicates with two arguments. -/
@[to_additive (attr := elab_as_elim)
      "An induction principle for additive closure membership, for
      predicates with two arguments."]
theorem closure_induction₂ {p : G → G → Prop} {x} {y : G} (hx : x ∈ closure k) (hy : y ∈ closure k)
    (Hk : ∀ x ∈ k, ∀ y ∈ k, p x y) (H1_left : ∀ x, p 1 x) (H1_right : ∀ x, p x 1)
    (Hmul_left : ∀ x₁ x₂ y, p x₁ y → p x₂ y → p (x₁ * x₂) y)
    (Hmul_right : ∀ x y₁ y₂, p x y₁ → p x y₂ → p x (y₁ * y₂)) (Hinv_left : ∀ x y, p x y → p x⁻¹ y)
    (Hinv_right : ∀ x y, p x y → p x y⁻¹) : p x y 
goal: p x y

full_name: AddSubgroup.closure_induction₂
code: /-- An induction principle for closure membership for predicates with two arguments. -/
@[to_additive (attr := elab_as_elim)
      "An induction principle for additive closure membership, for
      predicates with two arguments."]
theorem closure_induction₂ {p : G → G → Prop} {x} {y : G} (hx : x ∈ closure k) (hy : y ∈ closure k)
    (Hk : ∀ x ∈ k, ∀ y ∈ k, p x y) (H1_left : ∀ x, p 1 x) (H1_right : ∀ x, p x 1)
    (Hmul_left : ∀ x₁ x₂ y, p x₁ y → p x₂ y → p (x₁ * x₂) y)
    (Hmul_right : ∀ x y₁ y₂, p x y₁ → p x y₂ → p x (y₁ * y₂)) (Hinv_left : ∀ x y, p x y → p x⁻¹ y)
    (Hinv_right : ∀ x y, p x y → p x y⁻¹) : p x y 
goal: p x y

full_name: Subgroup.closure_closure_coe_preimage
code: @[to_additive (attr := simp)]
theorem closure_closure_coe_preimage {k : Set G} : closure (((↑) : closure k → G) ⁻¹' k) = ⊤ 
goal: Subgroup.closure (Subtype.val ⁻¹' k) = ⊤

full_name: AddSubgroup.closure_closure_coe_preimage
code: @[to_additive (attr := simp)]
theorem closure_closure_coe_preimage {k : Set G} : closure (((↑) : closure k → G) ⁻¹' k) = ⊤ 
goal: AddSubgroup.closure (Subtype.val ⁻¹' k) = ⊤

full_name: AddSubgroup.closureAddCommGroupOfComm
code: /-- If all the elements of a set `s` commute, then `closure s` is a commutative group. -/
@[to_additive
      "If all the elements of a set `s` commute, then `closure s` is an additive
      commutative group."]
def closureCommGroupOfComm {k : Set G} (hcomm : ∀ x ∈ k, ∀ y ∈ k, x * y = y * x) :
    CommGroup (closure k) 
goal: AddCommGroup ↥(AddSubgroup.closure k)

full_name: Subgroup.closureCommGroupOfComm
code: /-- If all the elements of a set `s` commute, then `closure s` is a commutative group. -/
@[to_additive
      "If all the elements of a set `s` commute, then `closure s` is an additive
      commutative group."]
def closureCommGroupOfComm {k : Set G} (hcomm : ∀ x ∈ k, ∀ y ∈ k, x * y = y * x) :
    CommGroup (closure k) 
goal: CommGroup ↥(Subgroup.closure k)

full_name: Subgroup.gi
code: /-- `closure` forms a Galois insertion with the coercion to set. -/
@[to_additive "`closure` forms a Galois insertion with the coercion to set."]
protected def gi : GaloisInsertion (@closure G _) (↑) 
goal: GaloisInsertion Subgroup.closure SetLike.coe

full_name: AddSubgroup.gi
code: /-- `closure` forms a Galois insertion with the coercion to set. -/
@[to_additive "`closure` forms a Galois insertion with the coercion to set."]
protected def gi : GaloisInsertion (@closure G _) (↑) 
goal: GaloisInsertion AddSubgroup.closure SetLike.coe

full_name: Subgroup.closure_mono
code: /-- Subgroup closure of a set is monotone in its argument: if `h ⊆ k`,
then `closure h ≤ closure k`. -/
@[to_additive
      "Additive subgroup closure of a set is monotone in its argument: if `h ⊆ k`,
      then `closure h ≤ closure k`"]
theorem closure_mono ⦃h k : Set G⦄ (h' : h ⊆ k) : closure h ≤ closure k 
goal: Subgroup.closure h ≤ Subgroup.closure k

full_name: AddSubgroup.closure_mono
code: /-- Subgroup closure of a set is monotone in its argument: if `h ⊆ k`,
then `closure h ≤ closure k`. -/
@[to_additive
      "Additive subgroup closure of a set is monotone in its argument: if `h ⊆ k`,
      then `closure h ≤ closure k`"]
theorem closure_mono ⦃h k : Set G⦄ (h' : h ⊆ k) : closure h ≤ closure k 
goal: AddSubgroup.closure h ≤ AddSubgroup.closure k

full_name: Subgroup.closure_eq
code: /-- Closure of a subgroup `K` equals `K`. -/
@[to_additive (attr := simp) "Additive closure of an additive subgroup `K` equals `K`"]
theorem closure_eq : closure (K : Set G) = K 
goal: Subgroup.closure ↑K = K

full_name: AddSubgroup.closure_eq
code: /-- Closure of a subgroup `K` equals `K`. -/
@[to_additive (attr := simp) "Additive closure of an additive subgroup `K` equals `K`"]
theorem closure_eq : closure (K : Set G) = K 
goal: AddSubgroup.closure ↑K = K

full_name: AddSubgroup.closure_empty
code: @[to_additive (attr := simp)]
theorem closure_empty : closure (∅ : Set G) = ⊥ 
goal: AddSubgroup.closure ∅ = ⊥

full_name: Subgroup.closure_empty
code: @[to_additive (attr := simp)]
theorem closure_empty : closure (∅ : Set G) = ⊥ 
goal: Subgroup.closure ∅ = ⊥

full_name: AddSubgroup.closure_univ
code: @[to_additive (attr := simp)]
theorem closure_univ : closure (univ : Set G) = ⊤ 
goal: AddSubgroup.closure Set.univ = ⊤

full_name: Subgroup.closure_univ
code: @[to_additive (attr := simp)]
theorem closure_univ : closure (univ : Set G) = ⊤ 
goal: Subgroup.closure Set.univ = ⊤

full_name: Subgroup.closure_union
code: @[to_additive]
theorem closure_union (s t : Set G) : closure (s ∪ t) = closure s ⊔ closure t 
goal: Subgroup.closure (s ∪ t) = Subgroup.closure s ⊔ Subgroup.closure t

full_name: AddSubgroup.closure_union
code: @[to_additive]
theorem closure_union (s t : Set G) : closure (s ∪ t) = closure s ⊔ closure t 
goal: AddSubgroup.closure (s ∪ t) = AddSubgroup.closure s ⊔ AddSubgroup.closure t

full_name: AddSubgroup.sup_eq_closure
code: @[to_additive]
theorem sup_eq_closure (H H' : Subgroup G) : H ⊔ H' = closure ((H : Set G) ∪ (H' : Set G)) 
goal: H ⊔ H' = AddSubgroup.closure (↑H ∪ ↑H')

full_name: Subgroup.sup_eq_closure
code: @[to_additive]
theorem sup_eq_closure (H H' : Subgroup G) : H ⊔ H' = closure ((H : Set G) ∪ (H' : Set G)) 
goal: H ⊔ H' = Subgroup.closure (↑H ∪ ↑H')

full_name: Subgroup.closure_iUnion
code: @[to_additive]
theorem closure_iUnion {ι} (s : ι → Set G) : closure (⋃ i, s i) = ⨆ i, closure (s i) 
goal: Subgroup.closure (⋃ i, s i) = ⨆ i, Subgroup.closure (s i)

full_name: AddSubgroup.closure_iUnion
code: @[to_additive]
theorem closure_iUnion {ι} (s : ι → Set G) : closure (⋃ i, s i) = ⨆ i, closure (s i) 
goal: AddSubgroup.closure (⋃ i, s i) = ⨆ i, AddSubgroup.closure (s i)

full_name: Subgroup.closure_eq_bot_iff
code: @[to_additive (attr := simp)]
theorem closure_eq_bot_iff : closure k = ⊥ ↔ k ⊆ {1} 
goal: Subgroup.closure k = ⊥ ↔ k ⊆ {1}

full_name: AddSubgroup.closure_eq_bot_iff
code: @[to_additive (attr := simp)]
theorem closure_eq_bot_iff : closure k = ⊥ ↔ k ⊆ {1} 
goal: AddSubgroup.closure k = ⊥ ↔ k ⊆ {0}

full_name: AddSubgroup.iSup_eq_closure
code: @[to_additive]
theorem iSup_eq_closure {ι : Sort*} (p : ι → Subgroup G) :
    ⨆ i, p i = closure (⋃ i, (p i : Set G)) 
goal: ⨆ i, p i = AddSubgroup.closure (⋃ i, ↑(p i))

full_name: Subgroup.iSup_eq_closure
code: @[to_additive]
theorem iSup_eq_closure {ι : Sort*} (p : ι → Subgroup G) :
    ⨆ i, p i = closure (⋃ i, (p i : Set G)) 
goal: ⨆ i, p i = Subgroup.closure (⋃ i, ↑(p i))

full_name: Subgroup.mem_closure_singleton
code: /-- The subgroup generated by an element of a group equals the set of integer number powers of
    the element. -/
@[to_additive
      "The `AddSubgroup` generated by an element of an `AddGroup` equals the set of
      natural number multiples of the element."]
theorem mem_closure_singleton {x y : G} : y ∈ closure ({x} : Set G) ↔ ∃ n : ℤ, x ^ n = y 
goal: y ∈ Subgroup.closure {x} ↔ ∃ n, x ^ n = y

full_name: AddSubgroup.mem_closure_singleton
code: /-- The subgroup generated by an element of a group equals the set of integer number powers of
    the element. -/
@[to_additive
      "The `AddSubgroup` generated by an element of an `AddGroup` equals the set of
      natural number multiples of the element."]
theorem mem_closure_singleton {x y : G} : y ∈ closure ({x} : Set G) ↔ ∃ n : ℤ, x ^ n = y 
goal: y ∈ AddSubgroup.closure {x} ↔ ∃ n, n • x = y

full_name: Subgroup.closure_singleton_one
code: @[to_additive]
theorem closure_singleton_one : closure ({1} : Set G) = ⊥ 
goal: Subgroup.closure {1} = ⊥

full_name: AddSubgroup.closure_singleton_zero
code: @[to_additive]
theorem closure_singleton_one : closure ({1} : Set G) = ⊥ 
goal: AddSubgroup.closure {0} = ⊥

full_name: AddSubgroup.le_closure_toAddSubmonoid
code: @[to_additive]
theorem le_closure_toSubmonoid (S : Set G) : Submonoid.closure S ≤ (closure S).toSubmonoid 
goal: AddSubmonoid.closure S ≤ (AddSubgroup.closure S).toAddSubmonoid

full_name: Subgroup.le_closure_toSubmonoid
code: @[to_additive]
theorem le_closure_toSubmonoid (S : Set G) : Submonoid.closure S ≤ (closure S).toSubmonoid 
goal: Submonoid.closure S ≤ (Subgroup.closure S).toSubmonoid

full_name: Subgroup.closure_eq_top_of_mclosure_eq_top
code: @[to_additive]
theorem closure_eq_top_of_mclosure_eq_top {S : Set G} (h : Submonoid.closure S = ⊤) :
    closure S = ⊤ 
goal: Subgroup.closure S = ⊤

full_name: AddSubgroup.closure_eq_top_of_mclosure_eq_top
code: @[to_additive]
theorem closure_eq_top_of_mclosure_eq_top {S : Set G} (h : Submonoid.closure S = ⊤) :
    closure S = ⊤ 
goal: AddSubgroup.closure S = ⊤

full_name: AddSubgroup.mem_iSup_of_directed
code: @[to_additive]
theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {K : ι → Subgroup G} (hK : Directed (· ≤ ·) K)
    {x : G} : x ∈ (iSup K : Subgroup G) ↔ ∃ i, x ∈ K i 
goal: x ∈ iSup K ↔ ∃ i, x ∈ K i

full_name: Subgroup.mem_iSup_of_directed
code: @[to_additive]
theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {K : ι → Subgroup G} (hK : Directed (· ≤ ·) K)
    {x : G} : x ∈ (iSup K : Subgroup G) ↔ ∃ i, x ∈ K i 
goal: x ∈ iSup K ↔ ∃ i, x ∈ K i

full_name: AddSubgroup.coe_iSup_of_directed
code: @[to_additive]
theorem coe_iSup_of_directed {ι} [Nonempty ι] {S : ι → Subgroup G} (hS : Directed (· ≤ ·) S) :
    ((⨆ i, S i : Subgroup G) : Set G) = ⋃ i, S i 
goal: ↑(⨆ i, S i) = ⋃ i, ↑(S i)

full_name: Subgroup.coe_iSup_of_directed
code: @[to_additive]
theorem coe_iSup_of_directed {ι} [Nonempty ι] {S : ι → Subgroup G} (hS : Directed (· ≤ ·) S) :
    ((⨆ i, S i : Subgroup G) : Set G) = ⋃ i, S i 
goal: ↑(⨆ i, S i) = ⋃ i, ↑(S i)

full_name: AddSubgroup.mem_sSup_of_directedOn
code: @[to_additive]
theorem mem_sSup_of_directedOn {K : Set (Subgroup G)} (Kne : K.Nonempty) (hK : DirectedOn (· ≤ ·) K)
    {x : G} : x ∈ sSup K ↔ ∃ s ∈ K, x ∈ s 
goal: x ∈ sSup K ↔ ∃ s ∈ K, x ∈ s

full_name: Subgroup.mem_sSup_of_directedOn
code: @[to_additive]
theorem mem_sSup_of_directedOn {K : Set (Subgroup G)} (Kne : K.Nonempty) (hK : DirectedOn (· ≤ ·) K)
    {x : G} : x ∈ sSup K ↔ ∃ s ∈ K, x ∈ s 
goal: x ∈ sSup K ↔ ∃ s ∈ K, x ∈ s

full_name: Subgroup.comap
code: /-- The preimage of a subgroup along a monoid homomorphism is a subgroup. -/
@[to_additive
      "The preimage of an `AddSubgroup` along an `AddMonoid` homomorphism
      is an `AddSubgroup`."]
def comap {N : Type*} [Group N] (f : G →* N) (H : Subgroup N) : Subgroup G 
goal: Subgroup G

full_name: AddSubgroup.comap
code: /-- The preimage of a subgroup along a monoid homomorphism is a subgroup. -/
@[to_additive
      "The preimage of an `AddSubgroup` along an `AddMonoid` homomorphism
      is an `AddSubgroup`."]
def comap {N : Type*} [Group N] (f : G →* N) (H : Subgroup N) : Subgroup G 
goal: AddSubgroup G

full_name: Subgroup.coe_comap
code: @[to_additive (attr := simp)]
theorem coe_comap (K : Subgroup N) (f : G →* N) : (K.comap f : Set G) = f ⁻¹' K 
goal: ↑(Subgroup.comap f K) = ⇑f ⁻¹' ↑K

full_name: AddSubgroup.coe_comap
code: @[to_additive (attr := simp)]
theorem coe_comap (K : Subgroup N) (f : G →* N) : (K.comap f : Set G) = f ⁻¹' K 
goal: ↑(AddSubgroup.comap f K) = ⇑f ⁻¹' ↑K

full_name: Subgroup.toAddSubgroup_comap
code: @[simp]
theorem toAddSubgroup_comap {G₂ : Type*} [Group G₂] (f : G →* G₂) (s : Subgroup G₂) :
    s.toAddSubgroup.comap (MonoidHom.toAdditive f) = Subgroup.toAddSubgroup (s.comap f) 
goal: AddSubgroup.comap (MonoidHom.toAdditive f) (Subgroup.toAddSubgroup s) = Subgroup.toAddSubgroup (Subgroup.comap f s)

full_name: AddSubgroup.toSubgroup_comap
code: @[simp]
theorem _root_.AddSubgroup.toSubgroup_comap {A A₂ : Type*} [AddGroup A] [AddGroup A₂]
    (f : A →+ A₂)  (s : AddSubgroup A₂) :
    s.toSubgroup.comap (AddMonoidHom.toMultiplicative f) = AddSubgroup.toSubgroup (s.comap f) 
goal: Subgroup.comap (AddMonoidHom.toMultiplicative f) (AddSubgroup.toSubgroup s) =
  AddSubgroup.toSubgroup (AddSubgroup.comap f s)

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

full_name: AddSubgroup.mem_comap
code: @[to_additive (attr := simp)]
theorem mem_comap {K : Subgroup N} {f : G →* N} {x : G} : x ∈ K.comap f ↔ f x ∈ K 
goal: x ∈ AddSubgroup.comap f K ↔ f x ∈ K

full_name: AddSubgroup.comap_mono
code: @[to_additive]
theorem comap_mono {f : G →* N} {K K' : Subgroup N} : K ≤ K' → comap f K ≤ comap f K' 
goal: K ≤ K' → AddSubgroup.comap f K ≤ AddSubgroup.comap f K'

full_name: Subgroup.comap_mono
code: @[to_additive]
theorem comap_mono {f : G →* N} {K K' : Subgroup N} : K ≤ K' → comap f K ≤ comap f K' 
goal: K ≤ K' → Subgroup.comap f K ≤ Subgroup.comap f K'

full_name: Subgroup.comap_comap
code: @[to_additive]
theorem comap_comap (K : Subgroup P) (g : N →* P) (f : G →* N) :
    (K.comap g).comap f = K.comap (g.comp f) 
goal: Subgroup.comap f (Subgroup.comap g K) = Subgroup.comap (g.comp f) K

full_name: AddSubgroup.comap_comap
code: @[to_additive]
theorem comap_comap (K : Subgroup P) (g : N →* P) (f : G →* N) :
    (K.comap g).comap f = K.comap (g.comp f) 
goal: AddSubgroup.comap f (AddSubgroup.comap g K) = AddSubgroup.comap (g.comp f) K

full_name: Subgroup.comap_id
code: @[to_additive (attr := simp)]
theorem comap_id (K : Subgroup N) : K.comap (MonoidHom.id _) = K 
goal: Subgroup.comap (MonoidHom.id N) K = K

full_name: AddSubgroup.comap_id
code: @[to_additive (attr := simp)]
theorem comap_id (K : Subgroup N) : K.comap (MonoidHom.id _) = K 
goal: AddSubgroup.comap (AddMonoidHom.id N) K = K

full_name: AddSubgroup.map
code: /-- The image of a subgroup along a monoid homomorphism is a subgroup. -/
@[to_additive
      "The image of an `AddSubgroup` along an `AddMonoid` homomorphism
      is an `AddSubgroup`."]
def map (f : G →* N) (H : Subgroup G) : Subgroup N 
goal: AddSubgroup N

full_name: Subgroup.map
code: /-- The image of a subgroup along a monoid homomorphism is a subgroup. -/
@[to_additive
      "The image of an `AddSubgroup` along an `AddMonoid` homomorphism
      is an `AddSubgroup`."]
def map (f : G →* N) (H : Subgroup G) : Subgroup N 
goal: Subgroup N

full_name: Subgroup.coe_map
code: @[to_additive (attr := simp)]
theorem coe_map (f : G →* N) (K : Subgroup G) : (K.map f : Set N) = f '' K 
goal: ↑(Subgroup.map f K) = ⇑f '' ↑K

full_name: AddSubgroup.coe_map
code: @[to_additive (attr := simp)]
theorem coe_map (f : G →* N) (K : Subgroup G) : (K.map f : Set N) = f '' K 
goal: ↑(AddSubgroup.map f K) = ⇑f '' ↑K

full_name: Subgroup.mem_map
code: @[to_additive (attr := simp)]
theorem mem_map {f : G →* N} {K : Subgroup G} {y : N} : y ∈ K.map f ↔ ∃ x ∈ K, f x = y 
goal: y ∈ Subgroup.map f K ↔ ∃ x ∈ K, f x = y

full_name: AddSubgroup.mem_map
code: @[to_additive (attr := simp)]
theorem mem_map {f : G →* N} {K : Subgroup G} {y : N} : y ∈ K.map f ↔ ∃ x ∈ K, f x = y 
goal: y ∈ AddSubgroup.map f K ↔ ∃ x ∈ K, f x = y

full_name: AddSubgroup.mem_map_of_mem
code: @[to_additive]
theorem mem_map_of_mem (f : G →* N) {K : Subgroup G} {x : G} (hx : x ∈ K) : f x ∈ K.map f 
goal: f x ∈ AddSubgroup.map f K

full_name: Subgroup.mem_map_of_mem
code: @[to_additive]
theorem mem_map_of_mem (f : G →* N) {K : Subgroup G} {x : G} (hx : x ∈ K) : f x ∈ K.map f 
goal: f x ∈ Subgroup.map f K

full_name: AddSubgroup.apply_coe_mem_map
code: @[to_additive]
theorem apply_coe_mem_map (f : G →* N) (K : Subgroup G) (x : K) : f x ∈ K.map f 
goal: f ↑x ∈ AddSubgroup.map f K

full_name: Subgroup.apply_coe_mem_map
code: @[to_additive]
theorem apply_coe_mem_map (f : G →* N) (K : Subgroup G) (x : K) : f x ∈ K.map f 
goal: f ↑x ∈ Subgroup.map f K

full_name: AddSubgroup.map_mono
code: @[to_additive]
theorem map_mono {f : G →* N} {K K' : Subgroup G} : K ≤ K' → map f K ≤ map f K' 
goal: K ≤ K' → AddSubgroup.map f K ≤ AddSubgroup.map f K'

full_name: Subgroup.map_mono
code: @[to_additive]
theorem map_mono {f : G →* N} {K K' : Subgroup G} : K ≤ K' → map f K ≤ map f K' 
goal: K ≤ K' → Subgroup.map f K ≤ Subgroup.map f K'

full_name: AddSubgroup.map_id
code: @[to_additive (attr := simp)]
theorem map_id : K.map (MonoidHom.id G) = K 
goal: AddSubgroup.map (AddMonoidHom.id G) K = K

full_name: Subgroup.map_id
code: @[to_additive (attr := simp)]
theorem map_id : K.map (MonoidHom.id G) = K 
goal: Subgroup.map (MonoidHom.id G) K = K

full_name: Subgroup.map_map
code: @[to_additive]
theorem map_map (g : N →* P) (f : G →* N) : (K.map f).map g = K.map (g.comp f) 
goal: Subgroup.map g (Subgroup.map f K) = Subgroup.map (g.comp f) K

full_name: AddSubgroup.map_map
code: @[to_additive]
theorem map_map (g : N →* P) (f : G →* N) : (K.map f).map g = K.map (g.comp f) 
goal: AddSubgroup.map g (AddSubgroup.map f K) = AddSubgroup.map (g.comp f) K

full_name: Subgroup.map_one_eq_bot
code: @[to_additive (attr := simp)]
theorem map_one_eq_bot : K.map (1 : G →* N) = ⊥ 
goal: Subgroup.map 1 K = ⊥

full_name: AddSubgroup.map_zero_eq_bot
code: @[to_additive (attr := simp)]
theorem map_one_eq_bot : K.map (1 : G →* N) = ⊥ 
goal: AddSubgroup.map 0 K = ⊥

full_name: Subgroup.mem_map_equiv
code: @[to_additive]
theorem mem_map_equiv {f : G ≃* N} {K : Subgroup G} {x : N} :
    x ∈ K.map f.toMonoidHom ↔ f.symm x ∈ K 
goal: x ∈ Subgroup.map f.toMonoidHom K ↔ f.symm x ∈ K

full_name: AddSubgroup.mem_map_equiv
code: @[to_additive]
theorem mem_map_equiv {f : G ≃* N} {K : Subgroup G} {x : N} :
    x ∈ K.map f.toMonoidHom ↔ f.symm x ∈ K 
goal: x ∈ AddSubgroup.map f.toAddMonoidHom K ↔ f.symm x ∈ K

full_name: AddSubgroup.mem_map_iff_mem
code: @[to_additive (attr := simp 1100, nolint simpNF)]
theorem mem_map_iff_mem {f : G →* N} (hf : Function.Injective f) {K : Subgroup G} {x : G} :
    f x ∈ K.map f ↔ x ∈ K 
goal: f x ∈ AddSubgroup.map f K ↔ x ∈ K

full_name: Subgroup.mem_map_iff_mem
code: @[to_additive (attr := simp 1100, nolint simpNF)]
theorem mem_map_iff_mem {f : G →* N} (hf : Function.Injective f) {K : Subgroup G} {x : G} :
    f x ∈ K.map f ↔ x ∈ K 
goal: f x ∈ Subgroup.map f K ↔ x ∈ K

full_name: Subgroup.map_equiv_eq_comap_symm'
code: @[to_additive]
theorem map_equiv_eq_comap_symm' (f : G ≃* N) (K : Subgroup G) :
    K.map f.toMonoidHom = K.comap f.symm.toMonoidHom 
goal: Subgroup.map f.toMonoidHom K = Subgroup.comap f.symm.toMonoidHom K

full_name: AddSubgroup.map_equiv_eq_comap_symm'
code: @[to_additive]
theorem map_equiv_eq_comap_symm' (f : G ≃* N) (K : Subgroup G) :
    K.map f.toMonoidHom = K.comap f.symm.toMonoidHom 
goal: AddSubgroup.map f.toAddMonoidHom K = AddSubgroup.comap f.symm.toAddMonoidHom K

full_name: AddSubgroup.map_equiv_eq_comap_symm
code: @[to_additive]
theorem map_equiv_eq_comap_symm (f : G ≃* N) (K : Subgroup G) :
    K.map f = K.comap (G := N) f.symm 
goal: AddSubgroup.map (↑f) K = AddSubgroup.comap (↑f.symm) K

full_name: Subgroup.map_equiv_eq_comap_symm
code: @[to_additive]
theorem map_equiv_eq_comap_symm (f : G ≃* N) (K : Subgroup G) :
    K.map f = K.comap (G := N) f.symm 
goal: Subgroup.map (↑f) K = Subgroup.comap (↑f.symm) K

full_name: Subgroup.comap_equiv_eq_map_symm
code: @[to_additive]
theorem comap_equiv_eq_map_symm (f : N ≃* G) (K : Subgroup G) :
    K.comap (G := N) f = K.map f.symm 
goal: Subgroup.comap (↑f) K = Subgroup.map (↑f.symm) K

full_name: AddSubgroup.comap_equiv_eq_map_symm
code: @[to_additive]
theorem comap_equiv_eq_map_symm (f : N ≃* G) (K : Subgroup G) :
    K.comap (G := N) f = K.map f.symm 
goal: AddSubgroup.comap (↑f) K = AddSubgroup.map (↑f.symm) K

full_name: AddSubgroup.comap_equiv_eq_map_symm'
code: @[to_additive]
theorem comap_equiv_eq_map_symm' (f : N ≃* G) (K : Subgroup G) :
    K.comap f.toMonoidHom = K.map f.symm.toMonoidHom 
goal: AddSubgroup.comap f.toAddMonoidHom K = AddSubgroup.map f.symm.toAddMonoidHom K

full_name: Subgroup.comap_equiv_eq_map_symm'
code: @[to_additive]
theorem comap_equiv_eq_map_symm' (f : N ≃* G) (K : Subgroup G) :
    K.comap f.toMonoidHom = K.map f.symm.toMonoidHom 
goal: Subgroup.comap f.toMonoidHom K = Subgroup.map f.symm.toMonoidHom K

full_name: AddSubgroup.map_symm_eq_iff_map_eq
code: @[to_additive]
theorem map_symm_eq_iff_map_eq {H : Subgroup N} {e : G ≃* N} :
    H.map ↑e.symm = K ↔ K.map ↑e = H 
goal: AddSubgroup.map (↑e.symm) H = K ↔ AddSubgroup.map (↑e) K = H

full_name: Subgroup.map_symm_eq_iff_map_eq
code: @[to_additive]
theorem map_symm_eq_iff_map_eq {H : Subgroup N} {e : G ≃* N} :
    H.map ↑e.symm = K ↔ K.map ↑e = H 
goal: Subgroup.map (↑e.symm) H = K ↔ Subgroup.map (↑e) K = H

full_name: AddSubgroup.map_le_iff_le_comap
code: @[to_additive]
theorem map_le_iff_le_comap {f : G →* N} {K : Subgroup G} {H : Subgroup N} :
    K.map f ≤ H ↔ K ≤ H.comap f 
goal: AddSubgroup.map f K ≤ H ↔ K ≤ AddSubgroup.comap f H

full_name: Subgroup.map_le_iff_le_comap
code: @[to_additive]
theorem map_le_iff_le_comap {f : G →* N} {K : Subgroup G} {H : Subgroup N} :
    K.map f ≤ H ↔ K ≤ H.comap f 
goal: Subgroup.map f K ≤ H ↔ K ≤ Subgroup.comap f H

full_name: AddSubgroup.gc_map_comap
code: @[to_additive]
theorem gc_map_comap (f : G →* N) : GaloisConnection (map f) (comap f) 
goal: GaloisConnection (AddSubgroup.map f) (AddSubgroup.comap f)

full_name: Subgroup.gc_map_comap
code: @[to_additive]
theorem gc_map_comap (f : G →* N) : GaloisConnection (map f) (comap f) 
goal: GaloisConnection (Subgroup.map f) (Subgroup.comap f)

full_name: AddSubgroup.map_sup
code: @[to_additive]
theorem map_sup (H K : Subgroup G) (f : G →* N) : (H ⊔ K).map f = H.map f ⊔ K.map f 
goal: AddSubgroup.map f (H ⊔ K) = AddSubgroup.map f H ⊔ AddSubgroup.map f K

full_name: Subgroup.map_sup
code: @[to_additive]
theorem map_sup (H K : Subgroup G) (f : G →* N) : (H ⊔ K).map f = H.map f ⊔ K.map f 
goal: Subgroup.map f (H ⊔ K) = Subgroup.map f H ⊔ Subgroup.map f K

full_name: AddSubgroup.map_iSup
code: @[to_additive]
theorem map_iSup {ι : Sort*} (f : G →* N) (s : ι → Subgroup G) :
    (iSup s).map f = ⨆ i, (s i).map f 
goal: AddSubgroup.map f (iSup s) = ⨆ i, AddSubgroup.map f (s i)

full_name: Subgroup.map_iSup
code: @[to_additive]
theorem map_iSup {ι : Sort*} (f : G →* N) (s : ι → Subgroup G) :
    (iSup s).map f = ⨆ i, (s i).map f 
goal: Subgroup.map f (iSup s) = ⨆ i, Subgroup.map f (s i)

full_name: AddSubgroup.comap_sup_comap_le
code: @[to_additive]
theorem comap_sup_comap_le (H K : Subgroup N) (f : G →* N) :
    comap f H ⊔ comap f K ≤ comap f (H ⊔ K) 
goal: AddSubgroup.comap f H ⊔ AddSubgroup.comap f K ≤ AddSubgroup.comap f (H ⊔ K)

full_name: Subgroup.comap_sup_comap_le
code: @[to_additive]
theorem comap_sup_comap_le (H K : Subgroup N) (f : G →* N) :
    comap f H ⊔ comap f K ≤ comap f (H ⊔ K) 
goal: Subgroup.comap f H ⊔ Subgroup.comap f K ≤ Subgroup.comap f (H ⊔ K)

full_name: AddSubgroup.iSup_comap_le
code: @[to_additive]
theorem iSup_comap_le {ι : Sort*} (f : G →* N) (s : ι → Subgroup N) :
    ⨆ i, (s i).comap f ≤ (iSup s).comap f 
goal: ⨆ i, AddSubgroup.comap f (s i) ≤ AddSubgroup.comap f (iSup s)

full_name: Subgroup.iSup_comap_le
code: @[to_additive]
theorem iSup_comap_le {ι : Sort*} (f : G →* N) (s : ι → Subgroup N) :
    ⨆ i, (s i).comap f ≤ (iSup s).comap f 
goal: ⨆ i, Subgroup.comap f (s i) ≤ Subgroup.comap f (iSup s)

full_name: Subgroup.comap_inf
code: @[to_additive]
theorem comap_inf (H K : Subgroup N) (f : G →* N) : (H ⊓ K).comap f = H.comap f ⊓ K.comap f 
goal: Subgroup.comap f (H ⊓ K) = Subgroup.comap f H ⊓ Subgroup.comap f K

full_name: AddSubgroup.comap_inf
code: @[to_additive]
theorem comap_inf (H K : Subgroup N) (f : G →* N) : (H ⊓ K).comap f = H.comap f ⊓ K.comap f 
goal: AddSubgroup.comap f (H ⊓ K) = AddSubgroup.comap f H ⊓ AddSubgroup.comap f K

full_name: Subgroup.comap_iInf
code: @[to_additive]
theorem comap_iInf {ι : Sort*} (f : G →* N) (s : ι → Subgroup N) :
    (iInf s).comap f = ⨅ i, (s i).comap f 
goal: Subgroup.comap f (iInf s) = ⨅ i, Subgroup.comap f (s i)

full_name: AddSubgroup.comap_iInf
code: @[to_additive]
theorem comap_iInf {ι : Sort*} (f : G →* N) (s : ι → Subgroup N) :
    (iInf s).comap f = ⨅ i, (s i).comap f 
goal: AddSubgroup.comap f (iInf s) = ⨅ i, AddSubgroup.comap f (s i)

full_name: Subgroup.map_inf_le
code: @[to_additive]
theorem map_inf_le (H K : Subgroup G) (f : G →* N) : map f (H ⊓ K) ≤ map f H ⊓ map f K 
goal: Subgroup.map f (H ⊓ K) ≤ Subgroup.map f H ⊓ Subgroup.map f K

full_name: AddSubgroup.map_inf_le
code: @[to_additive]
theorem map_inf_le (H K : Subgroup G) (f : G →* N) : map f (H ⊓ K) ≤ map f H ⊓ map f K 
goal: AddSubgroup.map f (H ⊓ K) ≤ AddSubgroup.map f H ⊓ AddSubgroup.map f K

full_name: AddSubgroup.map_inf_eq
code: @[to_additive]
theorem map_inf_eq (H K : Subgroup G) (f : G →* N) (hf : Function.Injective f) :
    map f (H ⊓ K) = map f H ⊓ map f K 
goal: AddSubgroup.map f (H ⊓ K) = AddSubgroup.map f H ⊓ AddSubgroup.map f K

full_name: Subgroup.map_inf_eq
code: @[to_additive]
theorem map_inf_eq (H K : Subgroup G) (f : G →* N) (hf : Function.Injective f) :
    map f (H ⊓ K) = map f H ⊓ map f K 
goal: Subgroup.map f (H ⊓ K) = Subgroup.map f H ⊓ Subgroup.map f K

full_name: Subgroup.map_bot
code: @[to_additive (attr := simp)]
theorem map_bot (f : G →* N) : (⊥ : Subgroup G).map f = ⊥ 
goal: Subgroup.map f ⊥ = ⊥

full_name: AddSubgroup.map_bot
code: @[to_additive (attr := simp)]
theorem map_bot (f : G →* N) : (⊥ : Subgroup G).map f = ⊥ 
goal: AddSubgroup.map f ⊥ = ⊥

full_name: Subgroup.map_top_of_surjective
code: @[to_additive (attr := simp)]
theorem map_top_of_surjective (f : G →* N) (h : Function.Surjective f) : Subgroup.map f ⊤ = ⊤ 
goal: Subgroup.map f ⊤ = ⊤

full_name: AddSubgroup.map_top_of_surjective
code: @[to_additive (attr := simp)]
theorem map_top_of_surjective (f : G →* N) (h : Function.Surjective f) : Subgroup.map f ⊤ = ⊤ 
goal: AddSubgroup.map f ⊤ = ⊤

full_name: AddSubgroup.comap_top
code: @[to_additive (attr := simp)]
theorem comap_top (f : G →* N) : (⊤ : Subgroup N).comap f = ⊤ 
goal: AddSubgroup.comap f ⊤ = ⊤

full_name: Subgroup.comap_top
code: @[to_additive (attr := simp)]
theorem comap_top (f : G →* N) : (⊤ : Subgroup N).comap f = ⊤ 
goal: Subgroup.comap f ⊤ = ⊤

full_name: AddSubgroup.addSubgroupOf
code: /-- For any subgroups `H` and `K`, view `H ⊓ K` as a subgroup of `K`. -/
@[to_additive "For any subgroups `H` and `K`, view `H ⊓ K` as a subgroup of `K`."]
def subgroupOf (H K : Subgroup G) : Subgroup K 
goal: AddSubgroup ↥K

full_name: Subgroup.subgroupOf
code: /-- For any subgroups `H` and `K`, view `H ⊓ K` as a subgroup of `K`. -/
@[to_additive "For any subgroups `H` and `K`, view `H ⊓ K` as a subgroup of `K`."]
def subgroupOf (H K : Subgroup G) : Subgroup K 
goal: Subgroup ↥K

full_name: Subgroup.subgroupOfEquivOfLe_symm_apply_coe_coe
code: /-- If `H ≤ K`, then `H` as a subgroup of `K` is isomorphic to `H`. -/
@[to_additive (attr := simps) "If `H ≤ K`, then `H` as a subgroup of `K` is isomorphic to `H`."]
def subgroupOfEquivOfLe {G : Type*} [Group G] {H K : Subgroup G} (h : H ≤ K) :
    H.subgroupOf K ≃* H 
goal: ↑↑((Subgroup.subgroupOfEquivOfLe h).symm g) = ↑g

full_name: AddSubgroup.addSubgroupOfEquivOfLe
code: /-- If `H ≤ K`, then `H` as a subgroup of `K` is isomorphic to `H`. -/
@[to_additive (attr := simps) "If `H ≤ K`, then `H` as a subgroup of `K` is isomorphic to `H`."]
def subgroupOfEquivOfLe {G : Type*} [Group G] {H K : Subgroup G} (h : H ≤ K) :
    H.subgroupOf K ≃* H 
goal: ↥(H.addSubgroupOf K) ≃+ ↥H

full_name: Subgroup.subgroupOfEquivOfLe
code: /-- If `H ≤ K`, then `H` as a subgroup of `K` is isomorphic to `H`. -/
@[to_additive (attr := simps) "If `H ≤ K`, then `H` as a subgroup of `K` is isomorphic to `H`."]
def subgroupOfEquivOfLe {G : Type*} [Group G] {H K : Subgroup G} (h : H ≤ K) :
    H.subgroupOf K ≃* H 
goal: ↥(H.subgroupOf K) ≃* ↥H

full_name: Subgroup.subgroupOfEquivOfLe_apply_coe
code: /-- If `H ≤ K`, then `H` as a subgroup of `K` is isomorphic to `H`. -/
@[to_additive (attr := simps) "If `H ≤ K`, then `H` as a subgroup of `K` is isomorphic to `H`."]
def subgroupOfEquivOfLe {G : Type*} [Group G] {H K : Subgroup G} (h : H ≤ K) :
    H.subgroupOf K ≃* H 
goal: ↑((Subgroup.subgroupOfEquivOfLe h) g) = ↑↑g

full_name: AddSubgroup.addSubgroupOfEquivOfLe_symm_apply_coe_coe
code: /-- If `H ≤ K`, then `H` as a subgroup of `K` is isomorphic to `H`. -/
@[to_additive (attr := simps) "If `H ≤ K`, then `H` as a subgroup of `K` is isomorphic to `H`."]
def subgroupOfEquivOfLe {G : Type*} [Group G] {H K : Subgroup G} (h : H ≤ K) :
    H.subgroupOf K ≃* H 
goal: ↑↑((AddSubgroup.addSubgroupOfEquivOfLe h).symm g) = ↑g

full_name: AddSubgroup.addSubgroupOfEquivOfLe_apply_coe
code: /-- If `H ≤ K`, then `H` as a subgroup of `K` is isomorphic to `H`. -/
@[to_additive (attr := simps) "If `H ≤ K`, then `H` as a subgroup of `K` is isomorphic to `H`."]
def subgroupOfEquivOfLe {G : Type*} [Group G] {H K : Subgroup G} (h : H ≤ K) :
    H.subgroupOf K ≃* H 
goal: ↑((AddSubgroup.addSubgroupOfEquivOfLe h) g) = ↑↑g

full_name: Subgroup.comap_subtype
code: @[to_additive (attr := simp)]
theorem comap_subtype (H K : Subgroup G) : H.comap K.subtype = H.subgroupOf K 
goal: Subgroup.comap K.subtype H = H.subgroupOf K

full_name: AddSubgroup.comap_subtype
code: @[to_additive (attr := simp)]
theorem comap_subtype (H K : Subgroup G) : H.comap K.subtype = H.subgroupOf K 
goal: AddSubgroup.comap K.subtype H = H.addSubgroupOf K

full_name: AddSubgroup.comap_inclusion_addSubgroupOf
code: @[to_additive (attr := simp)]
theorem comap_inclusion_subgroupOf {K₁ K₂ : Subgroup G} (h : K₁ ≤ K₂) (H : Subgroup G) :
    (H.subgroupOf K₂).comap (inclusion h) = H.subgroupOf K₁ 
goal: AddSubgroup.comap (AddSubgroup.inclusion h) (H.addSubgroupOf K₂) = H.addSubgroupOf K₁

full_name: Subgroup.comap_inclusion_subgroupOf
code: @[to_additive (attr := simp)]
theorem comap_inclusion_subgroupOf {K₁ K₂ : Subgroup G} (h : K₁ ≤ K₂) (H : Subgroup G) :
    (H.subgroupOf K₂).comap (inclusion h) = H.subgroupOf K₁ 
goal: Subgroup.comap (Subgroup.inclusion h) (H.subgroupOf K₂) = H.subgroupOf K₁

full_name: Subgroup.coe_subgroupOf
code: @[to_additive]
theorem coe_subgroupOf (H K : Subgroup G) : (H.subgroupOf K : Set K) = K.subtype ⁻¹' H 
goal: ↑(H.subgroupOf K) = ⇑K.subtype ⁻¹' ↑H

full_name: AddSubgroup.coe_addSubgroupOf
code: @[to_additive]
theorem coe_subgroupOf (H K : Subgroup G) : (H.subgroupOf K : Set K) = K.subtype ⁻¹' H 
goal: ↑(H.addSubgroupOf K) = ⇑K.subtype ⁻¹' ↑H

full_name: Subgroup.mem_subgroupOf
code: @[to_additive]
theorem mem_subgroupOf {H K : Subgroup G} {h : K} : h ∈ H.subgroupOf K ↔ (h : G) ∈ H 
goal: h ∈ H.subgroupOf K ↔ ↑h ∈ H

full_name: AddSubgroup.mem_addSubgroupOf
code: @[to_additive]
theorem mem_subgroupOf {H K : Subgroup G} {h : K} : h ∈ H.subgroupOf K ↔ (h : G) ∈ H 
goal: h ∈ H.addSubgroupOf K ↔ ↑h ∈ H

full_name: AddSubgroup.addSubgroupOf_map_subtype
code: @[to_additive (attr := simp)]
theorem subgroupOf_map_subtype (H K : Subgroup G) : (H.subgroupOf K).map K.subtype = H ⊓ K 
goal: AddSubgroup.map K.subtype (H.addSubgroupOf K) = H ⊓ K

full_name: Subgroup.subgroupOf_map_subtype
code: @[to_additive (attr := simp)]
theorem subgroupOf_map_subtype (H K : Subgroup G) : (H.subgroupOf K).map K.subtype = H ⊓ K 
goal: Subgroup.map K.subtype (H.subgroupOf K) = H ⊓ K

full_name: AddSubgroup.bot_addSubgroupOf
code: @[to_additive (attr := simp)]
theorem bot_subgroupOf : (⊥ : Subgroup G).subgroupOf H = ⊥ 
goal: ⊥.addSubgroupOf H = ⊥

full_name: Subgroup.bot_subgroupOf
code: @[to_additive (attr := simp)]
theorem bot_subgroupOf : (⊥ : Subgroup G).subgroupOf H = ⊥ 
goal: ⊥.subgroupOf H = ⊥

full_name: Subgroup.top_subgroupOf
code: @[to_additive (attr := simp)]
theorem top_subgroupOf : (⊤ : Subgroup G).subgroupOf H = ⊤ 
goal: ⊤.subgroupOf H = ⊤

full_name: AddSubgroup.top_addSubgroupOf
code: @[to_additive (attr := simp)]
theorem top_subgroupOf : (⊤ : Subgroup G).subgroupOf H = ⊤ 
goal: ⊤.addSubgroupOf H = ⊤

full_name: Subgroup.subgroupOf_bot_eq_bot
code: @[to_additive]
theorem subgroupOf_bot_eq_bot : H.subgroupOf ⊥ = ⊥ 
goal: H.subgroupOf ⊥ = ⊥

full_name: AddSubgroup.addSubgroupOf_bot_eq_bot
code: @[to_additive]
theorem subgroupOf_bot_eq_bot : H.subgroupOf ⊥ = ⊥ 
goal: H.addSubgroupOf ⊥ = ⊥

full_name: AddSubgroup.addSubgroupOf_bot_eq_top
code: @[to_additive]
theorem subgroupOf_bot_eq_top : H.subgroupOf ⊥ = ⊤ 
goal: H.addSubgroupOf ⊥ = ⊤

full_name: Subgroup.subgroupOf_bot_eq_top
code: @[to_additive]
theorem subgroupOf_bot_eq_top : H.subgroupOf ⊥ = ⊤ 
goal: H.subgroupOf ⊥ = ⊤

full_name: AddSubgroup.addSubgroupOf_self
code: @[to_additive (attr := simp)]
theorem subgroupOf_self : H.subgroupOf H = ⊤ 
goal: H.addSubgroupOf H = ⊤

full_name: Subgroup.subgroupOf_self
code: @[to_additive (attr := simp)]
theorem subgroupOf_self : H.subgroupOf H = ⊤ 
goal: H.subgroupOf H = ⊤

full_name: Subgroup.subgroupOf_inj
code: @[to_additive (attr := simp)]
theorem subgroupOf_inj {H₁ H₂ K : Subgroup G} :
    H₁.subgroupOf K = H₂.subgroupOf K ↔ H₁ ⊓ K = H₂ ⊓ K 
goal: H₁.subgroupOf K = H₂.subgroupOf K ↔ H₁ ⊓ K = H₂ ⊓ K

full_name: AddSubgroup.addSubgroupOf_inj
code: @[to_additive (attr := simp)]
theorem subgroupOf_inj {H₁ H₂ K : Subgroup G} :
    H₁.subgroupOf K = H₂.subgroupOf K ↔ H₁ ⊓ K = H₂ ⊓ K 
goal: H₁.addSubgroupOf K = H₂.addSubgroupOf K ↔ H₁ ⊓ K = H₂ ⊓ K

full_name: AddSubgroup.inf_addSubgroupOf_right
code: @[to_additive (attr := simp)]
theorem inf_subgroupOf_right (H K : Subgroup G) : (H ⊓ K).subgroupOf K = H.subgroupOf K 
goal: (H ⊓ K).addSubgroupOf K = H.addSubgroupOf K

full_name: Subgroup.inf_subgroupOf_right
code: @[to_additive (attr := simp)]
theorem inf_subgroupOf_right (H K : Subgroup G) : (H ⊓ K).subgroupOf K = H.subgroupOf K 
goal: (H ⊓ K).subgroupOf K = H.subgroupOf K

full_name: AddSubgroup.inf_addSubgroupOf_left
code: @[to_additive (attr := simp)]
theorem inf_subgroupOf_left (H K : Subgroup G) : (K ⊓ H).subgroupOf K = H.subgroupOf K 
goal: (K ⊓ H).addSubgroupOf K = H.addSubgroupOf K

full_name: Subgroup.inf_subgroupOf_left
code: @[to_additive (attr := simp)]
theorem inf_subgroupOf_left (H K : Subgroup G) : (K ⊓ H).subgroupOf K = H.subgroupOf K 
goal: (K ⊓ H).subgroupOf K = H.subgroupOf K

full_name: Subgroup.subgroupOf_eq_bot
code: @[to_additive (attr := simp)]
theorem subgroupOf_eq_bot {H K : Subgroup G} : H.subgroupOf K = ⊥ ↔ Disjoint H K 
goal: H.subgroupOf K = ⊥ ↔ Disjoint H K

full_name: AddSubgroup.addSubgroupOf_eq_bot
code: @[to_additive (attr := simp)]
theorem subgroupOf_eq_bot {H K : Subgroup G} : H.subgroupOf K = ⊥ ↔ Disjoint H K 
goal: H.addSubgroupOf K = ⊥ ↔ Disjoint H K

full_name: AddSubgroup.addSubgroupOf_eq_top
code: @[to_additive (attr := simp)]
theorem subgroupOf_eq_top {H K : Subgroup G} : H.subgroupOf K = ⊤ ↔ K ≤ H 
goal: H.addSubgroupOf K = ⊤ ↔ K ≤ H

full_name: Subgroup.subgroupOf_eq_top
code: @[to_additive (attr := simp)]
theorem subgroupOf_eq_top {H K : Subgroup G} : H.subgroupOf K = ⊤ ↔ K ≤ H 
goal: H.subgroupOf K = ⊤ ↔ K ≤ H

full_name: Subgroup.prod
code: /-- Given `Subgroup`s `H`, `K` of groups `G`, `N` respectively, `H × K` as a subgroup of `G × N`. -/
@[to_additive prod
      "Given `AddSubgroup`s `H`, `K` of `AddGroup`s `A`, `B` respectively, `H × K`
      as an `AddSubgroup` of `A × B`."]
def prod (H : Subgroup G) (K : Subgroup N) : Subgroup (G × N) 
goal: Subgroup (G × N)

full_name: AddSubgroup.prod
code: /-- Given `Subgroup`s `H`, `K` of groups `G`, `N` respectively, `H × K` as a subgroup of `G × N`. -/
@[to_additive prod
      "Given `AddSubgroup`s `H`, `K` of `AddGroup`s `A`, `B` respectively, `H × K`
      as an `AddSubgroup` of `A × B`."]
def prod (H : Subgroup G) (K : Subgroup N) : Subgroup (G × N) 
goal: AddSubgroup (G × N)

full_name: Subgroup.coe_prod
code: @[to_additive coe_prod]
theorem coe_prod (H : Subgroup G) (K : Subgroup N) :
    (H.prod K : Set (G × N)) = (H : Set G) ×ˢ (K : Set N) 
goal: ↑(H.prod K) = ↑H ×ˢ ↑K

full_name: AddSubgroup.coe_prod
code: @[to_additive coe_prod]
theorem coe_prod (H : Subgroup G) (K : Subgroup N) :
    (H.prod K : Set (G × N)) = (H : Set G) ×ˢ (K : Set N) 
goal: ↑(H.prod K) = ↑H ×ˢ ↑K

full_name: AddSubgroup.mem_prod
code: @[to_additive mem_prod]
theorem mem_prod {H : Subgroup G} {K : Subgroup N} {p : G × N} : p ∈ H.prod K ↔ p.1 ∈ H ∧ p.2 ∈ K 
goal: p ∈ H.prod K ↔ p.1 ∈ H ∧ p.2 ∈ K

full_name: Subgroup.mem_prod
code: @[to_additive mem_prod]
theorem mem_prod {H : Subgroup G} {K : Subgroup N} {p : G × N} : p ∈ H.prod K ↔ p.1 ∈ H ∧ p.2 ∈ K 
goal: p ∈ H.prod K ↔ p.1 ∈ H ∧ p.2 ∈ K

full_name: AddSubgroup.prod_mono
code: @[to_additive prod_mono]
theorem prod_mono : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) (@prod G _ N _) (@prod G _ N _) 
goal: ((fun x x_1 => x ≤ x_1) ⇒ (fun x x_1 => x ≤ x_1) ⇒ fun x x_1 => x ≤ x_1) AddSubgroup.prod AddSubgroup.prod

full_name: Subgroup.prod_mono
code: @[to_additive prod_mono]
theorem prod_mono : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) (@prod G _ N _) (@prod G _ N _) 
goal: ((fun x x_1 => x ≤ x_1) ⇒ (fun x x_1 => x ≤ x_1) ⇒ fun x x_1 => x ≤ x_1) Subgroup.prod Subgroup.prod

full_name: Subgroup.prod_mono_right
code: @[to_additive prod_mono_right]
theorem prod_mono_right (K : Subgroup G) : Monotone fun t : Subgroup N => K.prod t 
goal: Monotone fun t => K.prod t

full_name: AddSubgroup.prod_mono_right
code: @[to_additive prod_mono_right]
theorem prod_mono_right (K : Subgroup G) : Monotone fun t : Subgroup N => K.prod t 
goal: Monotone fun t => K.prod t

full_name: AddSubgroup.prod_mono_left
code: @[to_additive prod_mono_left]
theorem prod_mono_left (H : Subgroup N) : Monotone fun K : Subgroup G => K.prod H 
goal: Monotone fun K => K.prod H

full_name: Subgroup.prod_mono_left
code: @[to_additive prod_mono_left]
theorem prod_mono_left (H : Subgroup N) : Monotone fun K : Subgroup G => K.prod H 
goal: Monotone fun K => K.prod H

full_name: AddSubgroup.prod_top
code: @[to_additive prod_top]
theorem prod_top (K : Subgroup G) : K.prod (⊤ : Subgroup N) = K.comap (MonoidHom.fst G N) 
goal: K.prod ⊤ = AddSubgroup.comap (AddMonoidHom.fst G N) K

full_name: Subgroup.prod_top
code: @[to_additive prod_top]
theorem prod_top (K : Subgroup G) : K.prod (⊤ : Subgroup N) = K.comap (MonoidHom.fst G N) 
goal: K.prod ⊤ = Subgroup.comap (MonoidHom.fst G N) K

full_name: AddSubgroup.top_prod
code: @[to_additive top_prod]
theorem top_prod (H : Subgroup N) : (⊤ : Subgroup G).prod H = H.comap (MonoidHom.snd G N) 
goal: ⊤.prod H = AddSubgroup.comap (AddMonoidHom.snd G N) H

full_name: Subgroup.top_prod
code: @[to_additive top_prod]
theorem top_prod (H : Subgroup N) : (⊤ : Subgroup G).prod H = H.comap (MonoidHom.snd G N) 
goal: ⊤.prod H = Subgroup.comap (MonoidHom.snd G N) H

full_name: AddSubgroup.top_prod_top
code: @[to_additive (attr := simp) top_prod_top]
theorem top_prod_top : (⊤ : Subgroup G).prod (⊤ : Subgroup N) = ⊤ 
goal: ⊤.prod ⊤ = ⊤

full_name: Subgroup.top_prod_top
code: @[to_additive (attr := simp) top_prod_top]
theorem top_prod_top : (⊤ : Subgroup G).prod (⊤ : Subgroup N) = ⊤ 
goal: ⊤.prod ⊤ = ⊤

full_name: Subgroup.bot_prod_bot
code: @[to_additive]
theorem bot_prod_bot : (⊥ : Subgroup G).prod (⊥ : Subgroup N) = ⊥ 
goal: ⊥.prod ⊥ = ⊥

full_name: AddSubgroup.bot_sum_bot
code: @[to_additive]
theorem bot_prod_bot : (⊥ : Subgroup G).prod (⊥ : Subgroup N) = ⊥ 
goal: ⊥.prod ⊥ = ⊥

full_name: AddSubgroup.le_prod_iff
code: @[to_additive le_prod_iff]
theorem le_prod_iff {H : Subgroup G} {K : Subgroup N} {J : Subgroup (G × N)} :
    J ≤ H.prod K ↔ map (MonoidHom.fst G N) J ≤ H ∧ map (MonoidHom.snd G N) J ≤ K 
goal: J ≤ H.prod K ↔ AddSubgroup.map (AddMonoidHom.fst G N) J ≤ H ∧ AddSubgroup.map (AddMonoidHom.snd G N) J ≤ K

full_name: Subgroup.le_prod_iff
code: @[to_additive le_prod_iff]
theorem le_prod_iff {H : Subgroup G} {K : Subgroup N} {J : Subgroup (G × N)} :
    J ≤ H.prod K ↔ map (MonoidHom.fst G N) J ≤ H ∧ map (MonoidHom.snd G N) J ≤ K 
goal: J ≤ H.prod K ↔ Subgroup.map (MonoidHom.fst G N) J ≤ H ∧ Subgroup.map (MonoidHom.snd G N) J ≤ K

full_name: Subgroup.prod_le_iff
code: @[to_additive prod_le_iff]
theorem prod_le_iff {H : Subgroup G} {K : Subgroup N} {J : Subgroup (G × N)} :
    H.prod K ≤ J ↔ map (MonoidHom.inl G N) H ≤ J ∧ map (MonoidHom.inr G N) K ≤ J 
goal: H.prod K ≤ J ↔ Subgroup.map (MonoidHom.inl G N) H ≤ J ∧ Subgroup.map (MonoidHom.inr G N) K ≤ J

full_name: AddSubgroup.prod_le_iff
code: @[to_additive prod_le_iff]
theorem prod_le_iff {H : Subgroup G} {K : Subgroup N} {J : Subgroup (G × N)} :
    H.prod K ≤ J ↔ map (MonoidHom.inl G N) H ≤ J ∧ map (MonoidHom.inr G N) K ≤ J 
goal: H.prod K ≤ J ↔ AddSubgroup.map (AddMonoidHom.inl G N) H ≤ J ∧ AddSubgroup.map (AddMonoidHom.inr G N) K ≤ J

full_name: AddSubgroup.prod_eq_bot_iff
code: @[to_additive (attr := simp) prod_eq_bot_iff]
theorem prod_eq_bot_iff {H : Subgroup G} {K : Subgroup N} : H.prod K = ⊥ ↔ H = ⊥ ∧ K = ⊥ 
goal: H.prod K = ⊥ ↔ H = ⊥ ∧ K = ⊥

full_name: Subgroup.prod_eq_bot_iff
code: @[to_additive (attr := simp) prod_eq_bot_iff]
theorem prod_eq_bot_iff {H : Subgroup G} {K : Subgroup N} : H.prod K = ⊥ ↔ H = ⊥ ∧ K = ⊥ 
goal: H.prod K = ⊥ ↔ H = ⊥ ∧ K = ⊥

full_name: AddSubgroup.prodEquiv
code: /-- Product of subgroups is isomorphic to their product as groups. -/
@[to_additive prodEquiv
      "Product of additive subgroups is isomorphic to their product
      as additive groups"]
def prodEquiv (H : Subgroup G) (K : Subgroup N) : H.prod K ≃* H × K 
goal: ↥(H.prod K) ≃+ ↥H × ↥K

full_name: Subgroup.prodEquiv
code: /-- Product of subgroups is isomorphic to their product as groups. -/
@[to_additive prodEquiv
      "Product of additive subgroups is isomorphic to their product
      as additive groups"]
def prodEquiv (H : Subgroup G) (K : Subgroup N) : H.prod K ≃* H × K 
goal: ↥(H.prod K) ≃* ↥H × ↥K

full_name: Submonoid.pi
code: /-- A version of `Set.pi` for submonoids. Given an index set `I` and a family of submodules
`s : Π i, Submonoid f i`, `pi I s` is the submonoid of dependent functions `f : Π i, f i` such that
`f i` belongs to `Pi I s` whenever `i ∈ I`. -/
@[to_additive "A version of `Set.pi` for `AddSubmonoid`s. Given an index set `I` and a family
  of submodules `s : Π i, AddSubmonoid f i`, `pi I s` is the `AddSubmonoid` of dependent functions
  `f : Π i, f i` such that `f i` belongs to `pi I s` whenever `i ∈ I`."]
def _root_.Submonoid.pi [∀ i, MulOneClass (f i)] (I : Set η) (s : ∀ i, Submonoid (f i)) :
    Submonoid (∀ i, f i) 
goal: Submonoid ((i : η) → f i)

full_name: AddSubmonoid.pi
code: /-- A version of `Set.pi` for submonoids. Given an index set `I` and a family of submodules
`s : Π i, Submonoid f i`, `pi I s` is the submonoid of dependent functions `f : Π i, f i` such that
`f i` belongs to `Pi I s` whenever `i ∈ I`. -/
@[to_additive "A version of `Set.pi` for `AddSubmonoid`s. Given an index set `I` and a family
  of submodules `s : Π i, AddSubmonoid f i`, `pi I s` is the `AddSubmonoid` of dependent functions
  `f : Π i, f i` such that `f i` belongs to `pi I s` whenever `i ∈ I`."]
def _root_.Submonoid.pi [∀ i, MulOneClass (f i)] (I : Set η) (s : ∀ i, Submonoid (f i)) :
    Submonoid (∀ i, f i) 
goal: AddSubmonoid ((i : η) → f i)

full_name: AddSubgroup.pi
code: /-- A version of `Set.pi` for subgroups. Given an index set `I` and a family of submodules
`s : Π i, Subgroup f i`, `pi I s` is the subgroup of dependent functions `f : Π i, f i` such that
`f i` belongs to `pi I s` whenever `i ∈ I`. -/
@[to_additive
      "A version of `Set.pi` for `AddSubgroup`s. Given an index set `I` and a family
      of submodules `s : Π i, AddSubgroup f i`, `pi I s` is the `AddSubgroup` of dependent functions
      `f : Π i, f i` such that `f i` belongs to `pi I s` whenever `i ∈ I`."]
def pi (I : Set η) (H : ∀ i, Subgroup (f i)) : Subgroup (∀ i, f i) 
goal: AddSubgroup ((i : η) → f i)

full_name: Subgroup.pi
code: /-- A version of `Set.pi` for subgroups. Given an index set `I` and a family of submodules
`s : Π i, Subgroup f i`, `pi I s` is the subgroup of dependent functions `f : Π i, f i` such that
`f i` belongs to `pi I s` whenever `i ∈ I`. -/
@[to_additive
      "A version of `Set.pi` for `AddSubgroup`s. Given an index set `I` and a family
      of submodules `s : Π i, AddSubgroup f i`, `pi I s` is the `AddSubgroup` of dependent functions
      `f : Π i, f i` such that `f i` belongs to `pi I s` whenever `i ∈ I`."]
def pi (I : Set η) (H : ∀ i, Subgroup (f i)) : Subgroup (∀ i, f i) 
goal: Subgroup ((i : η) → f i)

full_name: Subgroup.coe_pi
code: @[to_additive]
theorem coe_pi (I : Set η) (H : ∀ i, Subgroup (f i)) :
    (pi I H : Set (∀ i, f i)) = Set.pi I fun i => (H i : Set (f i)) 
goal: ↑(Subgroup.pi I H) = I.pi fun i => ↑(H i)

full_name: AddSubgroup.coe_pi
code: @[to_additive]
theorem coe_pi (I : Set η) (H : ∀ i, Subgroup (f i)) :
    (pi I H : Set (∀ i, f i)) = Set.pi I fun i => (H i : Set (f i)) 
goal: ↑(AddSubgroup.pi I H) = I.pi fun i => ↑(H i)

full_name: Subgroup.mem_pi
code: @[to_additive]
theorem mem_pi (I : Set η) {H : ∀ i, Subgroup (f i)} {p : ∀ i, f i} :
    p ∈ pi I H ↔ ∀ i : η, i ∈ I → p i ∈ H i 
goal: p ∈ Subgroup.pi I H ↔ ∀ i ∈ I, p i ∈ H i

full_name: AddSubgroup.mem_pi
code: @[to_additive]
theorem mem_pi (I : Set η) {H : ∀ i, Subgroup (f i)} {p : ∀ i, f i} :
    p ∈ pi I H ↔ ∀ i : η, i ∈ I → p i ∈ H i 
goal: p ∈ AddSubgroup.pi I H ↔ ∀ i ∈ I, p i ∈ H i

full_name: AddSubgroup.pi_top
code: @[to_additive]
theorem pi_top (I : Set η) : (pi I fun i => (⊤ : Subgroup (f i))) = ⊤ 
goal: (AddSubgroup.pi I fun i => ⊤) = ⊤

full_name: Subgroup.pi_top
code: @[to_additive]
theorem pi_top (I : Set η) : (pi I fun i => (⊤ : Subgroup (f i))) = ⊤ 
goal: (Subgroup.pi I fun i => ⊤) = ⊤

full_name: Subgroup.pi_empty
code: @[to_additive]
theorem pi_empty (H : ∀ i, Subgroup (f i)) : pi ∅ H = ⊤ 
goal: Subgroup.pi ∅ H = ⊤

full_name: AddSubgroup.pi_empty
code: @[to_additive]
theorem pi_empty (H : ∀ i, Subgroup (f i)) : pi ∅ H = ⊤ 
goal: AddSubgroup.pi ∅ H = ⊤

full_name: Subgroup.pi_bot
code: @[to_additive]
theorem pi_bot : (pi Set.univ fun i => (⊥ : Subgroup (f i))) = ⊥ 
goal: (Subgroup.pi Set.univ fun i => ⊥) = ⊥

full_name: AddSubgroup.pi_bot
code: @[to_additive]
theorem pi_bot : (pi Set.univ fun i => (⊥ : Subgroup (f i))) = ⊥ 
goal: (AddSubgroup.pi Set.univ fun i => ⊥) = ⊥

full_name: AddSubgroup.le_pi_iff
code: @[to_additive]
theorem le_pi_iff {I : Set η} {H : ∀ i, Subgroup (f i)} {J : Subgroup (∀ i, f i)} :
    J ≤ pi I H ↔ ∀ i : η, i ∈ I → map (Pi.evalMonoidHom f i) J ≤ H i 
goal: J ≤ AddSubgroup.pi I H ↔ ∀ i ∈ I, AddSubgroup.map (Pi.evalAddMonoidHom f i) J ≤ H i

full_name: Subgroup.le_pi_iff
code: @[to_additive]
theorem le_pi_iff {I : Set η} {H : ∀ i, Subgroup (f i)} {J : Subgroup (∀ i, f i)} :
    J ≤ pi I H ↔ ∀ i : η, i ∈ I → map (Pi.evalMonoidHom f i) J ≤ H i 
goal: J ≤ Subgroup.pi I H ↔ ∀ i ∈ I, Subgroup.map (Pi.evalMonoidHom f i) J ≤ H i

full_name: Subgroup.mulSingle_mem_pi
code: @[to_additive (attr := simp)]
theorem mulSingle_mem_pi [DecidableEq η] {I : Set η} {H : ∀ i, Subgroup (f i)} (i : η) (x : f i) :
    Pi.mulSingle i x ∈ pi I H ↔ i ∈ I → x ∈ H i 
goal: Pi.mulSingle i x ∈ Subgroup.pi I H ↔ i ∈ I → x ∈ H i

full_name: AddSubgroup.single_mem_pi
code: @[to_additive (attr := simp)]
theorem mulSingle_mem_pi [DecidableEq η] {I : Set η} {H : ∀ i, Subgroup (f i)} (i : η) (x : f i) :
    Pi.mulSingle i x ∈ pi I H ↔ i ∈ I → x ∈ H i 
goal: Pi.single i x ∈ AddSubgroup.pi I H ↔ i ∈ I → x ∈ H i

full_name: AddSubgroup.pi_eq_bot_iff
code: @[to_additive]
theorem pi_eq_bot_iff (H : ∀ i, Subgroup (f i)) : pi Set.univ H = ⊥ ↔ ∀ i, H i = ⊥ 
goal: AddSubgroup.pi Set.univ H = ⊥ ↔ ∀ (i : η), H i = ⊥

full_name: Subgroup.pi_eq_bot_iff
code: @[to_additive]
theorem pi_eq_bot_iff (H : ∀ i, Subgroup (f i)) : pi Set.univ H = ⊥ ↔ ∀ i, H i = ⊥ 
goal: Subgroup.pi Set.univ H = ⊥ ↔ ∀ (i : η), H i = ⊥

full_name: Subgroup.Normal.conj_mem
code: /-- A subgroup is normal if whenever `n ∈ H`, then `g * n * g⁻¹ ∈ H` for every `g : G` -/
structure Normal : Prop where
  /-- `N` is closed under conjugation -/
  conj_mem : ∀ n, n ∈ H → ∀ g : G, g * n * g⁻¹ ∈ H
goal: n ∈ H → ∀ (g : G), g * n * g⁻¹ ∈ H

full_name: Subgroup.Normal
code: /-- A subgroup is normal if whenever `n ∈ H`, then `g * n * g⁻¹ ∈ H` for every `g : G` -/
structure Normal : Prop where
  /-- `N` is closed under conjugation -/
  conj_mem : ∀ n, n ∈ H → ∀ g : G, g * n * g⁻¹ ∈ H
goal: Prop

full_name: AddSubgroup.Normal
code: /-- An AddSubgroup is normal if whenever `n ∈ H`, then `g + n - g ∈ H` for every `g : G` -/
structure Normal (H : AddSubgroup A) : Prop where
  /-- `N` is closed under additive conjugation -/
  conj_mem : ∀ n, n ∈ H → ∀ g : A, g + n + -g ∈ H
goal: Prop

full_name: AddSubgroup.Normal.conj_mem
code: /-- An AddSubgroup is normal if whenever `n ∈ H`, then `g + n - g ∈ H` for every `g : G` -/
structure Normal (H : AddSubgroup A) : Prop where
  /-- `N` is closed under additive conjugation -/
  conj_mem : ∀ n, n ∈ H → ∀ g : A, g + n + -g ∈ H
goal: n ∈ H → ∀ (g : A), g + n + -g ∈ H

full_name: Subgroup.normal_of_comm
code: @[to_additive]
instance (priority := 100) normal_of_comm {G : Type*} [CommGroup G] (H : Subgroup G) : H.Normal 
goal: H.Normal

full_name: AddSubgroup.normal_of_comm
code: @[to_additive]
instance (priority := 100) normal_of_comm {G : Type*} [CommGroup G] (H : Subgroup G) : H.Normal 
goal: H.Normal

full_name: Subgroup.Normal.conj_mem'
code: @[to_additive]
theorem conj_mem' (nH : H.Normal) (n : G) (hn : n ∈ H) (g : G) :
    g⁻¹ * n * g ∈ H 
goal: g⁻¹ * n * g ∈ H

full_name: AddSubgroup.Normal.conj_mem'
code: @[to_additive]
theorem conj_mem' (nH : H.Normal) (n : G) (hn : n ∈ H) (g : G) :
    g⁻¹ * n * g ∈ H 
goal: -g + n + g ∈ H

full_name: AddSubgroup.Normal.mem_comm
code: @[to_additive]
theorem mem_comm (nH : H.Normal) {a b : G} (h : a * b ∈ H) : b * a ∈ H 
goal: b + a ∈ H

full_name: Subgroup.Normal.mem_comm
code: @[to_additive]
theorem mem_comm (nH : H.Normal) {a b : G} (h : a * b ∈ H) : b * a ∈ H 
goal: b * a ∈ H

full_name: Subgroup.Normal.mem_comm_iff
code: @[to_additive]
theorem mem_comm_iff (nH : H.Normal) {a b : G} : a * b ∈ H ↔ b * a ∈ H 
goal: a * b ∈ H ↔ b * a ∈ H

full_name: AddSubgroup.Normal.mem_comm_iff
code: @[to_additive]
theorem mem_comm_iff (nH : H.Normal) {a b : G} : a * b ∈ H ↔ b * a ∈ H 
goal: a + b ∈ H ↔ b + a ∈ H

full_name: Subgroup.Characteristic.fixed
code: /-- A subgroup is characteristic if it is fixed by all automorphisms.
  Several equivalent conditions are provided by lemmas of the form `Characteristic.iff...` -/
structure Characteristic : Prop where
  /-- `H` is fixed by all automorphisms -/
  fixed : ∀ ϕ : G ≃* G, H.comap ϕ.toMonoidHom = H
goal: Subgroup.comap ϕ.toMonoidHom H = H

full_name: Subgroup.Characteristic
code: /-- A subgroup is characteristic if it is fixed by all automorphisms.
  Several equivalent conditions are provided by lemmas of the form `Characteristic.iff...` -/
structure Characteristic : Prop where
  /-- `H` is fixed by all automorphisms -/
  fixed : ∀ ϕ : G ≃* G, H.comap ϕ.toMonoidHom = H
goal: Prop

full_name: Subgroup.normal_of_characteristic
code: instance (priority := 100) normal_of_characteristic [h : H.Characteristic] : H.Normal 
goal: H.Normal

full_name: AddSubgroup.Characteristic
code: /-- An `AddSubgroup` is characteristic if it is fixed by all automorphisms.
  Several equivalent conditions are provided by lemmas of the form `Characteristic.iff...` -/
structure Characteristic : Prop where
  /-- `H` is fixed by all automorphisms -/
  fixed : ∀ ϕ : A ≃+ A, H.comap ϕ.toAddMonoidHom = H
goal: Prop

full_name: AddSubgroup.Characteristic.fixed
code: /-- An `AddSubgroup` is characteristic if it is fixed by all automorphisms.
  Several equivalent conditions are provided by lemmas of the form `Characteristic.iff...` -/
structure Characteristic : Prop where
  /-- `H` is fixed by all automorphisms -/
  fixed : ∀ ϕ : A ≃+ A, H.comap ϕ.toAddMonoidHom = H
goal: AddSubgroup.comap ϕ.toAddMonoidHom H = H

full_name: AddSubgroup.normal_of_characteristic
code: instance (priority := 100) normal_of_characteristic [h : H.Characteristic] : H.Normal 
goal: H.Normal

full_name: Subgroup.characteristic_iff_comap_eq
code: @[to_additive]
theorem characteristic_iff_comap_eq : H.Characteristic ↔ ∀ ϕ : G ≃* G, H.comap ϕ.toMonoidHom = H 
goal: H.Characteristic ↔ ∀ (ϕ : G ≃* G), Subgroup.comap ϕ.toMonoidHom H = H

full_name: AddSubgroup.characteristic_iff_comap_eq
code: @[to_additive]
theorem characteristic_iff_comap_eq : H.Characteristic ↔ ∀ ϕ : G ≃* G, H.comap ϕ.toMonoidHom = H 
goal: H.Characteristic ↔ ∀ (ϕ : G ≃+ G), AddSubgroup.comap ϕ.toAddMonoidHom H = H

full_name: Subgroup.characteristic_iff_comap_le
code: @[to_additive]
theorem characteristic_iff_comap_le : H.Characteristic ↔ ∀ ϕ : G ≃* G, H.comap ϕ.toMonoidHom ≤ H 
goal: H.Characteristic ↔ ∀ (ϕ : G ≃* G), Subgroup.comap ϕ.toMonoidHom H ≤ H

full_name: AddSubgroup.characteristic_iff_comap_le
code: @[to_additive]
theorem characteristic_iff_comap_le : H.Characteristic ↔ ∀ ϕ : G ≃* G, H.comap ϕ.toMonoidHom ≤ H 
goal: H.Characteristic ↔ ∀ (ϕ : G ≃+ G), AddSubgroup.comap ϕ.toAddMonoidHom H ≤ H

full_name: AddSubgroup.characteristic_iff_le_comap
code: @[to_additive]
theorem characteristic_iff_le_comap : H.Characteristic ↔ ∀ ϕ : G ≃* G, H ≤ H.comap ϕ.toMonoidHom 
goal: H.Characteristic ↔ ∀ (ϕ : G ≃+ G), H ≤ AddSubgroup.comap ϕ.toAddMonoidHom H

full_name: Subgroup.characteristic_iff_le_comap
code: @[to_additive]
theorem characteristic_iff_le_comap : H.Characteristic ↔ ∀ ϕ : G ≃* G, H ≤ H.comap ϕ.toMonoidHom 
goal: H.Characteristic ↔ ∀ (ϕ : G ≃* G), H ≤ Subgroup.comap ϕ.toMonoidHom H

full_name: AddSubgroup.characteristic_iff_map_eq
code: @[to_additive]
theorem characteristic_iff_map_eq : H.Characteristic ↔ ∀ ϕ : G ≃* G, H.map ϕ.toMonoidHom = H 
goal: H.Characteristic ↔ ∀ (ϕ : G ≃+ G), AddSubgroup.map ϕ.toAddMonoidHom H = H

full_name: Subgroup.characteristic_iff_map_eq
code: @[to_additive]
theorem characteristic_iff_map_eq : H.Characteristic ↔ ∀ ϕ : G ≃* G, H.map ϕ.toMonoidHom = H 
goal: H.Characteristic ↔ ∀ (ϕ : G ≃* G), Subgroup.map ϕ.toMonoidHom H = H

full_name: AddSubgroup.characteristic_iff_map_le
code: @[to_additive]
theorem characteristic_iff_map_le : H.Characteristic ↔ ∀ ϕ : G ≃* G, H.map ϕ.toMonoidHom ≤ H 
goal: H.Characteristic ↔ ∀ (ϕ : G ≃+ G), AddSubgroup.map ϕ.toAddMonoidHom H ≤ H

full_name: Subgroup.characteristic_iff_map_le
code: @[to_additive]
theorem characteristic_iff_map_le : H.Characteristic ↔ ∀ ϕ : G ≃* G, H.map ϕ.toMonoidHom ≤ H 
goal: H.Characteristic ↔ ∀ (ϕ : G ≃* G), Subgroup.map ϕ.toMonoidHom H ≤ H

full_name: AddSubgroup.characteristic_iff_le_map
code: @[to_additive]
theorem characteristic_iff_le_map : H.Characteristic ↔ ∀ ϕ : G ≃* G, H ≤ H.map ϕ.toMonoidHom 
goal: H.Characteristic ↔ ∀ (ϕ : G ≃+ G), H ≤ AddSubgroup.map ϕ.toAddMonoidHom H

full_name: Subgroup.characteristic_iff_le_map
code: @[to_additive]
theorem characteristic_iff_le_map : H.Characteristic ↔ ∀ ϕ : G ≃* G, H ≤ H.map ϕ.toMonoidHom 
goal: H.Characteristic ↔ ∀ (ϕ : G ≃* G), H ≤ Subgroup.map ϕ.toMonoidHom H

full_name: AddSubgroup.botCharacteristic
code: @[to_additive]
instance botCharacteristic : Characteristic (⊥ : Subgroup G) 
goal: ⊥.Characteristic

full_name: Subgroup.botCharacteristic
code: @[to_additive]
instance botCharacteristic : Characteristic (⊥ : Subgroup G) 
goal: ⊥.Characteristic

full_name: AddSubgroup.topCharacteristic
code: @[to_additive]
instance topCharacteristic : Characteristic (⊤ : Subgroup G) 
goal: ⊤.Characteristic

full_name: Subgroup.topCharacteristic
code: @[to_additive]
instance topCharacteristic : Characteristic (⊤ : Subgroup G) 
goal: ⊤.Characteristic

full_name: Subgroup.normalizer
code: /-- The `normalizer` of `H` is the largest subgroup of `G` inside which `H` is normal. -/
@[to_additive "The `normalizer` of `H` is the largest subgroup of `G` inside which `H` is normal."]
def normalizer : Subgroup G 
goal: Subgroup G

full_name: AddSubgroup.normalizer
code: /-- The `normalizer` of `H` is the largest subgroup of `G` inside which `H` is normal. -/
@[to_additive "The `normalizer` of `H` is the largest subgroup of `G` inside which `H` is normal."]
def normalizer : Subgroup G 
goal: AddSubgroup G

full_name: Subgroup.setNormalizer
code: /-- The `setNormalizer` of `S` is the subgroup of `G` whose elements satisfy `g*S*g⁻¹=S` -/
@[to_additive
      "The `setNormalizer` of `S` is the subgroup of `G` whose elements satisfy
      `g+S-g=S`."]
def setNormalizer (S : Set G) : Subgroup G 
goal: Subgroup G

full_name: AddSubgroup.setNormalizer
code: /-- The `setNormalizer` of `S` is the subgroup of `G` whose elements satisfy `g*S*g⁻¹=S` -/
@[to_additive
      "The `setNormalizer` of `S` is the subgroup of `G` whose elements satisfy
      `g+S-g=S`."]
def setNormalizer (S : Set G) : Subgroup G 
goal: AddSubgroup G

full_name: Subgroup.mem_normalizer_iff
code: @[to_additive]
theorem mem_normalizer_iff {g : G} : g ∈ H.normalizer ↔ ∀ h, h ∈ H ↔ g * h * g⁻¹ ∈ H 
goal: g ∈ H.normalizer ↔ ∀ (h : G), h ∈ H ↔ g * h * g⁻¹ ∈ H

full_name: AddSubgroup.mem_normalizer_iff
code: @[to_additive]
theorem mem_normalizer_iff {g : G} : g ∈ H.normalizer ↔ ∀ h, h ∈ H ↔ g * h * g⁻¹ ∈ H 
goal: g ∈ H.normalizer ↔ ∀ (h : G), h ∈ H ↔ g + h + -g ∈ H

full_name: Subgroup.mem_normalizer_iff''
code: @[to_additive]
theorem mem_normalizer_iff'' {g : G} : g ∈ H.normalizer ↔ ∀ h : G, h ∈ H ↔ g⁻¹ * h * g ∈ H 
goal: g ∈ H.normalizer ↔ ∀ (h : G), h ∈ H ↔ g⁻¹ * h * g ∈ H

full_name: AddSubgroup.mem_normalizer_iff''
code: @[to_additive]
theorem mem_normalizer_iff'' {g : G} : g ∈ H.normalizer ↔ ∀ h : G, h ∈ H ↔ g⁻¹ * h * g ∈ H 
goal: g ∈ H.normalizer ↔ ∀ (h : G), h ∈ H ↔ -g + h + g ∈ H

full_name: AddSubgroup.mem_normalizer_iff'
code: @[to_additive]
theorem mem_normalizer_iff' {g : G} : g ∈ H.normalizer ↔ ∀ n, n * g ∈ H ↔ g * n ∈ H 
goal: g ∈ H.normalizer ↔ ∀ (n : G), n + g ∈ H ↔ g + n ∈ H

full_name: Subgroup.mem_normalizer_iff'
code: @[to_additive]
theorem mem_normalizer_iff' {g : G} : g ∈ H.normalizer ↔ ∀ n, n * g ∈ H ↔ g * n ∈ H 
goal: g ∈ H.normalizer ↔ ∀ (n : G), n * g ∈ H ↔ g * n ∈ H

full_name: AddSubgroup.le_normalizer
code: @[to_additive]
theorem le_normalizer : H ≤ normalizer H 
goal: H ≤ H.normalizer

full_name: Subgroup.le_normalizer
code: @[to_additive]
theorem le_normalizer : H ≤ normalizer H 
goal: H ≤ H.normalizer

full_name: AddSubgroup.normal_in_normalizer
code: @[to_additive]
instance (priority := 100) normal_in_normalizer : (H.subgroupOf H.normalizer).Normal 
goal: (H.addSubgroupOf H.normalizer).Normal

full_name: Subgroup.normal_in_normalizer
code: @[to_additive]
instance (priority := 100) normal_in_normalizer : (H.subgroupOf H.normalizer).Normal 
goal: (H.subgroupOf H.normalizer).Normal

full_name: Subgroup.normalizer_eq_top
code: @[to_additive]
theorem normalizer_eq_top : H.normalizer = ⊤ ↔ H.Normal 
goal: H.normalizer = ⊤ ↔ H.Normal

full_name: AddSubgroup.normalizer_eq_top
code: @[to_additive]
theorem normalizer_eq_top : H.normalizer = ⊤ ↔ H.Normal 
goal: H.normalizer = ⊤ ↔ H.Normal

full_name: AddSubgroup.le_normalizer_of_normal
code: @[to_additive]
theorem le_normalizer_of_normal [hK : (H.subgroupOf K).Normal] (HK : H ≤ K) : K ≤ H.normalizer 
goal: K ≤ H.normalizer

full_name: Subgroup.le_normalizer_of_normal
code: @[to_additive]
theorem le_normalizer_of_normal [hK : (H.subgroupOf K).Normal] (HK : H ≤ K) : K ≤ H.normalizer 
goal: K ≤ H.normalizer

full_name: AddSubgroup.le_normalizer_comap
code: /-- The preimage of the normalizer is contained in the normalizer of the preimage. -/
@[to_additive "The preimage of the normalizer is contained in the normalizer of the preimage."]
theorem le_normalizer_comap (f : N →* G) :
    H.normalizer.comap f ≤ (H.comap f).normalizer 
goal: AddSubgroup.comap f H.normalizer ≤ (AddSubgroup.comap f H).normalizer

full_name: Subgroup.le_normalizer_comap
code: /-- The preimage of the normalizer is contained in the normalizer of the preimage. -/
@[to_additive "The preimage of the normalizer is contained in the normalizer of the preimage."]
theorem le_normalizer_comap (f : N →* G) :
    H.normalizer.comap f ≤ (H.comap f).normalizer 
goal: Subgroup.comap f H.normalizer ≤ (Subgroup.comap f H).normalizer

full_name: Subgroup.le_normalizer_map
code: /-- The image of the normalizer is contained in the normalizer of the image. -/
@[to_additive "The image of the normalizer is contained in the normalizer of the image."]
theorem le_normalizer_map (f : G →* N) : H.normalizer.map f ≤ (H.map f).normalizer 
goal: Subgroup.map f H.normalizer ≤ (Subgroup.map f H).normalizer

full_name: AddSubgroup.le_normalizer_map
code: /-- The image of the normalizer is contained in the normalizer of the image. -/
@[to_additive "The image of the normalizer is contained in the normalizer of the image."]
theorem le_normalizer_map (f : G →* N) : H.normalizer.map f ≤ (H.map f).normalizer 
goal: AddSubgroup.map f H.normalizer ≤ (AddSubgroup.map f H).normalizer

full_name: NormalizerCondition
code: /-- Every proper subgroup `H` of `G` is a proper normal subgroup of the normalizer of `H` in `G`. -/
def _root_.NormalizerCondition 
goal: Prop

full_name: normalizerCondition_iff_only_full_group_self_normalizing
code: /-- Alternative phrasing of the normalizer condition: Only the full group is self-normalizing.
This may be easier to work with, as it avoids inequalities and negations.  -/
theorem _root_.normalizerCondition_iff_only_full_group_self_normalizing :
    NormalizerCondition G ↔ ∀ H : Subgroup G, H.normalizer = H → H = ⊤ 
goal: NormalizerCondition G ↔ ∀ (H : Subgroup G), H.normalizer = H → H = ⊤

full_name: Subgroup.IsCommutative.is_comm
code: /-- Commutativity of a subgroup -/
structure IsCommutative : Prop where
  /-- `*` is commutative on `H` -/
  is_comm : Std.Commutative (α := H) (· * ·)
goal: Std.Commutative fun x x_1 => x * x_1

full_name: Subgroup.IsCommutative
code: /-- Commutativity of a subgroup -/
structure IsCommutative : Prop where
  /-- `*` is commutative on `H` -/
  is_comm : Std.Commutative (α := H) (· * ·)
goal: Prop

full_name: AddSubgroup.IsCommutative.is_comm
code: /-- Commutativity of an additive subgroup -/
structure _root_.AddSubgroup.IsCommutative (H : AddSubgroup A) : Prop where
  /-- `+` is commutative on `H` -/
  is_comm : Std.Commutative (α := H) (· + ·)
goal: Std.Commutative fun x x_1 => x + x_1

full_name: AddSubgroup.IsCommutative
code: /-- Commutativity of an additive subgroup -/
structure _root_.AddSubgroup.IsCommutative (H : AddSubgroup A) : Prop where
  /-- `+` is commutative on `H` -/
  is_comm : Std.Commutative (α := H) (· + ·)
goal: Prop

full_name: Subgroup.IsCommutative.commGroup
code: /-- A commutative subgroup is commutative. -/
@[to_additive "A commutative subgroup is commutative."]
instance IsCommutative.commGroup [h : H.IsCommutative] : CommGroup H 
goal: CommGroup ↥H

full_name: AddSubgroup.IsCommutative.addCommGroup
code: /-- A commutative subgroup is commutative. -/
@[to_additive "A commutative subgroup is commutative."]
instance IsCommutative.commGroup [h : H.IsCommutative] : CommGroup H 
goal: AddCommGroup ↥H

full_name: Subgroup.map_isCommutative
code: @[to_additive]
instance map_isCommutative (f : G →* G') [H.IsCommutative] : (H.map f).IsCommutative 
goal: (Subgroup.map f H).IsCommutative

full_name: AddSubgroup.map_isCommutative
code: @[to_additive]
instance map_isCommutative (f : G →* G') [H.IsCommutative] : (H.map f).IsCommutative 
goal: (AddSubgroup.map f H).IsCommutative

full_name: AddSubgroup.comap_injective_isCommutative
code: @[to_additive]
theorem comap_injective_isCommutative {f : G' →* G} (hf : Injective f) [H.IsCommutative] :
    (H.comap f).IsCommutative 
goal: (AddSubgroup.comap f H).IsCommutative

full_name: Subgroup.comap_injective_isCommutative
code: @[to_additive]
theorem comap_injective_isCommutative {f : G' →* G} (hf : Injective f) [H.IsCommutative] :
    (H.comap f).IsCommutative 
goal: (Subgroup.comap f H).IsCommutative

full_name: AddSubgroup.addSubgroupOf_isCommutative
code: @[to_additive]
instance subgroupOf_isCommutative [H.IsCommutative] : (H.subgroupOf K).IsCommutative 
goal: (H.addSubgroupOf K).IsCommutative

full_name: Subgroup.subgroupOf_isCommutative
code: @[to_additive]
instance subgroupOf_isCommutative [H.IsCommutative] : (H.subgroupOf K).IsCommutative 
goal: (H.subgroupOf K).IsCommutative

full_name: MulEquiv.comapSubgroup_symm_apply
code: /--
An isomorphism of groups gives an order isomorphism between the lattices of subgroups,
defined by sending subgroups to their inverse images.

See also `MulEquiv.mapSubgroup` which maps subgroups to their forward images.
-/
@[simps]
def comapSubgroup (f : G ≃* H) : Subgroup H ≃o Subgroup G 
goal: ∀ (H_1 : Subgroup G), (RelIso.symm f.comapSubgroup) H_1 = Subgroup.comap (↑f.symm) H_1

full_name: MulEquiv.comapSubgroup_apply
code: /--
An isomorphism of groups gives an order isomorphism between the lattices of subgroups,
defined by sending subgroups to their inverse images.

See also `MulEquiv.mapSubgroup` which maps subgroups to their forward images.
-/
@[simps]
def comapSubgroup (f : G ≃* H) : Subgroup H ≃o Subgroup G 
goal: ∀ (H_1 : Subgroup H), f.comapSubgroup H_1 = Subgroup.comap (↑f) H_1

full_name: MulEquiv.comapSubgroup
code: /--
An isomorphism of groups gives an order isomorphism between the lattices of subgroups,
defined by sending subgroups to their inverse images.

See also `MulEquiv.mapSubgroup` which maps subgroups to their forward images.
-/
@[simps]
def comapSubgroup (f : G ≃* H) : Subgroup H ≃o Subgroup G 
goal: Subgroup H ≃o Subgroup G

full_name: MulEquiv.mapSubgroup_apply
code: /--
An isomorphism of groups gives an order isomorphism between the lattices of subgroups,
defined by sending subgroups to their forward images.

See also `MulEquiv.comapSubgroup` which maps subgroups to their inverse images.
-/
@[simps]
def mapSubgroup {H : Type*} [Group H] (f : G ≃* H) : Subgroup G ≃o Subgroup H 
goal: ∀ (H_1 : Subgroup G), f.mapSubgroup H_1 = Subgroup.map (↑f) H_1

full_name: MulEquiv.mapSubgroup_symm_apply
code: /--
An isomorphism of groups gives an order isomorphism between the lattices of subgroups,
defined by sending subgroups to their forward images.

See also `MulEquiv.comapSubgroup` which maps subgroups to their inverse images.
-/
@[simps]
def mapSubgroup {H : Type*} [Group H] (f : G ≃* H) : Subgroup G ≃o Subgroup H 
goal: ∀ (H_1 : Subgroup H), (RelIso.symm f.mapSubgroup) H_1 = Subgroup.map (↑f.symm) H_1

full_name: MulEquiv.mapSubgroup
code: /--
An isomorphism of groups gives an order isomorphism between the lattices of subgroups,
defined by sending subgroups to their forward images.

See also `MulEquiv.comapSubgroup` which maps subgroups to their inverse images.
-/
@[simps]
def mapSubgroup {H : Type*} [Group H] (f : G ≃* H) : Subgroup G ≃o Subgroup H 
goal: Subgroup G ≃o Subgroup H

full_name: Group.conjugatesOfSet
code: /-- Given a set `s`, `conjugatesOfSet s` is the set of all conjugates of
the elements of `s`. -/
def conjugatesOfSet (s : Set G) : Set G 
goal: Set G

full_name: Group.mem_conjugatesOfSet_iff
code: theorem mem_conjugatesOfSet_iff {x : G} : x ∈ conjugatesOfSet s ↔ ∃ a ∈ s, IsConj a x 
goal: x ∈ Group.conjugatesOfSet s ↔ ∃ a ∈ s, IsConj a x

full_name: Group.subset_conjugatesOfSet
code: theorem subset_conjugatesOfSet : s ⊆ conjugatesOfSet s 
goal: s ⊆ Group.conjugatesOfSet s

full_name: Group.conjugatesOfSet_mono
code: theorem conjugatesOfSet_mono {s t : Set G} (h : s ⊆ t) : conjugatesOfSet s ⊆ conjugatesOfSet t 
goal: Group.conjugatesOfSet s ⊆ Group.conjugatesOfSet t

full_name: Group.conjugates_subset_normal
code: theorem conjugates_subset_normal {N : Subgroup G} [tn : N.Normal] {a : G} (h : a ∈ N) :
    conjugatesOf a ⊆ N 
goal: conjugatesOf a ⊆ ↑N

full_name: Group.conjugatesOfSet_subset
code: theorem conjugatesOfSet_subset {s : Set G} {N : Subgroup G} [N.Normal] (h : s ⊆ N) :
    conjugatesOfSet s ⊆ N 
goal: Group.conjugatesOfSet s ⊆ ↑N

full_name: Group.conj_mem_conjugatesOfSet
code: /-- The set of conjugates of `s` is closed under conjugation. -/
theorem conj_mem_conjugatesOfSet {x c : G} :
    x ∈ conjugatesOfSet s → c * x * c⁻¹ ∈ conjugatesOfSet s 
goal: x ∈ Group.conjugatesOfSet s → c * x * c⁻¹ ∈ Group.conjugatesOfSet s

full_name: Subgroup.normalClosure
code: /-- The normal closure of a set `s` is the subgroup closure of all the conjugates of
elements of `s`. It is the smallest normal subgroup containing `s`. -/
def normalClosure (s : Set G) : Subgroup G 
goal: Subgroup G

full_name: Subgroup.conjugatesOfSet_subset_normalClosure
code: theorem conjugatesOfSet_subset_normalClosure : conjugatesOfSet s ⊆ normalClosure s 
goal: Group.conjugatesOfSet s ⊆ ↑(Subgroup.normalClosure s)

full_name: Subgroup.subset_normalClosure
code: theorem subset_normalClosure : s ⊆ normalClosure s 
goal: s ⊆ ↑(Subgroup.normalClosure s)

full_name: Subgroup.le_normalClosure
code: theorem le_normalClosure {H : Subgroup G} : H ≤ normalClosure ↑H 
goal: H ≤ Subgroup.normalClosure ↑H

full_name: Subgroup.normalClosure_normal
code: /-- The normal closure of `s` is a normal subgroup. -/
instance normalClosure_normal : (normalClosure s).Normal 
goal: (Subgroup.normalClosure s).Normal

full_name: Subgroup.normalClosure_le_normal
code: /-- The normal closure of `s` is the smallest normal subgroup containing `s`. -/
theorem normalClosure_le_normal {N : Subgroup G} [N.Normal] (h : s ⊆ N) : normalClosure s ≤ N 
goal: Subgroup.normalClosure s ≤ N

full_name: Subgroup.normalClosure_subset_iff
code: theorem normalClosure_subset_iff {N : Subgroup G} [N.Normal] : s ⊆ N ↔ normalClosure s ≤ N 
goal: s ⊆ ↑N ↔ Subgroup.normalClosure s ≤ N

full_name: Subgroup.normalClosure_mono
code: theorem normalClosure_mono {s t : Set G} (h : s ⊆ t) : normalClosure s ≤ normalClosure t 
goal: Subgroup.normalClosure s ≤ Subgroup.normalClosure t

full_name: Subgroup.normalClosure_eq_iInf
code: theorem normalClosure_eq_iInf :
    normalClosure s = ⨅ (N : Subgroup G) (_ : Normal N) (_ : s ⊆ N), N 
goal: Subgroup.normalClosure s = ⨅ N, ⨅ (_ : N.Normal), ⨅ (_ : s ⊆ ↑N), N

full_name: Subgroup.normalClosure_eq_self
code: @[simp]
theorem normalClosure_eq_self (H : Subgroup G) [H.Normal] : normalClosure ↑H = H 
goal: Subgroup.normalClosure ↑H = H

full_name: Subgroup.normalClosure_idempotent
code: theorem normalClosure_idempotent : normalClosure ↑(normalClosure s) = normalClosure s 
goal: Subgroup.normalClosure ↑(Subgroup.normalClosure s) = Subgroup.normalClosure s

full_name: Subgroup.closure_le_normalClosure
code: theorem closure_le_normalClosure {s : Set G} : closure s ≤ normalClosure s 
goal: Subgroup.closure s ≤ Subgroup.normalClosure s

full_name: Subgroup.normalClosure_closure_eq_normalClosure
code: @[simp]
theorem normalClosure_closure_eq_normalClosure {s : Set G} :
    normalClosure ↑(closure s) = normalClosure s 
goal: Subgroup.normalClosure ↑(Subgroup.closure s) = Subgroup.normalClosure s

full_name: Subgroup.normalCore
code: /-- The normal core of a subgroup `H` is the largest normal subgroup of `G` contained in `H`,
as shown by `Subgroup.normalCore_eq_iSup`. -/
def normalCore (H : Subgroup G) : Subgroup G 
goal: Subgroup G

full_name: Subgroup.normalCore_le
code: theorem normalCore_le (H : Subgroup G) : H.normalCore ≤ H 
goal: H.normalCore ≤ H

full_name: Subgroup.normalCore_normal
code: instance normalCore_normal (H : Subgroup G) : H.normalCore.Normal 
goal: H.normalCore.Normal

full_name: Subgroup.normal_le_normalCore
code: theorem normal_le_normalCore {H : Subgroup G} {N : Subgroup G} [hN : N.Normal] :
    N ≤ H.normalCore ↔ N ≤ H 
goal: N ≤ H.normalCore ↔ N ≤ H

full_name: Subgroup.normalCore_mono
code: theorem normalCore_mono {H K : Subgroup G} (h : H ≤ K) : H.normalCore ≤ K.normalCore 
goal: H.normalCore ≤ K.normalCore

full_name: Subgroup.normalCore_eq_iSup
code: theorem normalCore_eq_iSup (H : Subgroup G) :
    H.normalCore = ⨆ (N : Subgroup G) (_ : Normal N) (_ : N ≤ H), N 
goal: H.normalCore = ⨆ N, ⨆ (_ : N.Normal), ⨆ (_ : N ≤ H), N

full_name: Subgroup.normalCore_eq_self
code: @[simp]
theorem normalCore_eq_self (H : Subgroup G) [H.Normal] : H.normalCore = H 
goal: H.normalCore = H

full_name: Subgroup.normalCore_idempotent
code: theorem normalCore_idempotent (H : Subgroup G) : H.normalCore.normalCore = H.normalCore 
goal: H.normalCore.normalCore = H.normalCore

full_name: MonoidHom.range
code: /-- The range of a monoid homomorphism from a group is a subgroup. -/
@[to_additive "The range of an `AddMonoidHom` from an `AddGroup` is an `AddSubgroup`."]
def range (f : G →* N) : Subgroup N 
goal: Subgroup N

full_name: AddMonoidHom.range
code: /-- The range of a monoid homomorphism from a group is a subgroup. -/
@[to_additive "The range of an `AddMonoidHom` from an `AddGroup` is an `AddSubgroup`."]
def range (f : G →* N) : Subgroup N 
goal: AddSubgroup N

full_name: MonoidHom.coe_range
code: @[to_additive (attr := simp)]
theorem coe_range (f : G →* N) : (f.range : Set N) = Set.range f 
goal: ↑f.range = Set.range ⇑f

full_name: AddMonoidHom.coe_range
code: @[to_additive (attr := simp)]
theorem coe_range (f : G →* N) : (f.range : Set N) = Set.range f 
goal: ↑f.range = Set.range ⇑f

full_name: AddMonoidHom.mem_range
code: @[to_additive (attr := simp)]
theorem mem_range {f : G →* N} {y : N} : y ∈ f.range ↔ ∃ x, f x = y 
goal: y ∈ f.range ↔ ∃ x, f x = y

full_name: MonoidHom.mem_range
code: @[to_additive (attr := simp)]
theorem mem_range {f : G →* N} {y : N} : y ∈ f.range ↔ ∃ x, f x = y 
goal: y ∈ f.range ↔ ∃ x, f x = y

full_name: AddMonoidHom.range_eq_map
code: @[to_additive]
theorem range_eq_map (f : G →* N) : f.range = (⊤ : Subgroup G).map f 
goal: f.range = AddSubgroup.map f ⊤

full_name: MonoidHom.range_eq_map
code: @[to_additive]
theorem range_eq_map (f : G →* N) : f.range = (⊤ : Subgroup G).map f 
goal: f.range = Subgroup.map f ⊤

full_name: AddMonoidHom.restrict_range
code: @[to_additive (attr := simp)]
theorem restrict_range (f : G →* N) : (f.restrict K).range = K.map f 
goal: (f.restrict K).range = AddSubgroup.map f K

full_name: MonoidHom.restrict_range
code: @[to_additive (attr := simp)]
theorem restrict_range (f : G →* N) : (f.restrict K).range = K.map f 
goal: (f.restrict K).range = Subgroup.map f K

full_name: AddMonoidHom.rangeRestrict
code: /-- The canonical surjective group homomorphism `G →* f(G)` induced by a group
homomorphism `G →* N`. -/
@[to_additive
      "The canonical surjective `AddGroup` homomorphism `G →+ f(G)` induced by a group
      homomorphism `G →+ N`."]
def rangeRestrict (f : G →* N) : G →* f.range 
goal: G →+ ↥f.range

full_name: MonoidHom.rangeRestrict
code: /-- The canonical surjective group homomorphism `G →* f(G)` induced by a group
homomorphism `G →* N`. -/
@[to_additive
      "The canonical surjective `AddGroup` homomorphism `G →+ f(G)` induced by a group
      homomorphism `G →+ N`."]
def rangeRestrict (f : G →* N) : G →* f.range 
goal: G →* ↥f.range

full_name: MonoidHom.coe_rangeRestrict
code: @[to_additive (attr := simp)]
theorem coe_rangeRestrict (f : G →* N) (g : G) : (f.rangeRestrict g : N) = f g 
goal: ↑(f.rangeRestrict g) = f g

full_name: AddMonoidHom.coe_rangeRestrict
code: @[to_additive (attr := simp)]
theorem coe_rangeRestrict (f : G →* N) (g : G) : (f.rangeRestrict g : N) = f g 
goal: ↑(f.rangeRestrict g) = f g

full_name: AddMonoidHom.coe_comp_rangeRestrict
code: @[to_additive]
theorem coe_comp_rangeRestrict (f : G →* N) :
    ((↑) : f.range → N) ∘ (⇑f.rangeRestrict : G → f.range) = f 
goal: Subtype.val ∘ ⇑f.rangeRestrict = ⇑f

full_name: MonoidHom.coe_comp_rangeRestrict
code: @[to_additive]
theorem coe_comp_rangeRestrict (f : G →* N) :
    ((↑) : f.range → N) ∘ (⇑f.rangeRestrict : G → f.range) = f 
goal: Subtype.val ∘ ⇑f.rangeRestrict = ⇑f

full_name: AddMonoidHom.subtype_comp_rangeRestrict
code: @[to_additive]
theorem subtype_comp_rangeRestrict (f : G →* N) : f.range.subtype.comp f.rangeRestrict = f 
goal: f.range.subtype.comp f.rangeRestrict = f

full_name: MonoidHom.subtype_comp_rangeRestrict
code: @[to_additive]
theorem subtype_comp_rangeRestrict (f : G →* N) : f.range.subtype.comp f.rangeRestrict = f 
goal: f.range.subtype.comp f.rangeRestrict = f

full_name: MonoidHom.rangeRestrict_surjective
code: @[to_additive]
theorem rangeRestrict_surjective (f : G →* N) : Function.Surjective f.rangeRestrict 
goal: Function.Surjective ⇑f.rangeRestrict

full_name: AddMonoidHom.rangeRestrict_surjective
code: @[to_additive]
theorem rangeRestrict_surjective (f : G →* N) : Function.Surjective f.rangeRestrict 
goal: Function.Surjective ⇑f.rangeRestrict

full_name: AddMonoidHom.rangeRestrict_injective_iff
code: @[to_additive (attr := simp)]
lemma rangeRestrict_injective_iff {f : G →* N} : Injective f.rangeRestrict ↔ Injective f 
goal: Function.Injective ⇑f.rangeRestrict ↔ Function.Injective ⇑f

full_name: MonoidHom.rangeRestrict_injective_iff
code: @[to_additive (attr := simp)]
lemma rangeRestrict_injective_iff {f : G →* N} : Injective f.rangeRestrict ↔ Injective f 
goal: Function.Injective ⇑f.rangeRestrict ↔ Function.Injective ⇑f

full_name: MonoidHom.map_range
code: @[to_additive]
theorem map_range (g : N →* P) (f : G →* N) : f.range.map g = (g.comp f).range 
goal: Subgroup.map g f.range = (g.comp f).range

full_name: AddMonoidHom.map_range
code: @[to_additive]
theorem map_range (g : N →* P) (f : G →* N) : f.range.map g = (g.comp f).range 
goal: AddSubgroup.map g f.range = (g.comp f).range

full_name: AddMonoidHom.range_top_iff_surjective
code: @[to_additive]
theorem range_top_iff_surjective {N} [Group N] {f : G →* N} :
    f.range = (⊤ : Subgroup N) ↔ Function.Surjective f 
goal: f.range = ⊤ ↔ Function.Surjective ⇑f

full_name: MonoidHom.range_top_iff_surjective
code: @[to_additive]
theorem range_top_iff_surjective {N} [Group N] {f : G →* N} :
    f.range = (⊤ : Subgroup N) ↔ Function.Surjective f 
goal: f.range = ⊤ ↔ Function.Surjective ⇑f

full_name: MonoidHom.range_top_of_surjective
code: /-- The range of a surjective monoid homomorphism is the whole of the codomain. -/
@[to_additive (attr := simp)
  "The range of a surjective `AddMonoid` homomorphism is the whole of the codomain."]
theorem range_top_of_surjective {N} [Group N] (f : G →* N) (hf : Function.Surjective f) :
    f.range = (⊤ : Subgroup N) 
goal: f.range = ⊤

full_name: AddMonoidHom.range_top_of_surjective
code: /-- The range of a surjective monoid homomorphism is the whole of the codomain. -/
@[to_additive (attr := simp)
  "The range of a surjective `AddMonoid` homomorphism is the whole of the codomain."]
theorem range_top_of_surjective {N} [Group N] (f : G →* N) (hf : Function.Surjective f) :
    f.range = (⊤ : Subgroup N) 
goal: f.range = ⊤

full_name: MonoidHom.range_one
code: @[to_additive (attr := simp)]
theorem range_one : (1 : G →* N).range = ⊥ 
goal: MonoidHom.range 1 = ⊥

full_name: AddMonoidHom.range_zero
code: @[to_additive (attr := simp)]
theorem range_one : (1 : G →* N).range = ⊥ 
goal: AddMonoidHom.range 0 = ⊥

full_name: Subgroup.subtype_range
code: @[to_additive (attr := simp)]
theorem _root_.Subgroup.subtype_range (H : Subgroup G) : H.subtype.range = H 
goal: H.subtype.range = H

full_name: AddSubgroup.subtype_range
code: @[to_additive (attr := simp)]
theorem _root_.Subgroup.subtype_range (H : Subgroup G) : H.subtype.range = H 
goal: H.subtype.range = H

full_name: Subgroup.inclusion_range
code: @[to_additive (attr := simp)]
theorem _root_.Subgroup.inclusion_range {H K : Subgroup G} (h_le : H ≤ K) :
    (inclusion h_le).range = H.subgroupOf K 
goal: (Subgroup.inclusion h_le).range = H.subgroupOf K

full_name: AddSubgroup.inclusion_range
code: @[to_additive (attr := simp)]
theorem _root_.Subgroup.inclusion_range {H K : Subgroup G} (h_le : H ≤ K) :
    (inclusion h_le).range = H.subgroupOf K 
goal: (AddSubgroup.inclusion h_le).range = H.addSubgroupOf K

full_name: AddMonoidHom.addSubgroupOf_range_eq_of_le
code: @[to_additive]
theorem subgroupOf_range_eq_of_le {G₁ G₂ : Type*} [Group G₁] [Group G₂] {K : Subgroup G₂}
    (f : G₁ →* G₂) (h : f.range ≤ K) :
    f.range.subgroupOf K = (f.codRestrict K fun x => h ⟨x, rfl⟩).range 
goal: f.range.addSubgroupOf K = (f.codRestrict K ⋯).range

full_name: MonoidHom.subgroupOf_range_eq_of_le
code: @[to_additive]
theorem subgroupOf_range_eq_of_le {G₁ G₂ : Type*} [Group G₁] [Group G₂] {K : Subgroup G₂}
    (f : G₁ →* G₂) (h : f.range ≤ K) :
    f.range.subgroupOf K = (f.codRestrict K fun x => h ⟨x, rfl⟩).range 
goal: f.range.subgroupOf K = (f.codRestrict K ⋯).range

full_name: MonoidHom.coe_toAdditive_range
code: @[simp]
theorem coe_toAdditive_range (f : G →* G') :
    (MonoidHom.toAdditive f).range = Subgroup.toAddSubgroup f.range 
goal: (MonoidHom.toAdditive f).range = Subgroup.toAddSubgroup f.range

full_name: MonoidHom.coe_toMultiplicative_range
code: @[simp]
theorem coe_toMultiplicative_range {A A' : Type*} [AddGroup A] [AddGroup A'] (f : A →+ A') :
    (AddMonoidHom.toMultiplicative f).range = AddSubgroup.toSubgroup f.range 
goal: (AddMonoidHom.toMultiplicative f).range = AddSubgroup.toSubgroup f.range

full_name: MonoidHom.ofLeftInverse
code: /-- Computable alternative to `MonoidHom.ofInjective`. -/
@[to_additive "Computable alternative to `AddMonoidHom.ofInjective`."]
def ofLeftInverse {f : G →* N} {g : N →* G} (h : Function.LeftInverse g f) : G ≃* f.range 
goal: G ≃* ↥f.range

full_name: AddMonoidHom.ofLeftInverse
code: /-- Computable alternative to `MonoidHom.ofInjective`. -/
@[to_additive "Computable alternative to `AddMonoidHom.ofInjective`."]
def ofLeftInverse {f : G →* N} {g : N →* G} (h : Function.LeftInverse g f) : G ≃* f.range 
goal: G ≃+ ↥f.range

full_name: AddMonoidHom.ofLeftInverse_apply
code: @[to_additive (attr := simp)]
theorem ofLeftInverse_apply {f : G →* N} {g : N →* G} (h : Function.LeftInverse g f) (x : G) :
    ↑(ofLeftInverse h x) = f x 
goal: ↑((AddMonoidHom.ofLeftInverse h) x) = f x

full_name: MonoidHom.ofLeftInverse_apply
code: @[to_additive (attr := simp)]
theorem ofLeftInverse_apply {f : G →* N} {g : N →* G} (h : Function.LeftInverse g f) (x : G) :
    ↑(ofLeftInverse h x) = f x 
goal: ↑((MonoidHom.ofLeftInverse h) x) = f x

full_name: AddMonoidHom.ofLeftInverse_symm_apply
code: @[to_additive (attr := simp)]
theorem ofLeftInverse_symm_apply {f : G →* N} {g : N →* G} (h : Function.LeftInverse g f)
    (x : f.range) : (ofLeftInverse h).symm x = g x 
goal: (AddMonoidHom.ofLeftInverse h).symm x = g ↑x

full_name: MonoidHom.ofLeftInverse_symm_apply
code: @[to_additive (attr := simp)]
theorem ofLeftInverse_symm_apply {f : G →* N} {g : N →* G} (h : Function.LeftInverse g f)
    (x : f.range) : (ofLeftInverse h).symm x = g x 
goal: (MonoidHom.ofLeftInverse h).symm x = g ↑x

full_name: MonoidHom.ofInjective
code: /-- The range of an injective group homomorphism is isomorphic to its domain. -/
@[to_additive "The range of an injective additive group homomorphism is isomorphic to its
domain."]
noncomputable def ofInjective {f : G →* N} (hf : Function.Injective f) : G ≃* f.range 
goal: G ≃* ↥f.range

full_name: AddMonoidHom.ofInjective
code: /-- The range of an injective group homomorphism is isomorphic to its domain. -/
@[to_additive "The range of an injective additive group homomorphism is isomorphic to its
domain."]
noncomputable def ofInjective {f : G →* N} (hf : Function.Injective f) : G ≃* f.range 
goal: G ≃+ ↥f.range

full_name: MonoidHom.ofInjective_apply
code: @[to_additive]
theorem ofInjective_apply {f : G →* N} (hf : Function.Injective f) {x : G} :
    ↑(ofInjective hf x) = f x 
goal: ↑((MonoidHom.ofInjective hf) x) = f x

full_name: AddMonoidHom.ofInjective_apply
code: @[to_additive]
theorem ofInjective_apply {f : G →* N} (hf : Function.Injective f) {x : G} :
    ↑(ofInjective hf x) = f x 
goal: ↑((AddMonoidHom.ofInjective hf) x) = f x

full_name: MonoidHom.apply_ofInjective_symm
code: @[to_additive (attr := simp)]
theorem apply_ofInjective_symm {f : G →* N} (hf : Function.Injective f) (x : f.range) :
    f ((ofInjective hf).symm x) = x 
goal: f ((MonoidHom.ofInjective hf).symm x) = ↑x

full_name: AddMonoidHom.apply_ofInjective_symm
code: @[to_additive (attr := simp)]
theorem apply_ofInjective_symm {f : G →* N} (hf : Function.Injective f) (x : f.range) :
    f ((ofInjective hf).symm x) = x 
goal: f ((AddMonoidHom.ofInjective hf).symm x) = ↑x

full_name: MonoidHom.ker
code: /-- The multiplicative kernel of a monoid homomorphism is the subgroup of elements `x : G` such that
`f x = 1` -/
@[to_additive
      "The additive kernel of an `AddMonoid` homomorphism is the `AddSubgroup` of elements
      such that `f x = 0`"]
def ker (f : G →* M) : Subgroup G 
goal: Subgroup G

full_name: AddMonoidHom.ker
code: /-- The multiplicative kernel of a monoid homomorphism is the subgroup of elements `x : G` such that
`f x = 1` -/
@[to_additive
      "The additive kernel of an `AddMonoid` homomorphism is the `AddSubgroup` of elements
      such that `f x = 0`"]
def ker (f : G →* M) : Subgroup G 
goal: AddSubgroup G

full_name: AddMonoidHom.mem_ker
code: @[to_additive]
theorem mem_ker (f : G →* M) {x : G} : x ∈ f.ker ↔ f x = 1 
goal: x ∈ f.ker ↔ f x = 0

full_name: MonoidHom.mem_ker
code: @[to_additive]
theorem mem_ker (f : G →* M) {x : G} : x ∈ f.ker ↔ f x = 1 
goal: x ∈ f.ker ↔ f x = 1

full_name: MonoidHom.coe_ker
code: @[to_additive]
theorem coe_ker (f : G →* M) : (f.ker : Set G) = (f : G → M) ⁻¹' {1} 
goal: ↑f.ker = ⇑f ⁻¹' {1}

full_name: AddMonoidHom.coe_ker
code: @[to_additive]
theorem coe_ker (f : G →* M) : (f.ker : Set G) = (f : G → M) ⁻¹' {1} 
goal: ↑f.ker = ⇑f ⁻¹' {0}

full_name: MonoidHom.ker_toHomUnits
code: @[to_additive (attr := simp)]
theorem ker_toHomUnits {M} [Monoid M] (f : G →* M) : f.toHomUnits.ker = f.ker 
goal: f.toHomUnits.ker = f.ker

full_name: AddMonoidHom.ker_toHomAddUnits
code: @[to_additive (attr := simp)]
theorem ker_toHomUnits {M} [Monoid M] (f : G →* M) : f.toHomUnits.ker = f.ker 
goal: f.toHomAddUnits.ker = f.ker

full_name: AddMonoidHom.eq_iff
code: @[to_additive]
theorem eq_iff (f : G →* M) {x y : G} : f x = f y ↔ y⁻¹ * x ∈ f.ker 
goal: f x = f y ↔ -y + x ∈ f.ker

full_name: MonoidHom.eq_iff
code: @[to_additive]
theorem eq_iff (f : G →* M) {x y : G} : f x = f y ↔ y⁻¹ * x ∈ f.ker 
goal: f x = f y ↔ y⁻¹ * x ∈ f.ker

full_name: MonoidHom.decidableMemKer
code: @[to_additive]
instance decidableMemKer [DecidableEq M] (f : G →* M) : DecidablePred (· ∈ f.ker) 
goal: DecidablePred fun x => x ∈ f.ker

full_name: AddMonoidHom.decidableMemKer
code: @[to_additive]
instance decidableMemKer [DecidableEq M] (f : G →* M) : DecidablePred (· ∈ f.ker) 
goal: DecidablePred fun x => x ∈ f.ker

full_name: AddMonoidHom.comap_ker
code: @[to_additive]
theorem comap_ker (g : N →* P) (f : G →* N) : g.ker.comap f = (g.comp f).ker 
goal: AddSubgroup.comap f g.ker = (g.comp f).ker

full_name: MonoidHom.comap_ker
code: @[to_additive]
theorem comap_ker (g : N →* P) (f : G →* N) : g.ker.comap f = (g.comp f).ker 
goal: Subgroup.comap f g.ker = (g.comp f).ker

full_name: AddMonoidHom.comap_bot
code: @[to_additive (attr := simp)]
theorem comap_bot (f : G →* N) : (⊥ : Subgroup N).comap f = f.ker 
goal: AddSubgroup.comap f ⊥ = f.ker

full_name: MonoidHom.comap_bot
code: @[to_additive (attr := simp)]
theorem comap_bot (f : G →* N) : (⊥ : Subgroup N).comap f = f.ker 
goal: Subgroup.comap f ⊥ = f.ker

full_name: AddMonoidHom.ker_restrict
code: @[to_additive (attr := simp)]
theorem ker_restrict (f : G →* N) : (f.restrict K).ker = f.ker.subgroupOf K 
goal: (f.restrict K).ker = f.ker.addSubgroupOf K

full_name: MonoidHom.ker_restrict
code: @[to_additive (attr := simp)]
theorem ker_restrict (f : G →* N) : (f.restrict K).ker = f.ker.subgroupOf K 
goal: (f.restrict K).ker = f.ker.subgroupOf K

full_name: MonoidHom.ker_codRestrict
code: @[to_additive (attr := simp)]
theorem ker_codRestrict {S} [SetLike S N] [SubmonoidClass S N] (f : G →* N) (s : S)
    (h : ∀ x, f x ∈ s) : (f.codRestrict s h).ker = f.ker 
goal: (f.codRestrict s h).ker = f.ker

full_name: AddMonoidHom.ker_codRestrict
code: @[to_additive (attr := simp)]
theorem ker_codRestrict {S} [SetLike S N] [SubmonoidClass S N] (f : G →* N) (s : S)
    (h : ∀ x, f x ∈ s) : (f.codRestrict s h).ker = f.ker 
goal: (f.codRestrict s h).ker = f.ker

full_name: AddMonoidHom.ker_rangeRestrict
code: @[to_additive (attr := simp)]
theorem ker_rangeRestrict (f : G →* N) : ker (rangeRestrict f) = ker f 
goal: f.rangeRestrict.ker = f.ker

full_name: MonoidHom.ker_rangeRestrict
code: @[to_additive (attr := simp)]
theorem ker_rangeRestrict (f : G →* N) : ker (rangeRestrict f) = ker f 
goal: f.rangeRestrict.ker = f.ker

full_name: MonoidHom.ker_one
code: @[to_additive (attr := simp)]
theorem ker_one : (1 : G →* M).ker = ⊤ 
goal: MonoidHom.ker 1 = ⊤

full_name: AddMonoidHom.ker_zero
code: @[to_additive (attr := simp)]
theorem ker_one : (1 : G →* M).ker = ⊤ 
goal: AddMonoidHom.ker 0 = ⊤

full_name: AddMonoidHom.ker_id
code: @[to_additive (attr := simp)]
theorem ker_id : (MonoidHom.id G).ker = ⊥ 
goal: (AddMonoidHom.id G).ker = ⊥

full_name: MonoidHom.ker_id
code: @[to_additive (attr := simp)]
theorem ker_id : (MonoidHom.id G).ker = ⊥ 
goal: (MonoidHom.id G).ker = ⊥

full_name: MonoidHom.ker_eq_bot_iff
code: @[to_additive]
theorem ker_eq_bot_iff (f : G →* M) : f.ker = ⊥ ↔ Function.Injective f 
goal: f.ker = ⊥ ↔ Function.Injective ⇑f

full_name: AddMonoidHom.ker_eq_bot_iff
code: @[to_additive]
theorem ker_eq_bot_iff (f : G →* M) : f.ker = ⊥ ↔ Function.Injective f 
goal: f.ker = ⊥ ↔ Function.Injective ⇑f

full_name: Subgroup.ker_subtype
code: @[to_additive (attr := simp)]
theorem _root_.Subgroup.ker_subtype (H : Subgroup G) : H.subtype.ker = ⊥ 
goal: H.subtype.ker = ⊥

full_name: AddSubgroup.ker_subtype
code: @[to_additive (attr := simp)]
theorem _root_.Subgroup.ker_subtype (H : Subgroup G) : H.subtype.ker = ⊥ 
goal: H.subtype.ker = ⊥

full_name: AddSubgroup.ker_inclusion
code: @[to_additive (attr := simp)]
theorem _root_.Subgroup.ker_inclusion {H K : Subgroup G} (h : H ≤ K) : (inclusion h).ker = ⊥ 
goal: (AddSubgroup.inclusion h).ker = ⊥

full_name: Subgroup.ker_inclusion
code: @[to_additive (attr := simp)]
theorem _root_.Subgroup.ker_inclusion {H K : Subgroup G} (h : H ≤ K) : (inclusion h).ker = ⊥ 
goal: (Subgroup.inclusion h).ker = ⊥

full_name: AddMonoidHom.ker_sum
code: @[to_additive]
theorem ker_prod {M N : Type*} [MulOneClass M] [MulOneClass N] (f : G →* M) (g : G →* N) :
    (f.prod g).ker = f.ker ⊓ g.ker 
goal: (f.prod g).ker = f.ker ⊓ g.ker

full_name: MonoidHom.ker_prod
code: @[to_additive]
theorem ker_prod {M N : Type*} [MulOneClass M] [MulOneClass N] (f : G →* M) (g : G →* N) :
    (f.prod g).ker = f.ker ⊓ g.ker 
goal: (f.prod g).ker = f.ker ⊓ g.ker

full_name: MonoidHom.prodMap_comap_prod
code: @[to_additive]
theorem prodMap_comap_prod {G' : Type*} {N' : Type*} [Group G'] [Group N'] (f : G →* N)
    (g : G' →* N') (S : Subgroup N) (S' : Subgroup N') :
    (S.prod S').comap (prodMap f g) = (S.comap f).prod (S'.comap g) 
goal: Subgroup.comap (f.prodMap g) (S.prod S') = (Subgroup.comap f S).prod (Subgroup.comap g S')

full_name: AddMonoidHom.sumMap_comap_sum
code: @[to_additive]
theorem prodMap_comap_prod {G' : Type*} {N' : Type*} [Group G'] [Group N'] (f : G →* N)
    (g : G' →* N') (S : Subgroup N) (S' : Subgroup N') :
    (S.prod S').comap (prodMap f g) = (S.comap f).prod (S'.comap g) 
goal: AddSubgroup.comap (f.prodMap g) (S.prod S') = (AddSubgroup.comap f S).prod (AddSubgroup.comap g S')

full_name: MonoidHom.ker_prodMap
code: @[to_additive]
theorem ker_prodMap {G' : Type*} {N' : Type*} [Group G'] [Group N'] (f : G →* N) (g : G' →* N') :
    (prodMap f g).ker = f.ker.prod g.ker 
goal: (f.prodMap g).ker = f.ker.prod g.ker

full_name: AddMonoidHom.ker_sumMap
code: @[to_additive]
theorem ker_prodMap {G' : Type*} {N' : Type*} [Group G'] [Group N'] (f : G →* N) (g : G' →* N') :
    (prodMap f g).ker = f.ker.prod g.ker 
goal: (f.prodMap g).ker = f.ker.prod g.ker

full_name: AddMonoidHom.range_le_ker_iff
code: @[to_additive]
theorem range_le_ker_iff (f : G →* G') (g : G' →* G'') : f.range ≤ g.ker ↔ g.comp f = 1 
goal: f.range ≤ g.ker ↔ g.comp f = 0

full_name: MonoidHom.range_le_ker_iff
code: @[to_additive]
theorem range_le_ker_iff (f : G →* G') (g : G' →* G'') : f.range ≤ g.ker ↔ g.comp f = 1 
goal: f.range ≤ g.ker ↔ g.comp f = 1

full_name: AddMonoidHom.normal_ker
code: @[to_additive]
instance (priority := 100) normal_ker (f : G →* M) : f.ker.Normal 
goal: f.ker.Normal

full_name: MonoidHom.normal_ker
code: @[to_additive]
instance (priority := 100) normal_ker (f : G →* M) : f.ker.Normal 
goal: f.ker.Normal

full_name: AddMonoidHom.ker_fst
code: @[to_additive (attr := simp)]
lemma ker_fst : ker (fst G G') = .prod ⊥ ⊤ 
goal: (AddMonoidHom.fst G G').ker = ⊥.prod ⊤

full_name: MonoidHom.ker_fst
code: @[to_additive (attr := simp)]
lemma ker_fst : ker (fst G G') = .prod ⊥ ⊤ 
goal: (MonoidHom.fst G G').ker = ⊥.prod ⊤

full_name: AddMonoidHom.ker_snd
code: @[to_additive (attr := simp)]
lemma ker_snd : ker (snd G G') = .prod ⊤ ⊥ 
goal: (AddMonoidHom.snd G G').ker = ⊤.prod ⊥

full_name: MonoidHom.ker_snd
code: @[to_additive (attr := simp)]
lemma ker_snd : ker (snd G G') = .prod ⊤ ⊥ 
goal: (MonoidHom.snd G G').ker = ⊤.prod ⊥

full_name: MonoidHom.coe_toAdditive_ker
code: @[simp]
theorem coe_toAdditive_ker (f : G →* G') :
    (MonoidHom.toAdditive f).ker = Subgroup.toAddSubgroup f.ker 
goal: (MonoidHom.toAdditive f).ker = Subgroup.toAddSubgroup f.ker

full_name: MonoidHom.coe_toMultiplicative_ker
code: @[simp]
theorem coe_toMultiplicative_ker {A A' : Type*} [AddGroup A] [AddGroup A'] (f : A →+ A') :
    (AddMonoidHom.toMultiplicative f).ker = AddSubgroup.toSubgroup f.ker 
goal: (AddMonoidHom.toMultiplicative f).ker = AddSubgroup.toSubgroup f.ker

full_name: AddMonoidHom.eqLocus
code: /-- The subgroup of elements `x : G` such that `f x = g x` -/
@[to_additive "The additive subgroup of elements `x : G` such that `f x = g x`"]
def eqLocus (f g : G →* M) : Subgroup G 
goal: AddSubgroup G

full_name: MonoidHom.eqLocus
code: /-- The subgroup of elements `x : G` such that `f x = g x` -/
@[to_additive "The additive subgroup of elements `x : G` such that `f x = g x`"]
def eqLocus (f g : G →* M) : Subgroup G 
goal: Subgroup G

full_name: AddMonoidHom.eqLocus_same
code: @[to_additive (attr := simp)]
theorem eqLocus_same (f : G →* N) : f.eqLocus f = ⊤ 
goal: f.eqLocus f = ⊤

full_name: MonoidHom.eqLocus_same
code: @[to_additive (attr := simp)]
theorem eqLocus_same (f : G →* N) : f.eqLocus f = ⊤ 
goal: f.eqLocus f = ⊤

full_name: AddMonoidHom.eqOn_closure
code: /-- If two monoid homomorphisms are equal on a set, then they are equal on its subgroup closure. -/
@[to_additive
      "If two monoid homomorphisms are equal on a set, then they are equal on its subgroup
      closure."]
theorem eqOn_closure {f g : G →* M} {s : Set G} (h : Set.EqOn f g s) : Set.EqOn f g (closure s) 
goal: Set.EqOn ⇑f ⇑g ↑(AddSubgroup.closure s)

full_name: MonoidHom.eqOn_closure
code: /-- If two monoid homomorphisms are equal on a set, then they are equal on its subgroup closure. -/
@[to_additive
      "If two monoid homomorphisms are equal on a set, then they are equal on its subgroup
      closure."]
theorem eqOn_closure {f g : G →* M} {s : Set G} (h : Set.EqOn f g s) : Set.EqOn f g (closure s) 
goal: Set.EqOn ⇑f ⇑g ↑(Subgroup.closure s)

full_name: AddMonoidHom.eq_of_eqOn_top
code: @[to_additive]
theorem eq_of_eqOn_top {f g : G →* M} (h : Set.EqOn f g (⊤ : Subgroup G)) : f = g 
goal: f = g

full_name: MonoidHom.eq_of_eqOn_top
code: @[to_additive]
theorem eq_of_eqOn_top {f g : G →* M} (h : Set.EqOn f g (⊤ : Subgroup G)) : f = g 
goal: f = g

full_name: MonoidHom.eq_of_eqOn_dense
code: @[to_additive]
theorem eq_of_eqOn_dense {s : Set G} (hs : closure s = ⊤) {f g : G →* M} (h : s.EqOn f g) : f = g 
goal: f = g

full_name: AddMonoidHom.eq_of_eqOn_dense
code: @[to_additive]
theorem eq_of_eqOn_dense {s : Set G} (hs : closure s = ⊤) {f g : G →* M} (h : s.EqOn f g) : f = g 
goal: f = g

full_name: AddMonoidHom.closure_preimage_le
code: @[to_additive]
theorem closure_preimage_le (f : G →* N) (s : Set N) : closure (f ⁻¹' s) ≤ (closure s).comap f 
goal: AddSubgroup.closure (⇑f ⁻¹' s) ≤ AddSubgroup.comap f (AddSubgroup.closure s)

full_name: MonoidHom.closure_preimage_le
code: @[to_additive]
theorem closure_preimage_le (f : G →* N) (s : Set N) : closure (f ⁻¹' s) ≤ (closure s).comap f 
goal: Subgroup.closure (⇑f ⁻¹' s) ≤ Subgroup.comap f (Subgroup.closure s)

full_name: AddMonoidHom.map_closure
code: /-- The image under a monoid homomorphism of the subgroup generated by a set equals the subgroup
generated by the image of the set. -/
@[to_additive
      "The image under an `AddMonoid` hom of the `AddSubgroup` generated by a set equals
      the `AddSubgroup` generated by the image of the set."]
theorem map_closure (f : G →* N) (s : Set G) : (closure s).map f = closure (f '' s) 
goal: AddSubgroup.map f (AddSubgroup.closure s) = AddSubgroup.closure (⇑f '' s)

full_name: MonoidHom.map_closure
code: /-- The image under a monoid homomorphism of the subgroup generated by a set equals the subgroup
generated by the image of the set. -/
@[to_additive
      "The image under an `AddMonoid` hom of the `AddSubgroup` generated by a set equals
      the `AddSubgroup` generated by the image of the set."]
theorem map_closure (f : G →* N) (s : Set G) : (closure s).map f = closure (f '' s) 
goal: Subgroup.map f (Subgroup.closure s) = Subgroup.closure (⇑f '' s)

full_name: Subgroup.Normal.map
code: @[to_additive]
theorem Normal.map {H : Subgroup G} (h : H.Normal) (f : G →* N) (hf : Function.Surjective f) :
    (H.map f).Normal 
goal: (Subgroup.map f H).Normal

full_name: AddSubgroup.Normal.map
code: @[to_additive]
theorem Normal.map {H : Subgroup G} (h : H.Normal) (f : G →* N) (hf : Function.Surjective f) :
    (H.map f).Normal 
goal: (AddSubgroup.map f H).Normal

full_name: Subgroup.map_eq_bot_iff
code: @[to_additive]
theorem map_eq_bot_iff {f : G →* N} : H.map f = ⊥ ↔ H ≤ f.ker 
goal: Subgroup.map f H = ⊥ ↔ H ≤ f.ker

full_name: AddSubgroup.map_eq_bot_iff
code: @[to_additive]
theorem map_eq_bot_iff {f : G →* N} : H.map f = ⊥ ↔ H ≤ f.ker 
goal: AddSubgroup.map f H = ⊥ ↔ H ≤ f.ker

full_name: Subgroup.map_eq_bot_iff_of_injective
code: @[to_additive]
theorem map_eq_bot_iff_of_injective {f : G →* N} (hf : Function.Injective f) :
    H.map f = ⊥ ↔ H = ⊥ 
goal: Subgroup.map f H = ⊥ ↔ H = ⊥

full_name: AddSubgroup.map_eq_bot_iff_of_injective
code: @[to_additive]
theorem map_eq_bot_iff_of_injective {f : G →* N} (hf : Function.Injective f) :
    H.map f = ⊥ ↔ H = ⊥ 
goal: AddSubgroup.map f H = ⊥ ↔ H = ⊥

full_name: AddSubgroup.map_le_range
code: @[to_additive]
theorem map_le_range (H : Subgroup G) : map f H ≤ f.range 
goal: AddSubgroup.map f H ≤ f.range

full_name: Subgroup.map_le_range
code: @[to_additive]
theorem map_le_range (H : Subgroup G) : map f H ≤ f.range 
goal: Subgroup.map f H ≤ f.range

full_name: AddSubgroup.map_subtype_le
code: @[to_additive]
theorem map_subtype_le {H : Subgroup G} (K : Subgroup H) : K.map H.subtype ≤ H 
goal: AddSubgroup.map H.subtype K ≤ H

full_name: Subgroup.map_subtype_le
code: @[to_additive]
theorem map_subtype_le {H : Subgroup G} (K : Subgroup H) : K.map H.subtype ≤ H 
goal: Subgroup.map H.subtype K ≤ H

full_name: Subgroup.ker_le_comap
code: @[to_additive]
theorem ker_le_comap (H : Subgroup N) : f.ker ≤ comap f H 
goal: f.ker ≤ Subgroup.comap f H

full_name: AddSubgroup.ker_le_comap
code: @[to_additive]
theorem ker_le_comap (H : Subgroup N) : f.ker ≤ comap f H 
goal: f.ker ≤ AddSubgroup.comap f H

full_name: Subgroup.map_comap_le
code: @[to_additive]
theorem map_comap_le (H : Subgroup N) : map f (comap f H) ≤ H 
goal: Subgroup.map f (Subgroup.comap f H) ≤ H

full_name: AddSubgroup.map_comap_le
code: @[to_additive]
theorem map_comap_le (H : Subgroup N) : map f (comap f H) ≤ H 
goal: AddSubgroup.map f (AddSubgroup.comap f H) ≤ H

full_name: Subgroup.le_comap_map
code: @[to_additive]
theorem le_comap_map (H : Subgroup G) : H ≤ comap f (map f H) 
goal: H ≤ Subgroup.comap f (Subgroup.map f H)

full_name: AddSubgroup.le_comap_map
code: @[to_additive]
theorem le_comap_map (H : Subgroup G) : H ≤ comap f (map f H) 
goal: H ≤ AddSubgroup.comap f (AddSubgroup.map f H)

full_name: AddSubgroup.map_comap_eq
code: @[to_additive]
theorem map_comap_eq (H : Subgroup N) : map f (comap f H) = f.range ⊓ H 
goal: AddSubgroup.map f (AddSubgroup.comap f H) = f.range ⊓ H

full_name: Subgroup.map_comap_eq
code: @[to_additive]
theorem map_comap_eq (H : Subgroup N) : map f (comap f H) = f.range ⊓ H 
goal: Subgroup.map f (Subgroup.comap f H) = f.range ⊓ H

full_name: AddSubgroup.comap_map_eq
code: @[to_additive]
theorem comap_map_eq (H : Subgroup G) : comap f (map f H) = H ⊔ f.ker 
goal: AddSubgroup.comap f (AddSubgroup.map f H) = H ⊔ f.ker

full_name: Subgroup.comap_map_eq
code: @[to_additive]
theorem comap_map_eq (H : Subgroup G) : comap f (map f H) = H ⊔ f.ker 
goal: Subgroup.comap f (Subgroup.map f H) = H ⊔ f.ker

full_name: Subgroup.map_comap_eq_self
code: @[to_additive]
theorem map_comap_eq_self {f : G →* N} {H : Subgroup N} (h : H ≤ f.range) :
    map f (comap f H) = H 
goal: Subgroup.map f (Subgroup.comap f H) = H

full_name: AddSubgroup.map_comap_eq_self
code: @[to_additive]
theorem map_comap_eq_self {f : G →* N} {H : Subgroup N} (h : H ≤ f.range) :
    map f (comap f H) = H 
goal: AddSubgroup.map f (AddSubgroup.comap f H) = H

full_name: AddSubgroup.map_comap_eq_self_of_surjective
code: @[to_additive]
theorem map_comap_eq_self_of_surjective {f : G →* N} (h : Function.Surjective f) (H : Subgroup N) :
    map f (comap f H) = H 
goal: AddSubgroup.map f (AddSubgroup.comap f H) = H

full_name: Subgroup.map_comap_eq_self_of_surjective
code: @[to_additive]
theorem map_comap_eq_self_of_surjective {f : G →* N} (h : Function.Surjective f) (H : Subgroup N) :
    map f (comap f H) = H 
goal: Subgroup.map f (Subgroup.comap f H) = H

full_name: Subgroup.comap_le_comap_of_le_range
code: @[to_additive]
theorem comap_le_comap_of_le_range {f : G →* N} {K L : Subgroup N} (hf : K ≤ f.range) :
    K.comap f ≤ L.comap f ↔ K ≤ L 
goal: Subgroup.comap f K ≤ Subgroup.comap f L ↔ K ≤ L

full_name: AddSubgroup.comap_le_comap_of_le_range
code: @[to_additive]
theorem comap_le_comap_of_le_range {f : G →* N} {K L : Subgroup N} (hf : K ≤ f.range) :
    K.comap f ≤ L.comap f ↔ K ≤ L 
goal: AddSubgroup.comap f K ≤ AddSubgroup.comap f L ↔ K ≤ L

full_name: Subgroup.comap_le_comap_of_surjective
code: @[to_additive]
theorem comap_le_comap_of_surjective {f : G →* N} {K L : Subgroup N} (hf : Function.Surjective f) :
    K.comap f ≤ L.comap f ↔ K ≤ L 
goal: Subgroup.comap f K ≤ Subgroup.comap f L ↔ K ≤ L

full_name: AddSubgroup.comap_le_comap_of_surjective
code: @[to_additive]
theorem comap_le_comap_of_surjective {f : G →* N} {K L : Subgroup N} (hf : Function.Surjective f) :
    K.comap f ≤ L.comap f ↔ K ≤ L 
goal: AddSubgroup.comap f K ≤ AddSubgroup.comap f L ↔ K ≤ L

full_name: AddSubgroup.comap_lt_comap_of_surjective
code: @[to_additive]
theorem comap_lt_comap_of_surjective {f : G →* N} {K L : Subgroup N} (hf : Function.Surjective f) :
    K.comap f < L.comap f ↔ K < L 
goal: AddSubgroup.comap f K < AddSubgroup.comap f L ↔ K < L

full_name: Subgroup.comap_lt_comap_of_surjective
code: @[to_additive]
theorem comap_lt_comap_of_surjective {f : G →* N} {K L : Subgroup N} (hf : Function.Surjective f) :
    K.comap f < L.comap f ↔ K < L 
goal: Subgroup.comap f K < Subgroup.comap f L ↔ K < L

full_name: AddSubgroup.comap_injective
code: @[to_additive]
theorem comap_injective {f : G →* N} (h : Function.Surjective f) : Function.Injective (comap f) 
goal: Function.Injective (AddSubgroup.comap f)

full_name: Subgroup.comap_injective
code: @[to_additive]
theorem comap_injective {f : G →* N} (h : Function.Surjective f) : Function.Injective (comap f) 
goal: Function.Injective (Subgroup.comap f)

full_name: Subgroup.comap_map_eq_self
code: @[to_additive]
theorem comap_map_eq_self {f : G →* N} {H : Subgroup G} (h : f.ker ≤ H) :
    comap f (map f H) = H 
goal: Subgroup.comap f (Subgroup.map f H) = H

full_name: AddSubgroup.comap_map_eq_self
code: @[to_additive]
theorem comap_map_eq_self {f : G →* N} {H : Subgroup G} (h : f.ker ≤ H) :
    comap f (map f H) = H 
goal: AddSubgroup.comap f (AddSubgroup.map f H) = H

full_name: Subgroup.comap_map_eq_self_of_injective
code: @[to_additive]
theorem comap_map_eq_self_of_injective {f : G →* N} (h : Function.Injective f) (H : Subgroup G) :
    comap f (map f H) = H 
goal: Subgroup.comap f (Subgroup.map f H) = H

full_name: AddSubgroup.comap_map_eq_self_of_injective
code: @[to_additive]
theorem comap_map_eq_self_of_injective {f : G →* N} (h : Function.Injective f) (H : Subgroup G) :
    comap f (map f H) = H 
goal: AddSubgroup.comap f (AddSubgroup.map f H) = H

full_name: AddSubgroup.map_le_map_iff
code: @[to_additive]
theorem map_le_map_iff {f : G →* N} {H K : Subgroup G} : H.map f ≤ K.map f ↔ H ≤ K ⊔ f.ker 
goal: AddSubgroup.map f H ≤ AddSubgroup.map f K ↔ H ≤ K ⊔ f.ker

full_name: Subgroup.map_le_map_iff
code: @[to_additive]
theorem map_le_map_iff {f : G →* N} {H K : Subgroup G} : H.map f ≤ K.map f ↔ H ≤ K ⊔ f.ker 
goal: Subgroup.map f H ≤ Subgroup.map f K ↔ H ≤ K ⊔ f.ker

full_name: Subgroup.map_le_map_iff'
code: @[to_additive]
theorem map_le_map_iff' {f : G →* N} {H K : Subgroup G} :
    H.map f ≤ K.map f ↔ H ⊔ f.ker ≤ K ⊔ f.ker 
goal: Subgroup.map f H ≤ Subgroup.map f K ↔ H ⊔ f.ker ≤ K ⊔ f.ker

full_name: AddSubgroup.map_le_map_iff'
code: @[to_additive]
theorem map_le_map_iff' {f : G →* N} {H K : Subgroup G} :
    H.map f ≤ K.map f ↔ H ⊔ f.ker ≤ K ⊔ f.ker 
goal: AddSubgroup.map f H ≤ AddSubgroup.map f K ↔ H ⊔ f.ker ≤ K ⊔ f.ker

full_name: Subgroup.map_eq_map_iff
code: @[to_additive]
theorem map_eq_map_iff {f : G →* N} {H K : Subgroup G} :
    H.map f = K.map f ↔ H ⊔ f.ker = K ⊔ f.ker 
goal: Subgroup.map f H = Subgroup.map f K ↔ H ⊔ f.ker = K ⊔ f.ker

full_name: AddSubgroup.map_eq_map_iff
code: @[to_additive]
theorem map_eq_map_iff {f : G →* N} {H K : Subgroup G} :
    H.map f = K.map f ↔ H ⊔ f.ker = K ⊔ f.ker 
goal: AddSubgroup.map f H = AddSubgroup.map f K ↔ H ⊔ f.ker = K ⊔ f.ker

full_name: Subgroup.map_eq_range_iff
code: @[to_additive]
theorem map_eq_range_iff {f : G →* N} {H : Subgroup G} :
    H.map f = f.range ↔ Codisjoint H f.ker 
goal: Subgroup.map f H = f.range ↔ Codisjoint H f.ker

full_name: AddSubgroup.map_eq_range_iff
code: @[to_additive]
theorem map_eq_range_iff {f : G →* N} {H : Subgroup G} :
    H.map f = f.range ↔ Codisjoint H f.ker 
goal: AddSubgroup.map f H = f.range ↔ Codisjoint H f.ker

full_name: AddSubgroup.map_le_map_iff_of_injective
code: @[to_additive]
theorem map_le_map_iff_of_injective {f : G →* N} (hf : Function.Injective f) {H K : Subgroup G} :
    H.map f ≤ K.map f ↔ H ≤ K 
goal: AddSubgroup.map f H ≤ AddSubgroup.map f K ↔ H ≤ K

full_name: Subgroup.map_le_map_iff_of_injective
code: @[to_additive]
theorem map_le_map_iff_of_injective {f : G →* N} (hf : Function.Injective f) {H K : Subgroup G} :
    H.map f ≤ K.map f ↔ H ≤ K 
goal: Subgroup.map f H ≤ Subgroup.map f K ↔ H ≤ K

full_name: AddSubgroup.map_subtype_le_map_subtype
code: @[to_additive (attr := simp)]
theorem map_subtype_le_map_subtype {G' : Subgroup G} {H K : Subgroup G'} :
    H.map G'.subtype ≤ K.map G'.subtype ↔ H ≤ K 
goal: AddSubgroup.map G'.subtype H ≤ AddSubgroup.map G'.subtype K ↔ H ≤ K

full_name: Subgroup.map_subtype_le_map_subtype
code: @[to_additive (attr := simp)]
theorem map_subtype_le_map_subtype {G' : Subgroup G} {H K : Subgroup G'} :
    H.map G'.subtype ≤ K.map G'.subtype ↔ H ≤ K 
goal: Subgroup.map G'.subtype H ≤ Subgroup.map G'.subtype K ↔ H ≤ K

full_name: Subgroup.map_injective
code: @[to_additive]
theorem map_injective {f : G →* N} (h : Function.Injective f) : Function.Injective (map f) 
goal: Function.Injective (Subgroup.map f)

full_name: AddSubgroup.map_injective
code: @[to_additive]
theorem map_injective {f : G →* N} (h : Function.Injective f) : Function.Injective (map f) 
goal: Function.Injective (AddSubgroup.map f)

full_name: AddSubgroup.map_eq_comap_of_inverse
code: @[to_additive]
theorem map_eq_comap_of_inverse {f : G →* N} {g : N →* G} (hl : Function.LeftInverse g f)
    (hr : Function.RightInverse g f) (H : Subgroup G) : map f H = comap g H 
goal: AddSubgroup.map f H = AddSubgroup.comap g H

full_name: Subgroup.map_eq_comap_of_inverse
code: @[to_additive]
theorem map_eq_comap_of_inverse {f : G →* N} {g : N →* G} (hl : Function.LeftInverse g f)
    (hr : Function.RightInverse g f) (H : Subgroup G) : map f H = comap g H 
goal: Subgroup.map f H = Subgroup.comap g H

full_name: AddSubgroup.map_injective_of_ker_le
code: /-- Given `f(A) = f(B)`, `ker f ≤ A`, and `ker f ≤ B`, deduce that `A = B`. -/
@[to_additive "Given `f(A) = f(B)`, `ker f ≤ A`, and `ker f ≤ B`, deduce that `A = B`."]
theorem map_injective_of_ker_le {H K : Subgroup G} (hH : f.ker ≤ H) (hK : f.ker ≤ K)
    (hf : map f H = map f K) : H = K 
goal: H = K

full_name: Subgroup.map_injective_of_ker_le
code: /-- Given `f(A) = f(B)`, `ker f ≤ A`, and `ker f ≤ B`, deduce that `A = B`. -/
@[to_additive "Given `f(A) = f(B)`, `ker f ≤ A`, and `ker f ≤ B`, deduce that `A = B`."]
theorem map_injective_of_ker_le {H K : Subgroup G} (hH : f.ker ≤ H) (hK : f.ker ≤ K)
    (hf : map f H = map f K) : H = K 
goal: H = K

full_name: Subgroup.closure_preimage_eq_top
code: @[to_additive]
theorem closure_preimage_eq_top (s : Set G) : closure ((closure s).subtype ⁻¹' s) = ⊤ 
goal: Subgroup.closure (⇑(Subgroup.closure s).subtype ⁻¹' s) = ⊤

full_name: AddSubgroup.closure_preimage_eq_top
code: @[to_additive]
theorem closure_preimage_eq_top (s : Set G) : closure ((closure s).subtype ⁻¹' s) = ⊤ 
goal: AddSubgroup.closure (⇑(AddSubgroup.closure s).subtype ⁻¹' s) = ⊤

full_name: Subgroup.comap_sup_eq_of_le_range
code: @[to_additive]
theorem comap_sup_eq_of_le_range {H K : Subgroup N} (hH : H ≤ f.range) (hK : K ≤ f.range) :
    comap f H ⊔ comap f K = comap f (H ⊔ K) 
goal: Subgroup.comap f H ⊔ Subgroup.comap f K = Subgroup.comap f (H ⊔ K)

full_name: AddSubgroup.comap_sup_eq_of_le_range
code: @[to_additive]
theorem comap_sup_eq_of_le_range {H K : Subgroup N} (hH : H ≤ f.range) (hK : K ≤ f.range) :
    comap f H ⊔ comap f K = comap f (H ⊔ K) 
goal: AddSubgroup.comap f H ⊔ AddSubgroup.comap f K = AddSubgroup.comap f (H ⊔ K)

full_name: AddSubgroup.comap_sup_eq
code: @[to_additive]
theorem comap_sup_eq (H K : Subgroup N) (hf : Function.Surjective f) :
    comap f H ⊔ comap f K = comap f (H ⊔ K) 
goal: AddSubgroup.comap f H ⊔ AddSubgroup.comap f K = AddSubgroup.comap f (H ⊔ K)

full_name: Subgroup.comap_sup_eq
code: @[to_additive]
theorem comap_sup_eq (H K : Subgroup N) (hf : Function.Surjective f) :
    comap f H ⊔ comap f K = comap f (H ⊔ K) 
goal: Subgroup.comap f H ⊔ Subgroup.comap f K = Subgroup.comap f (H ⊔ K)

full_name: AddSubgroup.sup_addSubgroupOf_eq
code: @[to_additive]
theorem sup_subgroupOf_eq {H K L : Subgroup G} (hH : H ≤ L) (hK : K ≤ L) :
    H.subgroupOf L ⊔ K.subgroupOf L = (H ⊔ K).subgroupOf L 
goal: H.addSubgroupOf L ⊔ K.addSubgroupOf L = (H ⊔ K).addSubgroupOf L

full_name: Subgroup.sup_subgroupOf_eq
code: @[to_additive]
theorem sup_subgroupOf_eq {H K L : Subgroup G} (hH : H ≤ L) (hK : K ≤ L) :
    H.subgroupOf L ⊔ K.subgroupOf L = (H ⊔ K).subgroupOf L 
goal: H.subgroupOf L ⊔ K.subgroupOf L = (H ⊔ K).subgroupOf L

full_name: Subgroup.codisjoint_subgroupOf_sup
code: @[to_additive]
theorem codisjoint_subgroupOf_sup (H K : Subgroup G) :
    Codisjoint (H.subgroupOf (H ⊔ K)) (K.subgroupOf (H ⊔ K)) 
goal: Codisjoint (H.subgroupOf (H ⊔ K)) (K.subgroupOf (H ⊔ K))

full_name: AddSubgroup.codisjoint_addSubgroupOf_sup
code: @[to_additive]
theorem codisjoint_subgroupOf_sup (H K : Subgroup G) :
    Codisjoint (H.subgroupOf (H ⊔ K)) (K.subgroupOf (H ⊔ K)) 
goal: Codisjoint (H.addSubgroupOf (H ⊔ K)) (K.addSubgroupOf (H ⊔ K))

full_name: AddSubgroup.equivMapOfInjective
code: /-- A subgroup is isomorphic to its image under an injective function. If you have an isomorphism,
use `MulEquiv.subgroupMap` for better definitional equalities. -/
@[to_additive
      "An additive subgroup is isomorphic to its image under an injective function. If you
      have an isomorphism, use `AddEquiv.addSubgroupMap` for better definitional equalities."]
noncomputable def equivMapOfInjective (H : Subgroup G) (f : G →* N) (hf : Function.Injective f) :
    H ≃* H.map f 
goal: ↥H ≃+ ↥(AddSubgroup.map f H)

full_name: Subgroup.equivMapOfInjective
code: /-- A subgroup is isomorphic to its image under an injective function. If you have an isomorphism,
use `MulEquiv.subgroupMap` for better definitional equalities. -/
@[to_additive
      "An additive subgroup is isomorphic to its image under an injective function. If you
      have an isomorphism, use `AddEquiv.addSubgroupMap` for better definitional equalities."]
noncomputable def equivMapOfInjective (H : Subgroup G) (f : G →* N) (hf : Function.Injective f) :
    H ≃* H.map f 
goal: ↥H ≃* ↥(Subgroup.map f H)

full_name: Subgroup.coe_equivMapOfInjective_apply
code: @[to_additive (attr := simp)]
theorem coe_equivMapOfInjective_apply (H : Subgroup G) (f : G →* N) (hf : Function.Injective f)
    (h : H) : (equivMapOfInjective H f hf h : N) = f h 
goal: ↑((H.equivMapOfInjective f hf) h) = f ↑h

full_name: AddSubgroup.coe_equivMapOfInjective_apply
code: @[to_additive (attr := simp)]
theorem coe_equivMapOfInjective_apply (H : Subgroup G) (f : G →* N) (hf : Function.Injective f)
    (h : H) : (equivMapOfInjective H f hf h : N) = f h 
goal: ↑((H.equivMapOfInjective f hf) h) = f ↑h

full_name: AddSubgroup.comap_normalizer_eq_of_surjective
code: /-- The preimage of the normalizer is equal to the normalizer of the preimage of a surjective
  function. -/
@[to_additive
      "The preimage of the normalizer is equal to the normalizer of the preimage of
      a surjective function."]
theorem comap_normalizer_eq_of_surjective (H : Subgroup G) {f : N →* G}
    (hf : Function.Surjective f) : H.normalizer.comap f = (H.comap f).normalizer 
goal: AddSubgroup.comap f H.normalizer = (AddSubgroup.comap f H).normalizer

full_name: Subgroup.comap_normalizer_eq_of_surjective
code: /-- The preimage of the normalizer is equal to the normalizer of the preimage of a surjective
  function. -/
@[to_additive
      "The preimage of the normalizer is equal to the normalizer of the preimage of
      a surjective function."]
theorem comap_normalizer_eq_of_surjective (H : Subgroup G) {f : N →* G}
    (hf : Function.Surjective f) : H.normalizer.comap f = (H.comap f).normalizer 
goal: Subgroup.comap f H.normalizer = (Subgroup.comap f H).normalizer

full_name: AddSubgroup.comap_normalizer_eq_of_injective_of_le_range
code: @[to_additive]
theorem comap_normalizer_eq_of_injective_of_le_range {N : Type*} [Group N] (H : Subgroup G)
    {f : N →* G} (hf : Function.Injective f) (h : H.normalizer ≤ f.range) :
    comap f H.normalizer = (comap f H).normalizer 
goal: AddSubgroup.comap f H.normalizer = (AddSubgroup.comap f H).normalizer

full_name: Subgroup.comap_normalizer_eq_of_injective_of_le_range
code: @[to_additive]
theorem comap_normalizer_eq_of_injective_of_le_range {N : Type*} [Group N] (H : Subgroup G)
    {f : N →* G} (hf : Function.Injective f) (h : H.normalizer ≤ f.range) :
    comap f H.normalizer = (comap f H).normalizer 
goal: Subgroup.comap f H.normalizer = (Subgroup.comap f H).normalizer

full_name: Subgroup.subgroupOf_normalizer_eq
code: @[to_additive]
theorem subgroupOf_normalizer_eq {H N : Subgroup G} (h : H.normalizer ≤ N) :
    H.normalizer.subgroupOf N = (H.subgroupOf N).normalizer 
goal: H.normalizer.subgroupOf N = (H.subgroupOf N).normalizer

full_name: AddSubgroup.addSubgroupOf_normalizer_eq
code: @[to_additive]
theorem subgroupOf_normalizer_eq {H N : Subgroup G} (h : H.normalizer ≤ N) :
    H.normalizer.subgroupOf N = (H.subgroupOf N).normalizer 
goal: H.normalizer.addSubgroupOf N = (H.addSubgroupOf N).normalizer

full_name: AddSubgroup.map_equiv_normalizer_eq
code: /-- The image of the normalizer is equal to the normalizer of the image of an isomorphism. -/
@[to_additive
      "The image of the normalizer is equal to the normalizer of the image of an
      isomorphism."]
theorem map_equiv_normalizer_eq (H : Subgroup G) (f : G ≃* N) :
    H.normalizer.map f.toMonoidHom = (H.map f.toMonoidHom).normalizer 
goal: AddSubgroup.map f.toAddMonoidHom H.normalizer = (AddSubgroup.map f.toAddMonoidHom H).normalizer

full_name: Subgroup.map_equiv_normalizer_eq
code: /-- The image of the normalizer is equal to the normalizer of the image of an isomorphism. -/
@[to_additive
      "The image of the normalizer is equal to the normalizer of the image of an
      isomorphism."]
theorem map_equiv_normalizer_eq (H : Subgroup G) (f : G ≃* N) :
    H.normalizer.map f.toMonoidHom = (H.map f.toMonoidHom).normalizer 
goal: Subgroup.map f.toMonoidHom H.normalizer = (Subgroup.map f.toMonoidHom H).normalizer

full_name: Subgroup.map_normalizer_eq_of_bijective
code: /-- The image of the normalizer is equal to the normalizer of the image of a bijective
  function. -/
@[to_additive
      "The image of the normalizer is equal to the normalizer of the image of a bijective
        function."]
theorem map_normalizer_eq_of_bijective (H : Subgroup G) {f : G →* N} (hf : Function.Bijective f) :
    H.normalizer.map f = (H.map f).normalizer 
goal: Subgroup.map f H.normalizer = (Subgroup.map f H).normalizer

full_name: AddSubgroup.map_normalizer_eq_of_bijective
code: /-- The image of the normalizer is equal to the normalizer of the image of a bijective
  function. -/
@[to_additive
      "The image of the normalizer is equal to the normalizer of the image of a bijective
        function."]
theorem map_normalizer_eq_of_bijective (H : Subgroup G) {f : G →* N} (hf : Function.Bijective f) :
    H.normalizer.map f = (H.map f).normalizer 
goal: AddSubgroup.map f H.normalizer = (AddSubgroup.map f H).normalizer

full_name: AddMonoidHom.liftOfRightInverseAux
code: /-- Auxiliary definition used to define `liftOfRightInverse` -/
@[to_additive "Auxiliary definition used to define `liftOfRightInverse`"]
def liftOfRightInverseAux (hf : Function.RightInverse f_inv f) (g : G₁ →* G₃) (hg : f.ker ≤ g.ker) :
    G₂ →* G₃ 
goal: G₂ →+ G₃

full_name: MonoidHom.liftOfRightInverseAux
code: /-- Auxiliary definition used to define `liftOfRightInverse` -/
@[to_additive "Auxiliary definition used to define `liftOfRightInverse`"]
def liftOfRightInverseAux (hf : Function.RightInverse f_inv f) (g : G₁ →* G₃) (hg : f.ker ≤ g.ker) :
    G₂ →* G₃ 
goal: G₂ →* G₃

full_name: MonoidHom.liftOfRightInverseAux_comp_apply
code: @[to_additive (attr := simp)]
theorem liftOfRightInverseAux_comp_apply (hf : Function.RightInverse f_inv f) (g : G₁ →* G₃)
    (hg : f.ker ≤ g.ker) (x : G₁) : (f.liftOfRightInverseAux f_inv hf g hg) (f x) = g x 
goal: (f.liftOfRightInverseAux f_inv hf g hg) (f x) = g x

full_name: AddMonoidHom.liftOfRightInverseAux_comp_apply
code: @[to_additive (attr := simp)]
theorem liftOfRightInverseAux_comp_apply (hf : Function.RightInverse f_inv f) (g : G₁ →* G₃)
    (hg : f.ker ≤ g.ker) (x : G₁) : (f.liftOfRightInverseAux f_inv hf g hg) (f x) = g x 
goal: (f.liftOfRightInverseAux f_inv hf g hg) (f x) = g x

full_name: MonoidHom.liftOfRightInverse
code: /-- `liftOfRightInverse f hf g hg` is the unique group homomorphism `φ`

* such that `φ.comp f = g` (`MonoidHom.liftOfRightInverse_comp`),
* where `f : G₁ →+* G₂` has a RightInverse `f_inv` (`hf`),
* and `g : G₂ →+* G₃` satisfies `hg : f.ker ≤ g.ker`.

See `MonoidHom.eq_liftOfRightInverse` for the uniqueness lemma.

```
   G₁.
   |  \
 f |   \ g
   |    \
   v     \⌟
   G₂----> G₃
      ∃!φ
```
 -/
@[to_additive
      "`liftOfRightInverse f f_inv hf g hg` is the unique additive group homomorphism `φ`
      * such that `φ.comp f = g` (`AddMonoidHom.liftOfRightInverse_comp`),
      * where `f : G₁ →+ G₂` has a RightInverse `f_inv` (`hf`),
      * and `g : G₂ →+ G₃` satisfies `hg : f.ker ≤ g.ker`.
      See `AddMonoidHom.eq_liftOfRightInverse` for the uniqueness lemma.
      ```
         G₁.
         |  \\
       f |   \\ g
         |    \\
         v     \\⌟
         G₂----> G₃
            ∃!φ
      ```"]
def liftOfRightInverse (hf : Function.RightInverse f_inv f) :
    { g : G₁ →* G₃ // f.ker ≤ g.ker } ≃ (G₂ →* G₃) 
goal: { g // f.ker ≤ g.ker } ≃ (G₂ →* G₃)

full_name: AddMonoidHom.liftOfRightInverse
code: /-- `liftOfRightInverse f hf g hg` is the unique group homomorphism `φ`

* such that `φ.comp f = g` (`MonoidHom.liftOfRightInverse_comp`),
* where `f : G₁ →+* G₂` has a RightInverse `f_inv` (`hf`),
* and `g : G₂ →+* G₃` satisfies `hg : f.ker ≤ g.ker`.

See `MonoidHom.eq_liftOfRightInverse` for the uniqueness lemma.

```
   G₁.
   |  \
 f |   \ g
   |    \
   v     \⌟
   G₂----> G₃
      ∃!φ
```
 -/
@[to_additive
      "`liftOfRightInverse f f_inv hf g hg` is the unique additive group homomorphism `φ`
      * such that `φ.comp f = g` (`AddMonoidHom.liftOfRightInverse_comp`),
      * where `f : G₁ →+ G₂` has a RightInverse `f_inv` (`hf`),
      * and `g : G₂ →+ G₃` satisfies `hg : f.ker ≤ g.ker`.
      See `AddMonoidHom.eq_liftOfRightInverse` for the uniqueness lemma.
      ```
         G₁.
         |  \\
       f |   \\ g
         |    \\
         v     \\⌟
         G₂----> G₃
            ∃!φ
      ```"]
def liftOfRightInverse (hf : Function.RightInverse f_inv f) :
    { g : G₁ →* G₃ // f.ker ≤ g.ker } ≃ (G₂ →* G₃) 
goal: { g // f.ker ≤ g.ker } ≃ (G₂ →+ G₃)

full_name: MonoidHom.liftOfSurjective
code: /-- A non-computable version of `MonoidHom.liftOfRightInverse` for when no computable right
inverse is available, that uses `Function.surjInv`. -/
@[to_additive (attr := simp)
      "A non-computable version of `AddMonoidHom.liftOfRightInverse` for when no
      computable right inverse is available."]
noncomputable abbrev liftOfSurjective (hf : Function.Surjective f) :
    { g : G₁ →* G₃ // f.ker ≤ g.ker } ≃ (G₂ →* G₃) 
goal: { g // f.ker ≤ g.ker } ≃ (G₂ →* G₃)

full_name: AddMonoidHom.liftOfSurjective
code: /-- A non-computable version of `MonoidHom.liftOfRightInverse` for when no computable right
inverse is available, that uses `Function.surjInv`. -/
@[to_additive (attr := simp)
      "A non-computable version of `AddMonoidHom.liftOfRightInverse` for when no
      computable right inverse is available."]
noncomputable abbrev liftOfSurjective (hf : Function.Surjective f) :
    { g : G₁ →* G₃ // f.ker ≤ g.ker } ≃ (G₂ →* G₃) 
goal: { g // f.ker ≤ g.ker } ≃ (G₂ →+ G₃)

full_name: AddMonoidHom.liftOfRightInverse_comp_apply
code: @[to_additive (attr := simp)]
theorem liftOfRightInverse_comp_apply (hf : Function.RightInverse f_inv f)
    (g : { g : G₁ →* G₃ // f.ker ≤ g.ker }) (x : G₁) :
    (f.liftOfRightInverse f_inv hf g) (f x) = g.1 x 
goal: ((f.liftOfRightInverse f_inv hf) g) (f x) = ↑g x

full_name: MonoidHom.liftOfRightInverse_comp_apply
code: @[to_additive (attr := simp)]
theorem liftOfRightInverse_comp_apply (hf : Function.RightInverse f_inv f)
    (g : { g : G₁ →* G₃ // f.ker ≤ g.ker }) (x : G₁) :
    (f.liftOfRightInverse f_inv hf g) (f x) = g.1 x 
goal: ((f.liftOfRightInverse f_inv hf) g) (f x) = ↑g x

full_name: MonoidHom.liftOfRightInverse_comp
code: @[to_additive (attr := simp)]
theorem liftOfRightInverse_comp (hf : Function.RightInverse f_inv f)
    (g : { g : G₁ →* G₃ // f.ker ≤ g.ker }) : (f.liftOfRightInverse f_inv hf g).comp f = g 
goal: ((f.liftOfRightInverse f_inv hf) g).comp f = ↑g

full_name: AddMonoidHom.liftOfRightInverse_comp
code: @[to_additive (attr := simp)]
theorem liftOfRightInverse_comp (hf : Function.RightInverse f_inv f)
    (g : { g : G₁ →* G₃ // f.ker ≤ g.ker }) : (f.liftOfRightInverse f_inv hf g).comp f = g 
goal: ((f.liftOfRightInverse f_inv hf) g).comp f = ↑g

full_name: AddMonoidHom.eq_liftOfRightInverse
code: @[to_additive]
theorem eq_liftOfRightInverse (hf : Function.RightInverse f_inv f) (g : G₁ →* G₃)
    (hg : f.ker ≤ g.ker) (h : G₂ →* G₃) (hh : h.comp f = g) :
    h = f.liftOfRightInverse f_inv hf ⟨g, hg⟩ 
goal: h = (f.liftOfRightInverse f_inv hf) ⟨g, hg⟩

full_name: MonoidHom.eq_liftOfRightInverse
code: @[to_additive]
theorem eq_liftOfRightInverse (hf : Function.RightInverse f_inv f) (g : G₁ →* G₃)
    (hg : f.ker ≤ g.ker) (h : G₂ →* G₃) (hh : h.comp f = g) :
    h = f.liftOfRightInverse f_inv hf ⟨g, hg⟩ 
goal: h = (f.liftOfRightInverse f_inv hf) ⟨g, hg⟩

full_name: AddSubgroup.Normal.comap
code: @[to_additive]
theorem Normal.comap {H : Subgroup N} (hH : H.Normal) (f : G →* N) : (H.comap f).Normal 
goal: (AddSubgroup.comap f H).Normal

full_name: Subgroup.Normal.comap
code: @[to_additive]
theorem Normal.comap {H : Subgroup N} (hH : H.Normal) (f : G →* N) : (H.comap f).Normal 
goal: (Subgroup.comap f H).Normal

full_name: Subgroup.normal_comap
code: @[to_additive]
instance (priority := 100) normal_comap {H : Subgroup N} [nH : H.Normal] (f : G →* N) :
    (H.comap f).Normal 
goal: (Subgroup.comap f H).Normal

full_name: AddSubgroup.normal_comap
code: @[to_additive]
instance (priority := 100) normal_comap {H : Subgroup N} [nH : H.Normal] (f : G →* N) :
    (H.comap f).Normal 
goal: (AddSubgroup.comap f H).Normal

full_name: Subgroup.Normal.subgroupOf
code: @[to_additive]
theorem Normal.subgroupOf {H : Subgroup G} (hH : H.Normal) (K : Subgroup G) :
    (H.subgroupOf K).Normal 
goal: (H.subgroupOf K).Normal

full_name: AddSubgroup.Normal.addSubgroupOf
code: @[to_additive]
theorem Normal.subgroupOf {H : Subgroup G} (hH : H.Normal) (K : Subgroup G) :
    (H.subgroupOf K).Normal 
goal: (H.addSubgroupOf K).Normal

full_name: Subgroup.normal_subgroupOf
code: @[to_additive]
instance (priority := 100) normal_subgroupOf {H N : Subgroup G} [N.Normal] :
    (N.subgroupOf H).Normal 
goal: (N.subgroupOf H).Normal

full_name: AddSubgroup.normal_addSubgroupOf
code: @[to_additive]
instance (priority := 100) normal_subgroupOf {H N : Subgroup G} [N.Normal] :
    (N.subgroupOf H).Normal 
goal: (N.addSubgroupOf H).Normal

full_name: Subgroup.map_normalClosure
code: theorem map_normalClosure (s : Set G) (f : G →* N) (hf : Surjective f) :
    (normalClosure s).map f = normalClosure (f '' s) 
goal: Subgroup.map f (Subgroup.normalClosure s) = Subgroup.normalClosure (⇑f '' s)

full_name: Subgroup.comap_normalClosure
code: theorem comap_normalClosure (s : Set N) (f : G ≃* N) :
    normalClosure (f ⁻¹' s) = (normalClosure s).comap f 
goal: Subgroup.normalClosure (⇑f ⁻¹' s) = Subgroup.comap (↑f) (Subgroup.normalClosure s)

full_name: Subgroup.Normal.of_map_injective
code: lemma Normal.of_map_injective {G H : Type*} [Group G] [Group H] {φ : G →* H}
    (hφ : Function.Injective φ) {L : Subgroup G} (n : (L.map φ).Normal) : L.Normal 
goal: L.Normal

full_name: Subgroup.Normal.of_map_subtype
code: theorem Normal.of_map_subtype {K : Subgroup G} {L : Subgroup K}
    (n : (Subgroup.map K.subtype L).Normal) : L.Normal 
goal: L.Normal

full_name: AddMonoidHom.addSubgroupComap_apply_coe
code: /-- The `MonoidHom` from the preimage of a subgroup to itself. -/
@[to_additive (attr := simps!) "the `AddMonoidHom` from the preimage of an
additive subgroup to itself."]
def subgroupComap (f : G →* G') (H' : Subgroup G') : H'.comap f →* H' 
goal: ↑((f.addSubgroupComap H') x) = f ↑x

full_name: MonoidHom.subgroupComap
code: /-- The `MonoidHom` from the preimage of a subgroup to itself. -/
@[to_additive (attr := simps!) "the `AddMonoidHom` from the preimage of an
additive subgroup to itself."]
def subgroupComap (f : G →* G') (H' : Subgroup G') : H'.comap f →* H' 
goal: ↥(Subgroup.comap f H') →* ↥H'

full_name: MonoidHom.subgroupComap_apply_coe
code: /-- The `MonoidHom` from the preimage of a subgroup to itself. -/
@[to_additive (attr := simps!) "the `AddMonoidHom` from the preimage of an
additive subgroup to itself."]
def subgroupComap (f : G →* G') (H' : Subgroup G') : H'.comap f →* H' 
goal: ↑((f.subgroupComap H') x) = f ↑x

full_name: AddMonoidHom.addSubgroupComap
code: /-- The `MonoidHom` from the preimage of a subgroup to itself. -/
@[to_additive (attr := simps!) "the `AddMonoidHom` from the preimage of an
additive subgroup to itself."]
def subgroupComap (f : G →* G') (H' : Subgroup G') : H'.comap f →* H' 
goal: ↥(AddSubgroup.comap f H') →+ ↥H'

full_name: MonoidHom.subgroupMap_apply_coe
code: /-- The `MonoidHom` from a subgroup to its image. -/
@[to_additive (attr := simps!) "the `AddMonoidHom` from an additive subgroup to its image"]
def subgroupMap (f : G →* G') (H : Subgroup G) : H →* H.map f 
goal: ↑((f.subgroupMap H) x) = f ↑x

full_name: AddMonoidHom.addSubgroupMap
code: /-- The `MonoidHom` from a subgroup to its image. -/
@[to_additive (attr := simps!) "the `AddMonoidHom` from an additive subgroup to its image"]
def subgroupMap (f : G →* G') (H : Subgroup G) : H →* H.map f 
goal: ↥H →+ ↥(AddSubgroup.map f H)

full_name: MonoidHom.subgroupMap
code: /-- The `MonoidHom` from a subgroup to its image. -/
@[to_additive (attr := simps!) "the `AddMonoidHom` from an additive subgroup to its image"]
def subgroupMap (f : G →* G') (H : Subgroup G) : H →* H.map f 
goal: ↥H →* ↥(Subgroup.map f H)

full_name: AddMonoidHom.addSubgroupMap_apply_coe
code: /-- The `MonoidHom` from a subgroup to its image. -/
@[to_additive (attr := simps!) "the `AddMonoidHom` from an additive subgroup to its image"]
def subgroupMap (f : G →* G') (H : Subgroup G) : H →* H.map f 
goal: ↑((f.addSubgroupMap H) x) = f ↑x

full_name: AddMonoidHom.addSubgroupMap_surjective
code: @[to_additive]
theorem subgroupMap_surjective (f : G →* G') (H : Subgroup G) :
    Function.Surjective (f.subgroupMap H) 
goal: Function.Surjective ⇑(f.addSubgroupMap H)

full_name: MonoidHom.subgroupMap_surjective
code: @[to_additive]
theorem subgroupMap_surjective (f : G →* G') (H : Subgroup G) :
    Function.Surjective (f.subgroupMap H) 
goal: Function.Surjective ⇑(f.subgroupMap H)

full_name: MulEquiv.subgroupCongr
code: /-- Makes the identity isomorphism from a proof two subgroups of a multiplicative
    group are equal. -/
@[to_additive
      "Makes the identity additive isomorphism from a proof
      two subgroups of an additive group are equal."]
def subgroupCongr (h : H = K) : H ≃* K 
goal: ↥H ≃* ↥K

full_name: AddEquiv.addSubgroupCongr
code: /-- Makes the identity isomorphism from a proof two subgroups of a multiplicative
    group are equal. -/
@[to_additive
      "Makes the identity additive isomorphism from a proof
      two subgroups of an additive group are equal."]
def subgroupCongr (h : H = K) : H ≃* K 
goal: ↥H ≃+ ↥K

full_name: MulEquiv.subgroupCongr_apply
code: @[to_additive (attr := simp)]
lemma subgroupCongr_apply (h : H = K) (x) :
    (MulEquiv.subgroupCongr h x : G) = x 
goal: ↑((MulEquiv.subgroupCongr h) x) = ↑x

full_name: AddEquiv.addSubgroupCongr_apply
code: @[to_additive (attr := simp)]
lemma subgroupCongr_apply (h : H = K) (x) :
    (MulEquiv.subgroupCongr h x : G) = x 
goal: ↑((AddEquiv.addSubgroupCongr h) x) = ↑x

full_name: AddEquiv.addSubgroupCongr_symm_apply
code: @[to_additive (attr := simp)]
lemma subgroupCongr_symm_apply (h : H = K) (x) :
    ((MulEquiv.subgroupCongr h).symm x : G) = x 
goal: ↑((AddEquiv.addSubgroupCongr h).symm x) = ↑x

full_name: MulEquiv.subgroupCongr_symm_apply
code: @[to_additive (attr := simp)]
lemma subgroupCongr_symm_apply (h : H = K) (x) :
    ((MulEquiv.subgroupCongr h).symm x : G) = x 
goal: ↑((MulEquiv.subgroupCongr h).symm x) = ↑x

full_name: AddEquiv.addSubgroupMap
code: /-- A subgroup is isomorphic to its image under an isomorphism. If you only have an injective map,
use `Subgroup.equiv_map_of_injective`. -/
@[to_additive
      "An additive subgroup is isomorphic to its image under an isomorphism. If you only
      have an injective map, use `AddSubgroup.equiv_map_of_injective`."]
def subgroupMap (e : G ≃* G') (H : Subgroup G) : H ≃* H.map (e : G →* G') 
goal: ↥H ≃+ ↥(AddSubgroup.map (↑e) H)

full_name: MulEquiv.subgroupMap
code: /-- A subgroup is isomorphic to its image under an isomorphism. If you only have an injective map,
use `Subgroup.equiv_map_of_injective`. -/
@[to_additive
      "An additive subgroup is isomorphic to its image under an isomorphism. If you only
      have an injective map, use `AddSubgroup.equiv_map_of_injective`."]
def subgroupMap (e : G ≃* G') (H : Subgroup G) : H ≃* H.map (e : G →* G') 
goal: ↥H ≃* ↥(Subgroup.map (↑e) H)

full_name: AddEquiv.coe_addSubgroupMap_apply
code: @[to_additive (attr := simp)]
theorem coe_subgroupMap_apply (e : G ≃* G') (H : Subgroup G) (g : H) :
    ((subgroupMap e H g : H.map (e : G →* G')) : G') = e g 
goal: ↑((e.addSubgroupMap H) g) = e ↑g

full_name: MulEquiv.coe_subgroupMap_apply
code: @[to_additive (attr := simp)]
theorem coe_subgroupMap_apply (e : G ≃* G') (H : Subgroup G) (g : H) :
    ((subgroupMap e H g : H.map (e : G →* G')) : G') = e g 
goal: ↑((e.subgroupMap H) g) = e ↑g

full_name: AddEquiv.addSubgroupMap_symm_apply
code: @[to_additive (attr := simp)]
theorem subgroupMap_symm_apply (e : G ≃* G') (H : Subgroup G) (g : H.map (e : G →* G')) :
    (e.subgroupMap H).symm g = ⟨e.symm g, SetLike.mem_coe.1 <| Set.mem_image_equiv.1 g.2⟩ 
goal: (e.addSubgroupMap H).symm g = ⟨e.symm ↑g, ⋯⟩

full_name: MulEquiv.subgroupMap_symm_apply
code: @[to_additive (attr := simp)]
theorem subgroupMap_symm_apply (e : G ≃* G') (H : Subgroup G) (g : H.map (e : G →* G')) :
    (e.subgroupMap H).symm g = ⟨e.symm g, SetLike.mem_coe.1 <| Set.mem_image_equiv.1 g.2⟩ 
goal: (e.subgroupMap H).symm g = ⟨e.symm ↑g, ⋯⟩

full_name: AddSubgroup.equivMapOfInjective_coe_addEquiv
code: @[to_additive (attr := simp)]
theorem equivMapOfInjective_coe_mulEquiv (H : Subgroup G) (e : G ≃* G') :
    H.equivMapOfInjective (e : G →* G') (EquivLike.injective e) = e.subgroupMap H 
goal: H.equivMapOfInjective ↑e ⋯ = e.addSubgroupMap H

full_name: Subgroup.equivMapOfInjective_coe_mulEquiv
code: @[to_additive (attr := simp)]
theorem equivMapOfInjective_coe_mulEquiv (H : Subgroup G) (e : G ≃* G') :
    H.equivMapOfInjective (e : G →* G') (EquivLike.injective e) = e.subgroupMap H 
goal: H.equivMapOfInjective ↑e ⋯ = e.subgroupMap H

full_name: Subgroup.mem_sup
code: @[to_additive]
theorem mem_sup : x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x 
goal: x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x

full_name: AddSubgroup.mem_sup
code: @[to_additive]
theorem mem_sup : x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x 
goal: x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y + z = x

full_name: Subgroup.mem_sup'
code: @[to_additive]
theorem mem_sup' : x ∈ s ⊔ t ↔ ∃ (y : s) (z : t), (y : C) * z = x 
goal: x ∈ s ⊔ t ↔ ∃ y z, ↑y * ↑z = x

full_name: AddSubgroup.mem_sup'
code: @[to_additive]
theorem mem_sup' : x ∈ s ⊔ t ↔ ∃ (y : s) (z : t), (y : C) * z = x 
goal: x ∈ s ⊔ t ↔ ∃ y z, ↑y + ↑z = x

full_name: Subgroup.mem_closure_pair
code: @[to_additive]
theorem mem_closure_pair {x y z : C} :
    z ∈ closure ({x, y} : Set C) ↔ ∃ m n : ℤ, x ^ m * y ^ n = z 
goal: z ∈ Subgroup.closure {x, y} ↔ ∃ m n, x ^ m * y ^ n = z

full_name: AddSubgroup.mem_closure_pair
code: @[to_additive]
theorem mem_closure_pair {x y z : C} :
    z ∈ closure ({x, y} : Set C) ↔ ∃ m n : ℤ, x ^ m * y ^ n = z 
goal: z ∈ AddSubgroup.closure {x, y} ↔ ∃ m n, m • x + n • y = z

full_name: Subgroup.normal_subgroupOf_iff
code: @[to_additive]
theorem normal_subgroupOf_iff {H K : Subgroup G} (hHK : H ≤ K) :
    (H.subgroupOf K).Normal ↔ ∀ h k, h ∈ H → k ∈ K → k * h * k⁻¹ ∈ H 
goal: (H.subgroupOf K).Normal ↔ ∀ (h k : G), h ∈ H → k ∈ K → k * h * k⁻¹ ∈ H

full_name: AddSubgroup.normal_addSubgroupOf_iff
code: @[to_additive]
theorem normal_subgroupOf_iff {H K : Subgroup G} (hHK : H ≤ K) :
    (H.subgroupOf K).Normal ↔ ∀ h k, h ∈ H → k ∈ K → k * h * k⁻¹ ∈ H 
goal: (H.addSubgroupOf K).Normal ↔ ∀ (h k : G), h ∈ H → k ∈ K → k + h + -k ∈ H

full_name: AddSubgroup.sum_addSubgroupOf_sum_normal
code: @[to_additive]
instance prod_subgroupOf_prod_normal {H₁ K₁ : Subgroup G} {H₂ K₂ : Subgroup N}
    [h₁ : (H₁.subgroupOf K₁).Normal] [h₂ : (H₂.subgroupOf K₂).Normal] :
    ((H₁.prod H₂).subgroupOf (K₁.prod K₂)).Normal 
goal: ((H₁.prod H₂).addSubgroupOf (K₁.prod K₂)).Normal

full_name: Subgroup.prod_subgroupOf_prod_normal
code: @[to_additive]
instance prod_subgroupOf_prod_normal {H₁ K₁ : Subgroup G} {H₂ K₂ : Subgroup N}
    [h₁ : (H₁.subgroupOf K₁).Normal] [h₂ : (H₂.subgroupOf K₂).Normal] :
    ((H₁.prod H₂).subgroupOf (K₁.prod K₂)).Normal 
goal: ((H₁.prod H₂).subgroupOf (K₁.prod K₂)).Normal

full_name: AddSubgroup.sum_normal
code: @[to_additive]
instance prod_normal (H : Subgroup G) (K : Subgroup N) [hH : H.Normal] [hK : K.Normal] :
    (H.prod K).Normal 
goal: (H.prod K).Normal

full_name: Subgroup.prod_normal
code: @[to_additive]
instance prod_normal (H : Subgroup G) (K : Subgroup N) [hH : H.Normal] [hK : K.Normal] :
    (H.prod K).Normal 
goal: (H.prod K).Normal

full_name: AddSubgroup.inf_addSubgroupOf_inf_normal_of_right
code: @[to_additive]
theorem inf_subgroupOf_inf_normal_of_right (A B' B : Subgroup G) (hB : B' ≤ B)
    [hN : (B'.subgroupOf B).Normal] : ((A ⊓ B').subgroupOf (A ⊓ B)).Normal 
goal: ((A ⊓ B').addSubgroupOf (A ⊓ B)).Normal

full_name: Subgroup.inf_subgroupOf_inf_normal_of_right
code: @[to_additive]
theorem inf_subgroupOf_inf_normal_of_right (A B' B : Subgroup G) (hB : B' ≤ B)
    [hN : (B'.subgroupOf B).Normal] : ((A ⊓ B').subgroupOf (A ⊓ B)).Normal 
goal: ((A ⊓ B').subgroupOf (A ⊓ B)).Normal

full_name: Subgroup.inf_subgroupOf_inf_normal_of_left
code: @[to_additive]
theorem inf_subgroupOf_inf_normal_of_left {A' A : Subgroup G} (B : Subgroup G) (hA : A' ≤ A)
    [hN : (A'.subgroupOf A).Normal] : ((A' ⊓ B).subgroupOf (A ⊓ B)).Normal 
goal: ((A' ⊓ B).subgroupOf (A ⊓ B)).Normal

full_name: AddSubgroup.inf_addSubgroupOf_inf_normal_of_left
code: @[to_additive]
theorem inf_subgroupOf_inf_normal_of_left {A' A : Subgroup G} (B : Subgroup G) (hA : A' ≤ A)
    [hN : (A'.subgroupOf A).Normal] : ((A' ⊓ B).subgroupOf (A ⊓ B)).Normal 
goal: ((A' ⊓ B).addSubgroupOf (A ⊓ B)).Normal

full_name: Subgroup.normal_inf_normal
code: @[to_additive]
instance normal_inf_normal (H K : Subgroup G) [hH : H.Normal] [hK : K.Normal] : (H ⊓ K).Normal 
goal: (H ⊓ K).Normal

full_name: AddSubgroup.normal_inf_normal
code: @[to_additive]
instance normal_inf_normal (H K : Subgroup G) [hH : H.Normal] [hK : K.Normal] : (H ⊓ K).Normal 
goal: (H ⊓ K).Normal

full_name: AddSubgroup.addSubgroupOf_sup
code: @[to_additive]
theorem subgroupOf_sup (A A' B : Subgroup G) (hA : A ≤ B) (hA' : A' ≤ B) :
    (A ⊔ A').subgroupOf B = A.subgroupOf B ⊔ A'.subgroupOf B 
goal: (A ⊔ A').addSubgroupOf B = A.addSubgroupOf B ⊔ A'.addSubgroupOf B

full_name: Subgroup.subgroupOf_sup
code: @[to_additive]
theorem subgroupOf_sup (A A' B : Subgroup G) (hA : A ≤ B) (hA' : A' ≤ B) :
    (A ⊔ A').subgroupOf B = A.subgroupOf B ⊔ A'.subgroupOf B 
goal: (A ⊔ A').subgroupOf B = A.subgroupOf B ⊔ A'.subgroupOf B

full_name: AddSubgroup.SubgroupNormal.mem_comm
code: @[to_additive]
theorem SubgroupNormal.mem_comm {H K : Subgroup G} (hK : H ≤ K) [hN : (H.subgroupOf K).Normal]
    {a b : G} (hb : b ∈ K) (h : a * b ∈ H) : b * a ∈ H 
goal: b + a ∈ H

full_name: Subgroup.SubgroupNormal.mem_comm
code: @[to_additive]
theorem SubgroupNormal.mem_comm {H K : Subgroup G} (hK : H ≤ K) [hN : (H.subgroupOf K).Normal]
    {a b : G} (hb : b ∈ K) (h : a * b ∈ H) : b * a ∈ H 
goal: b * a ∈ H

full_name: Subgroup.commute_of_normal_of_disjoint
code: /-- Elements of disjoint, normal subgroups commute. -/
@[to_additive "Elements of disjoint, normal subgroups commute."]
theorem commute_of_normal_of_disjoint (H₁ H₂ : Subgroup G) (hH₁ : H₁.Normal) (hH₂ : H₂.Normal)
    (hdis : Disjoint H₁ H₂) (x y : G) (hx : x ∈ H₁) (hy : y ∈ H₂) : Commute x y 
goal: Commute x y

full_name: AddSubgroup.addCommute_of_normal_of_disjoint
code: /-- Elements of disjoint, normal subgroups commute. -/
@[to_additive "Elements of disjoint, normal subgroups commute."]
theorem commute_of_normal_of_disjoint (H₁ H₂ : Subgroup G) (hH₁ : H₁.Normal) (hH₂ : H₂.Normal)
    (hdis : Disjoint H₁ H₂) (x y : G) (hx : x ∈ H₁) (hy : y ∈ H₂) : Commute x y 
goal: AddCommute x y

full_name: AddSubgroup.disjoint_def
code: @[to_additive]
theorem disjoint_def {H₁ H₂ : Subgroup G} : Disjoint H₁ H₂ ↔ ∀ {x : G}, x ∈ H₁ → x ∈ H₂ → x = 1 
goal: Disjoint H₁ H₂ ↔ ∀ {x : G}, x ∈ H₁ → x ∈ H₂ → x = 0

full_name: Subgroup.disjoint_def
code: @[to_additive]
theorem disjoint_def {H₁ H₂ : Subgroup G} : Disjoint H₁ H₂ ↔ ∀ {x : G}, x ∈ H₁ → x ∈ H₂ → x = 1 
goal: Disjoint H₁ H₂ ↔ ∀ {x : G}, x ∈ H₁ → x ∈ H₂ → x = 1

full_name: AddSubgroup.disjoint_def'
code: @[to_additive]
theorem disjoint_def' {H₁ H₂ : Subgroup G} :
    Disjoint H₁ H₂ ↔ ∀ {x y : G}, x ∈ H₁ → y ∈ H₂ → x = y → x = 1 
goal: Disjoint H₁ H₂ ↔ ∀ {x y : G}, x ∈ H₁ → y ∈ H₂ → x = y → x = 0

full_name: Subgroup.disjoint_def'
code: @[to_additive]
theorem disjoint_def' {H₁ H₂ : Subgroup G} :
    Disjoint H₁ H₂ ↔ ∀ {x y : G}, x ∈ H₁ → y ∈ H₂ → x = y → x = 1 
goal: Disjoint H₁ H₂ ↔ ∀ {x y : G}, x ∈ H₁ → y ∈ H₂ → x = y → x = 1

full_name: Subgroup.disjoint_iff_mul_eq_one
code: @[to_additive]
theorem disjoint_iff_mul_eq_one {H₁ H₂ : Subgroup G} :
    Disjoint H₁ H₂ ↔ ∀ {x y : G}, x ∈ H₁ → y ∈ H₂ → x * y = 1 → x = 1 ∧ y = 1 
goal: Disjoint H₁ H₂ ↔ ∀ {x y : G}, x ∈ H₁ → y ∈ H₂ → x * y = 1 → x = 1 ∧ y = 1

full_name: AddSubgroup.disjoint_iff_add_eq_zero
code: @[to_additive]
theorem disjoint_iff_mul_eq_one {H₁ H₂ : Subgroup G} :
    Disjoint H₁ H₂ ↔ ∀ {x y : G}, x ∈ H₁ → y ∈ H₂ → x * y = 1 → x = 1 ∧ y = 1 
goal: Disjoint H₁ H₂ ↔ ∀ {x y : G}, x ∈ H₁ → y ∈ H₂ → x + y = 0 → x = 0 ∧ y = 0

full_name: Subgroup.mul_injective_of_disjoint
code: @[to_additive]
theorem mul_injective_of_disjoint {H₁ H₂ : Subgroup G} (h : Disjoint H₁ H₂) :
    Function.Injective (fun g => g.1 * g.2 : H₁ × H₂ → G) 
goal: Function.Injective fun g => ↑g.1 * ↑g.2

full_name: AddSubgroup.add_injective_of_disjoint
code: @[to_additive]
theorem mul_injective_of_disjoint {H₁ H₂ : Subgroup G} (h : Disjoint H₁ H₂) :
    Function.Injective (fun g => g.1 * g.2 : H₁ × H₂ → G) 
goal: Function.Injective fun g => ↑g.1 + ↑g.2

full_name: IsConj.normalClosure_eq_top_of
code: theorem normalClosure_eq_top_of {N : Subgroup G} [hn : N.Normal] {g g' : G} {hg : g ∈ N}
    {hg' : g' ∈ N} (hc : IsConj g g') (ht : normalClosure ({⟨g, hg⟩} : Set N) = ⊤) :
    normalClosure ({⟨g', hg'⟩} : Set N) = ⊤ 
goal: Subgroup.normalClosure {⟨g', hg'⟩} = ⊤

full_name: ConjClasses.noncenter
code: /-- The conjugacy classes that are not trivial. -/
def noncenter (G : Type*) [Monoid G] : Set (ConjClasses G) 
goal: Set (ConjClasses G)

full_name: ConjClasses.mem_noncenter
code: @[simp] lemma mem_noncenter {G} [Monoid G] (g : ConjClasses G) :
  g ∈ noncenter G ↔ g.carrier.Nontrivial 
goal: g ∈ ConjClasses.noncenter G ↔ g.carrier.Nontrivial