File: Mathlib/Deprecated/Subgroup.lean

full_name: IsAddSubgroup
code: /-- `s` is an additive subgroup: a set containing 0 and closed under addition and negation. -/
structure IsAddSubgroup (s : Set A) extends IsAddSubmonoid s : Prop where
  /-- The proposition that `s` is closed under negation. -/
  neg_mem {a} : a ∈ s → -a ∈ s
goal: Prop

full_name: IsAddSubgroup.neg_mem
code: /-- `s` is an additive subgroup: a set containing 0 and closed under addition and negation. -/
structure IsAddSubgroup (s : Set A) extends IsAddSubmonoid s : Prop where
  /-- The proposition that `s` is closed under negation. -/
  neg_mem {a} : a ∈ s → -a ∈ s
goal: a ∈ s → -a ∈ s

full_name: IsSubgroup
code: /-- `s` is a subgroup: a set containing 1 and closed under multiplication and inverse. -/
@[to_additive]
structure IsSubgroup (s : Set G) extends IsSubmonoid s : Prop where
  /-- The proposition that `s` is closed under inverse. -/
  inv_mem {a} : a ∈ s → a⁻¹ ∈ s
goal: Prop

full_name: IsSubgroup.inv_mem
code: /-- `s` is a subgroup: a set containing 1 and closed under multiplication and inverse. -/
@[to_additive]
structure IsSubgroup (s : Set G) extends IsSubmonoid s : Prop where
  /-- The proposition that `s` is closed under inverse. -/
  inv_mem {a} : a ∈ s → a⁻¹ ∈ s
goal: a ∈ s → a⁻¹ ∈ s

full_name: IsAddSubgroup.sub_mem
code: @[to_additive]
theorem IsSubgroup.div_mem {s : Set G} (hs : IsSubgroup s) {x y : G} (hx : x ∈ s) (hy : y ∈ s) :
    x / y ∈ s 
goal: x - y ∈ s

full_name: IsSubgroup.div_mem
code: @[to_additive]
theorem IsSubgroup.div_mem {s : Set G} (hs : IsSubgroup s) {x y : G} (hx : x ∈ s) (hy : y ∈ s) :
    x / y ∈ s 
goal: x / y ∈ s

full_name: Additive.isAddSubgroup
code: theorem Additive.isAddSubgroup {s : Set G} (hs : IsSubgroup s) : @IsAddSubgroup (Additive G) _ s 
goal: IsAddSubgroup s

full_name: Additive.isAddSubgroup_iff
code: theorem Additive.isAddSubgroup_iff {s : Set G} : @IsAddSubgroup (Additive G) _ s ↔ IsSubgroup s 
goal: IsAddSubgroup s ↔ IsSubgroup s

full_name: Multiplicative.isSubgroup
code: theorem Multiplicative.isSubgroup {s : Set A} (hs : IsAddSubgroup s) :
    @IsSubgroup (Multiplicative A) _ s 
goal: IsSubgroup s

full_name: Multiplicative.isSubgroup_iff
code: theorem Multiplicative.isSubgroup_iff {s : Set A} :
    @IsSubgroup (Multiplicative A) _ s ↔ IsAddSubgroup s 
goal: IsSubgroup s ↔ IsAddSubgroup s

full_name: IsSubgroup.of_div
code: @[to_additive of_add_neg]
theorem IsSubgroup.of_div (s : Set G) (one_mem : (1 : G) ∈ s)
    (div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s) : IsSubgroup s 
goal: IsSubgroup s

full_name: IsAddSubgroup.of_add_neg
code: @[to_additive of_add_neg]
theorem IsSubgroup.of_div (s : Set G) (one_mem : (1 : G) ∈ s)
    (div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s) : IsSubgroup s 
goal: IsAddSubgroup s

full_name: IsAddSubgroup.of_sub
code: theorem IsAddSubgroup.of_sub (s : Set A) (zero_mem : (0 : A) ∈ s)
    (sub_mem : ∀ {a b : A}, a ∈ s → b ∈ s → a - b ∈ s) : IsAddSubgroup s 
goal: IsAddSubgroup s

full_name: IsAddSubgroup.inter
code: @[to_additive]
theorem IsSubgroup.inter {s₁ s₂ : Set G} (hs₁ : IsSubgroup s₁) (hs₂ : IsSubgroup s₂) :
    IsSubgroup (s₁ ∩ s₂) 
goal: IsAddSubgroup (s₁ ∩ s₂)

full_name: IsSubgroup.inter
code: @[to_additive]
theorem IsSubgroup.inter {s₁ s₂ : Set G} (hs₁ : IsSubgroup s₁) (hs₂ : IsSubgroup s₂) :
    IsSubgroup (s₁ ∩ s₂) 
goal: IsSubgroup (s₁ ∩ s₂)

full_name: IsSubgroup.iInter
code: @[to_additive]
theorem IsSubgroup.iInter {ι : Sort*} {s : ι → Set G} (hs : ∀ y : ι, IsSubgroup (s y)) :
    IsSubgroup (Set.iInter s) 
goal: IsSubgroup (Set.iInter s)

full_name: IsAddSubgroup.iInter
code: @[to_additive]
theorem IsSubgroup.iInter {ι : Sort*} {s : ι → Set G} (hs : ∀ y : ι, IsSubgroup (s y)) :
    IsSubgroup (Set.iInter s) 
goal: IsAddSubgroup (Set.iInter s)

full_name: isAddSubgroup_iUnion_of_directed
code: @[to_additive]
theorem isSubgroup_iUnion_of_directed {ι : Type*} [Nonempty ι] {s : ι → Set G}
    (hs : ∀ i, IsSubgroup (s i)) (directed : ∀ i j, ∃ k, s i ⊆ s k ∧ s j ⊆ s k) :
    IsSubgroup (⋃ i, s i) 
goal: IsAddSubgroup (⋃ i, s i)

full_name: isSubgroup_iUnion_of_directed
code: @[to_additive]
theorem isSubgroup_iUnion_of_directed {ι : Type*} [Nonempty ι] {s : ι → Set G}
    (hs : ∀ i, IsSubgroup (s i)) (directed : ∀ i j, ∃ k, s i ⊆ s k ∧ s j ⊆ s k) :
    IsSubgroup (⋃ i, s i) 
goal: IsSubgroup (⋃ i, s i)

full_name: IsAddSubgroup.neg_mem_iff
code: @[to_additive]
theorem inv_mem_iff : a⁻¹ ∈ s ↔ a ∈ s 
goal: -a ∈ s ↔ a ∈ s

full_name: IsSubgroup.inv_mem_iff
code: @[to_additive]
theorem inv_mem_iff : a⁻¹ ∈ s ↔ a ∈ s 
goal: a⁻¹ ∈ s ↔ a ∈ s

full_name: IsSubgroup.mul_mem_cancel_right
code: @[to_additive]
theorem mul_mem_cancel_right (h : a ∈ s) : b * a ∈ s ↔ b ∈ s 
goal: b * a ∈ s ↔ b ∈ s

full_name: IsAddSubgroup.add_mem_cancel_right
code: @[to_additive]
theorem mul_mem_cancel_right (h : a ∈ s) : b * a ∈ s ↔ b ∈ s 
goal: b + a ∈ s ↔ b ∈ s

full_name: IsSubgroup.mul_mem_cancel_left
code: @[to_additive]
theorem mul_mem_cancel_left (h : a ∈ s) : a * b ∈ s ↔ b ∈ s 
goal: a * b ∈ s ↔ b ∈ s

full_name: IsAddSubgroup.add_mem_cancel_left
code: @[to_additive]
theorem mul_mem_cancel_left (h : a ∈ s) : a * b ∈ s ↔ b ∈ s 
goal: a + b ∈ s ↔ b ∈ s

full_name: IsNormalAddSubgroup
code: /-- `IsNormalAddSubgroup (s : Set A)` expresses the fact that `s` is a normal additive subgroup
of the additive group `A`. Important: the preferred way to say this in Lean is via bundled
subgroups `S : AddSubgroup A` and `hs : S.normal`, and not via this structure. -/
structure IsNormalAddSubgroup [AddGroup A] (s : Set A) extends IsAddSubgroup s : Prop where
  /-- The proposition that `s` is closed under (additive) conjugation. -/
  normal : ∀ n ∈ s, ∀ g : A, g + n + -g ∈ s
goal: Prop

full_name: IsNormalAddSubgroup.normal
code: /-- `IsNormalAddSubgroup (s : Set A)` expresses the fact that `s` is a normal additive subgroup
of the additive group `A`. Important: the preferred way to say this in Lean is via bundled
subgroups `S : AddSubgroup A` and `hs : S.normal`, and not via this structure. -/
structure IsNormalAddSubgroup [AddGroup A] (s : Set A) extends IsAddSubgroup s : Prop where
  /-- The proposition that `s` is closed under (additive) conjugation. -/
  normal : ∀ n ∈ s, ∀ g : A, g + n + -g ∈ s
goal: n ∈ s → ∀ (g : A), g + n + -g ∈ s

full_name: IsNormalSubgroup.normal
code: /-- `IsNormalSubgroup (s : Set G)` expresses the fact that `s` is a normal subgroup
of the group `G`. Important: the preferred way to say this in Lean is via bundled
subgroups `S : Subgroup G` and not via this structure. -/
@[to_additive]
structure IsNormalSubgroup [Group G] (s : Set G) extends IsSubgroup s : Prop where
  /-- The proposition that `s` is closed under conjugation. -/
  normal : ∀ n ∈ s, ∀ g : G, g * n * g⁻¹ ∈ s
goal: n ∈ s → ∀ (g : G), g * n * g⁻¹ ∈ s

full_name: IsNormalSubgroup
code: /-- `IsNormalSubgroup (s : Set G)` expresses the fact that `s` is a normal subgroup
of the group `G`. Important: the preferred way to say this in Lean is via bundled
subgroups `S : Subgroup G` and not via this structure. -/
@[to_additive]
structure IsNormalSubgroup [Group G] (s : Set G) extends IsSubgroup s : Prop where
  /-- The proposition that `s` is closed under conjugation. -/
  normal : ∀ n ∈ s, ∀ g : G, g * n * g⁻¹ ∈ s
goal: Prop

full_name: isNormalAddSubgroup_of_addCommGroup
code: @[to_additive]
theorem isNormalSubgroup_of_commGroup [CommGroup G] {s : Set G} (hs : IsSubgroup s) :
    IsNormalSubgroup s 
goal: IsNormalAddSubgroup s

full_name: isNormalSubgroup_of_commGroup
code: @[to_additive]
theorem isNormalSubgroup_of_commGroup [CommGroup G] {s : Set G} (hs : IsSubgroup s) :
    IsNormalSubgroup s 
goal: IsNormalSubgroup s

full_name: Additive.isNormalAddSubgroup
code: theorem Additive.isNormalAddSubgroup [Group G] {s : Set G} (hs : IsNormalSubgroup s) :
    @IsNormalAddSubgroup (Additive G) _ s 
goal: IsNormalAddSubgroup s

full_name: Additive.isNormalAddSubgroup_iff
code: theorem Additive.isNormalAddSubgroup_iff [Group G] {s : Set G} :
    @IsNormalAddSubgroup (Additive G) _ s ↔ IsNormalSubgroup s 
goal: IsNormalAddSubgroup s ↔ IsNormalSubgroup s

full_name: Multiplicative.isNormalSubgroup
code: theorem Multiplicative.isNormalSubgroup [AddGroup A] {s : Set A} (hs : IsNormalAddSubgroup s) :
    @IsNormalSubgroup (Multiplicative A) _ s 
goal: IsNormalSubgroup s

full_name: Multiplicative.isNormalSubgroup_iff
code: theorem Multiplicative.isNormalSubgroup_iff [AddGroup A] {s : Set A} :
    @IsNormalSubgroup (Multiplicative A) _ s ↔ IsNormalAddSubgroup s 
goal: IsNormalSubgroup s ↔ IsNormalAddSubgroup s

full_name: IsAddSubgroup.mem_norm_comm
code: @[to_additive]
theorem mem_norm_comm {s : Set G} (hs : IsNormalSubgroup s) {a b : G} (hab : a * b ∈ s) :
    b * a ∈ s 
goal: b + a ∈ s

full_name: IsSubgroup.mem_norm_comm
code: @[to_additive]
theorem mem_norm_comm {s : Set G} (hs : IsNormalSubgroup s) {a b : G} (hab : a * b ∈ s) :
    b * a ∈ s 
goal: b * a ∈ s

full_name: IsSubgroup.mem_norm_comm_iff
code: @[to_additive]
theorem mem_norm_comm_iff {s : Set G} (hs : IsNormalSubgroup s) {a b : G} : a * b ∈ s ↔ b * a ∈ s 
goal: a * b ∈ s ↔ b * a ∈ s

full_name: IsAddSubgroup.mem_norm_comm_iff
code: @[to_additive]
theorem mem_norm_comm_iff {s : Set G} (hs : IsNormalSubgroup s) {a b : G} : a * b ∈ s ↔ b * a ∈ s 
goal: a + b ∈ s ↔ b + a ∈ s

full_name: IsSubgroup.trivial
code: /-- The trivial subgroup -/
@[to_additive "the trivial additive subgroup"]
def trivial (G : Type*) [Group G] : Set G 
goal: Set G

full_name: IsAddSubgroup.trivial
code: /-- The trivial subgroup -/
@[to_additive "the trivial additive subgroup"]
def trivial (G : Type*) [Group G] : Set G 
goal: Set G

full_name: IsAddSubgroup.mem_trivial
code: @[to_additive (attr := simp)]
theorem mem_trivial {g : G} : g ∈ trivial G ↔ g = 1 
goal: g ∈ IsAddSubgroup.trivial G ↔ g = 0

full_name: IsSubgroup.mem_trivial
code: @[to_additive (attr := simp)]
theorem mem_trivial {g : G} : g ∈ trivial G ↔ g = 1 
goal: g ∈ IsSubgroup.trivial G ↔ g = 1

full_name: IsAddSubgroup.trivial_normal
code: @[to_additive]
theorem trivial_normal : IsNormalSubgroup (trivial G) 
goal: IsNormalAddSubgroup (IsAddSubgroup.trivial G)

full_name: IsSubgroup.trivial_normal
code: @[to_additive]
theorem trivial_normal : IsNormalSubgroup (trivial G) 
goal: IsNormalSubgroup (IsSubgroup.trivial G)

full_name: IsAddSubgroup.eq_trivial_iff
code: @[to_additive]
theorem eq_trivial_iff {s : Set G} (hs : IsSubgroup s) : s = trivial G ↔ ∀ x ∈ s, x = (1 : G) 
goal: s = IsAddSubgroup.trivial G ↔ ∀ x ∈ s, x = 0

full_name: IsSubgroup.eq_trivial_iff
code: @[to_additive]
theorem eq_trivial_iff {s : Set G} (hs : IsSubgroup s) : s = trivial G ↔ ∀ x ∈ s, x = (1 : G) 
goal: s = IsSubgroup.trivial G ↔ ∀ x ∈ s, x = 1

full_name: IsSubgroup.univ_subgroup
code: @[to_additive]
theorem univ_subgroup : IsNormalSubgroup (@univ G) 
goal: IsNormalSubgroup Set.univ

full_name: IsAddSubgroup.univ_addSubgroup
code: @[to_additive]
theorem univ_subgroup : IsNormalSubgroup (@univ G) 
goal: IsNormalAddSubgroup Set.univ

full_name: IsSubgroup.center
code: /-- The underlying set of the center of a group. -/
@[to_additive addCenter "The underlying set of the center of an additive group."]
def center (G : Type*) [Group G] : Set G 
goal: Set G

full_name: IsAddSubgroup.addCenter
code: /-- The underlying set of the center of a group. -/
@[to_additive addCenter "The underlying set of the center of an additive group."]
def center (G : Type*) [Group G] : Set G 
goal: Set G

full_name: IsSubgroup.mem_center
code: @[to_additive mem_add_center]
theorem mem_center {a : G} : a ∈ center G ↔ ∀ g, g * a = a * g 
goal: a ∈ IsSubgroup.center G ↔ ∀ (g : G), g * a = a * g

full_name: IsAddSubgroup.mem_add_center
code: @[to_additive mem_add_center]
theorem mem_center {a : G} : a ∈ center G ↔ ∀ g, g * a = a * g 
goal: a ∈ IsAddSubgroup.addCenter G ↔ ∀ (g : G), g + a = a + g

full_name: IsSubgroup.center_normal
code: @[to_additive add_center_normal]
theorem center_normal : IsNormalSubgroup (center G) 
goal: IsNormalSubgroup (IsSubgroup.center G)

full_name: IsAddSubgroup.add_center_normal
code: @[to_additive add_center_normal]
theorem center_normal : IsNormalSubgroup (center G) 
goal: IsNormalAddSubgroup (IsAddSubgroup.addCenter G)

full_name: IsSubgroup.normalizer
code: /-- The underlying set of the normalizer of a subset `S : Set G` of a group `G`. That is,
  the elements `g : G` such that `g * S * g⁻¹ = S`. -/
@[to_additive addNormalizer
      "The underlying set of the normalizer of a subset `S : Set A` of an
      additive group `A`. That is, the elements `a : A` such that `a + S - a = S`."]
def normalizer (s : Set G) : Set G 
goal: Set G

full_name: IsAddSubgroup.addNormalizer
code: /-- The underlying set of the normalizer of a subset `S : Set G` of a group `G`. That is,
  the elements `g : G` such that `g * S * g⁻¹ = S`. -/
@[to_additive addNormalizer
      "The underlying set of the normalizer of a subset `S : Set A` of an
      additive group `A`. That is, the elements `a : A` such that `a + S - a = S`."]
def normalizer (s : Set G) : Set G 
goal: Set G

full_name: IsSubgroup.normalizer_isSubgroup
code: @[to_additive]
theorem normalizer_isSubgroup (s : Set G) : IsSubgroup (normalizer s) 
goal: IsSubgroup (IsSubgroup.normalizer s)

full_name: IsAddSubgroup.normalizer_isAddSubgroup
code: @[to_additive]
theorem normalizer_isSubgroup (s : Set G) : IsSubgroup (normalizer s) 
goal: IsAddSubgroup (IsAddSubgroup.addNormalizer s)

full_name: IsSubgroup.subset_normalizer
code: @[to_additive subset_add_normalizer]
theorem subset_normalizer {s : Set G} (hs : IsSubgroup s) : s ⊆ normalizer s 
goal: s ⊆ IsSubgroup.normalizer s

full_name: IsAddSubgroup.subset_add_normalizer
code: @[to_additive subset_add_normalizer]
theorem subset_normalizer {s : Set G} (hs : IsSubgroup s) : s ⊆ normalizer s 
goal: s ⊆ IsAddSubgroup.addNormalizer s

full_name: IsGroupHom.ker
code: /-- `ker f : Set G` is the underlying subset of the kernel of a map `G → H`. -/
@[to_additive "`ker f : Set A` is the underlying subset of the kernel of a map `A → B`"]
def ker [Group H] (f : G → H) : Set G 
goal: Set G

full_name: IsAddGroupHom.ker
code: /-- `ker f : Set G` is the underlying subset of the kernel of a map `G → H`. -/
@[to_additive "`ker f : Set A` is the underlying subset of the kernel of a map `A → B`"]
def ker [Group H] (f : G → H) : Set G 
goal: Set G

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

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

full_name: IsGroupHom.one_ker_inv
code: @[to_additive]
theorem one_ker_inv {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a * b⁻¹) = 1) :
    f a = f b 
goal: f a = f b

full_name: IsAddGroupHom.zero_ker_neg
code: @[to_additive]
theorem one_ker_inv {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a * b⁻¹) = 1) :
    f a = f b 
goal: f a = f b

full_name: IsGroupHom.one_ker_inv'
code: @[to_additive]
theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹ * b) = 1) :
    f a = f b 
goal: f a = f b

full_name: IsAddGroupHom.zero_ker_neg'
code: @[to_additive]
theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹ * b) = 1) :
    f a = f b 
goal: f a = f b

full_name: IsAddGroupHom.neg_ker_zero
code: @[to_additive]
theorem inv_ker_one {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) :
    f (a * b⁻¹) = 1 
goal: f (a + -b) = 0

full_name: IsGroupHom.inv_ker_one
code: @[to_additive]
theorem inv_ker_one {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) :
    f (a * b⁻¹) = 1 
goal: f (a * b⁻¹) = 1

full_name: IsAddGroupHom.neg_ker_zero'
code: @[to_additive]
theorem inv_ker_one' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) :
    f (a⁻¹ * b) = 1 
goal: f (-a + b) = 0

full_name: IsGroupHom.inv_ker_one'
code: @[to_additive]
theorem inv_ker_one' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) :
    f (a⁻¹ * b) = 1 
goal: f (a⁻¹ * b) = 1

full_name: IsGroupHom.one_iff_ker_inv
code: @[to_additive]
theorem one_iff_ker_inv {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ f (a * b⁻¹) = 1 
goal: f a = f b ↔ f (a * b⁻¹) = 1

full_name: IsAddGroupHom.zero_iff_ker_neg
code: @[to_additive]
theorem one_iff_ker_inv {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ f (a * b⁻¹) = 1 
goal: f a = f b ↔ f (a + -b) = 0

full_name: IsAddGroupHom.zero_iff_ker_neg'
code: @[to_additive]
theorem one_iff_ker_inv' {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ f (a⁻¹ * b) = 1 
goal: f a = f b ↔ f (-a + b) = 0

full_name: IsGroupHom.one_iff_ker_inv'
code: @[to_additive]
theorem one_iff_ker_inv' {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ f (a⁻¹ * b) = 1 
goal: f a = f b ↔ f (a⁻¹ * b) = 1

full_name: IsGroupHom.inv_iff_ker
code: @[to_additive]
theorem inv_iff_ker {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ a * b⁻¹ ∈ ker f 
goal: f a = f b ↔ a * b⁻¹ ∈ IsGroupHom.ker f

full_name: IsAddGroupHom.neg_iff_ker
code: @[to_additive]
theorem inv_iff_ker {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ a * b⁻¹ ∈ ker f 
goal: f a = f b ↔ a + -b ∈ IsAddGroupHom.ker f

full_name: IsGroupHom.inv_iff_ker'
code: @[to_additive]
theorem inv_iff_ker' {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ a⁻¹ * b ∈ ker f 
goal: f a = f b ↔ a⁻¹ * b ∈ IsGroupHom.ker f

full_name: IsAddGroupHom.neg_iff_ker'
code: @[to_additive]
theorem inv_iff_ker' {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ a⁻¹ * b ∈ ker f 
goal: f a = f b ↔ -a + b ∈ IsAddGroupHom.ker f

full_name: IsAddGroupHom.image_addSubgroup
code: @[to_additive]
theorem image_subgroup {f : G → H} (hf : IsGroupHom f) {s : Set G} (hs : IsSubgroup s) :
    IsSubgroup (f '' s) 
goal: IsAddSubgroup (f '' s)

full_name: IsGroupHom.image_subgroup
code: @[to_additive]
theorem image_subgroup {f : G → H} (hf : IsGroupHom f) {s : Set G} (hs : IsSubgroup s) :
    IsSubgroup (f '' s) 
goal: IsSubgroup (f '' s)

full_name: IsGroupHom.range_subgroup
code: @[to_additive]
theorem range_subgroup {f : G → H} (hf : IsGroupHom f) : IsSubgroup (Set.range f) 
goal: IsSubgroup (Set.range f)

full_name: IsAddGroupHom.range_addSubgroup
code: @[to_additive]
theorem range_subgroup {f : G → H} (hf : IsGroupHom f) : IsSubgroup (Set.range f) 
goal: IsAddSubgroup (Set.range f)

full_name: IsAddGroupHom.preimage
code: @[to_additive]
theorem preimage {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsSubgroup s) :
    IsSubgroup (f ⁻¹' s) 
goal: IsAddSubgroup (f ⁻¹' s)

full_name: IsGroupHom.preimage
code: @[to_additive]
theorem preimage {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsSubgroup s) :
    IsSubgroup (f ⁻¹' s) 
goal: IsSubgroup (f ⁻¹' s)

full_name: IsGroupHom.preimage_normal
code: @[to_additive]
theorem preimage_normal {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsNormalSubgroup s) :
    IsNormalSubgroup (f ⁻¹' s) 
goal: IsNormalSubgroup (f ⁻¹' s)

full_name: IsAddGroupHom.preimage_normal
code: @[to_additive]
theorem preimage_normal {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsNormalSubgroup s) :
    IsNormalSubgroup (f ⁻¹' s) 
goal: IsNormalAddSubgroup (f ⁻¹' s)

full_name: IsAddGroupHom.isNormalAddSubgroup_ker
code: @[to_additive]
theorem isNormalSubgroup_ker {f : G → H} (hf : IsGroupHom f) : IsNormalSubgroup (ker f) 
goal: IsNormalAddSubgroup (IsAddGroupHom.ker f)

full_name: IsGroupHom.isNormalSubgroup_ker
code: @[to_additive]
theorem isNormalSubgroup_ker {f : G → H} (hf : IsGroupHom f) : IsNormalSubgroup (ker f) 
goal: IsNormalSubgroup (IsGroupHom.ker f)

full_name: IsAddGroupHom.injective_of_trivial_ker
code: @[to_additive]
theorem injective_of_trivial_ker {f : G → H} (hf : IsGroupHom f) (h : ker f = trivial G) :
    Function.Injective f 
goal: Function.Injective f

full_name: IsGroupHom.injective_of_trivial_ker
code: @[to_additive]
theorem injective_of_trivial_ker {f : G → H} (hf : IsGroupHom f) (h : ker f = trivial G) :
    Function.Injective f 
goal: Function.Injective f

full_name: IsGroupHom.trivial_ker_of_injective
code: @[to_additive]
theorem trivial_ker_of_injective {f : G → H} (hf : IsGroupHom f) (h : Function.Injective f) :
    ker f = trivial G 
goal: IsGroupHom.ker f = IsSubgroup.trivial G

full_name: IsAddGroupHom.trivial_ker_of_injective
code: @[to_additive]
theorem trivial_ker_of_injective {f : G → H} (hf : IsGroupHom f) (h : Function.Injective f) :
    ker f = trivial G 
goal: IsAddGroupHom.ker f = IsAddSubgroup.trivial G

full_name: IsAddGroupHom.injective_iff_trivial_ker
code: @[to_additive]
theorem injective_iff_trivial_ker {f : G → H} (hf : IsGroupHom f) :
    Function.Injective f ↔ ker f = trivial G 
goal: Function.Injective f ↔ IsAddGroupHom.ker f = IsAddSubgroup.trivial G

full_name: IsGroupHom.injective_iff_trivial_ker
code: @[to_additive]
theorem injective_iff_trivial_ker {f : G → H} (hf : IsGroupHom f) :
    Function.Injective f ↔ ker f = trivial G 
goal: Function.Injective f ↔ IsGroupHom.ker f = IsSubgroup.trivial G

full_name: IsAddGroupHom.trivial_ker_iff_eq_zero
code: @[to_additive]
theorem trivial_ker_iff_eq_one {f : G → H} (hf : IsGroupHom f) :
    ker f = trivial G ↔ ∀ x, f x = 1 → x = 1 
goal: IsAddGroupHom.ker f = IsAddSubgroup.trivial G ↔ ∀ (x : G), f x = 0 → x = 0

full_name: IsGroupHom.trivial_ker_iff_eq_one
code: @[to_additive]
theorem trivial_ker_iff_eq_one {f : G → H} (hf : IsGroupHom f) :
    ker f = trivial G ↔ ∀ x, f x = 1 → x = 1 
goal: IsGroupHom.ker f = IsSubgroup.trivial G ↔ ∀ (x : G), f x = 1 → x = 1

full_name: AddGroup.InClosure.neg
code: /-- If `A` is an additive group and `s : Set A`, then `InClosure s : Set A` is the underlying
subset of the subgroup generated by `s`. -/
inductive InClosure (s : Set A) : A → Prop
  | basic {a : A} : a ∈ s → InClosure s a
  | zero : InClosure s 0
  | neg {a : A} : InClosure s a → InClosure s (-a)
  | add {a b : A} : InClosure s a → InClosure s b → InClosure s (a + b)
goal: AddGroup.InClosure s a → AddGroup.InClosure s (-a)

full_name: AddGroup.InClosure.zero
code: /-- If `A` is an additive group and `s : Set A`, then `InClosure s : Set A` is the underlying
subset of the subgroup generated by `s`. -/
inductive InClosure (s : Set A) : A → Prop
  | basic {a : A} : a ∈ s → InClosure s a
  | zero : InClosure s 0
  | neg {a : A} : InClosure s a → InClosure s (-a)
  | add {a b : A} : InClosure s a → InClosure s b → InClosure s (a + b)
goal: AddGroup.InClosure s 0

full_name: AddGroup.InClosure.basic
code: /-- If `A` is an additive group and `s : Set A`, then `InClosure s : Set A` is the underlying
subset of the subgroup generated by `s`. -/
inductive InClosure (s : Set A) : A → Prop
  | basic {a : A} : a ∈ s → InClosure s a
  | zero : InClosure s 0
  | neg {a : A} : InClosure s a → InClosure s (-a)
  | add {a b : A} : InClosure s a → InClosure s b → InClosure s (a + b)
goal: a ∈ s → AddGroup.InClosure s a

full_name: AddGroup.InClosure
code: /-- If `A` is an additive group and `s : Set A`, then `InClosure s : Set A` is the underlying
subset of the subgroup generated by `s`. -/
inductive InClosure (s : Set A) : A → Prop
  | basic {a : A} : a ∈ s → InClosure s a
  | zero : InClosure s 0
  | neg {a : A} : InClosure s a → InClosure s (-a)
  | add {a b : A} : InClosure s a → InClosure s b → InClosure s (a + b)
goal: A → Prop

full_name: AddGroup.InClosure.add
code: /-- If `A` is an additive group and `s : Set A`, then `InClosure s : Set A` is the underlying
subset of the subgroup generated by `s`. -/
inductive InClosure (s : Set A) : A → Prop
  | basic {a : A} : a ∈ s → InClosure s a
  | zero : InClosure s 0
  | neg {a : A} : InClosure s a → InClosure s (-a)
  | add {a b : A} : InClosure s a → InClosure s b → InClosure s (a + b)
goal: AddGroup.InClosure s a → AddGroup.InClosure s b → AddGroup.InClosure s (a + b)

full_name: Group.InClosure.mul
code: /-- If `G` is a group and `s : Set G`, then `InClosure s : Set G` is the underlying
subset of the subgroup generated by `s`. -/
@[to_additive]
inductive InClosure (s : Set G) : G → Prop
  | basic {a : G} : a ∈ s → InClosure s a
  | one : InClosure s 1
  | inv {a : G} : InClosure s a → InClosure s a⁻¹
  | mul {a b : G} : InClosure s a → InClosure s b → InClosure s (a * b)
goal: Group.InClosure s a → Group.InClosure s b → Group.InClosure s (a * b)

full_name: Group.InClosure.basic
code: /-- If `G` is a group and `s : Set G`, then `InClosure s : Set G` is the underlying
subset of the subgroup generated by `s`. -/
@[to_additive]
inductive InClosure (s : Set G) : G → Prop
  | basic {a : G} : a ∈ s → InClosure s a
  | one : InClosure s 1
  | inv {a : G} : InClosure s a → InClosure s a⁻¹
  | mul {a b : G} : InClosure s a → InClosure s b → InClosure s (a * b)
goal: a ∈ s → Group.InClosure s a

full_name: Group.InClosure
code: /-- If `G` is a group and `s : Set G`, then `InClosure s : Set G` is the underlying
subset of the subgroup generated by `s`. -/
@[to_additive]
inductive InClosure (s : Set G) : G → Prop
  | basic {a : G} : a ∈ s → InClosure s a
  | one : InClosure s 1
  | inv {a : G} : InClosure s a → InClosure s a⁻¹
  | mul {a b : G} : InClosure s a → InClosure s b → InClosure s (a * b)
goal: G → Prop

full_name: Group.InClosure.one
code: /-- If `G` is a group and `s : Set G`, then `InClosure s : Set G` is the underlying
subset of the subgroup generated by `s`. -/
@[to_additive]
inductive InClosure (s : Set G) : G → Prop
  | basic {a : G} : a ∈ s → InClosure s a
  | one : InClosure s 1
  | inv {a : G} : InClosure s a → InClosure s a⁻¹
  | mul {a b : G} : InClosure s a → InClosure s b → InClosure s (a * b)
goal: Group.InClosure s 1

full_name: Group.InClosure.inv
code: /-- If `G` is a group and `s : Set G`, then `InClosure s : Set G` is the underlying
subset of the subgroup generated by `s`. -/
@[to_additive]
inductive InClosure (s : Set G) : G → Prop
  | basic {a : G} : a ∈ s → InClosure s a
  | one : InClosure s 1
  | inv {a : G} : InClosure s a → InClosure s a⁻¹
  | mul {a b : G} : InClosure s a → InClosure s b → InClosure s (a * b)
goal: Group.InClosure s a → Group.InClosure s a⁻¹

full_name: AddGroup.closure
code: /-- `Group.closure s` is the subgroup generated by `s`, i.e. the smallest subgroup containing `s`.
-/
@[to_additive
  "`AddGroup.closure s` is the additive subgroup generated by `s`, i.e., the
  smallest additive subgroup containing `s`."]
def closure (s : Set G) : Set G 
goal: Set G

full_name: Group.closure
code: /-- `Group.closure s` is the subgroup generated by `s`, i.e. the smallest subgroup containing `s`.
-/
@[to_additive
  "`AddGroup.closure s` is the additive subgroup generated by `s`, i.e., the
  smallest additive subgroup containing `s`."]
def closure (s : Set G) : Set G 
goal: Set G

full_name: AddGroup.mem_closure
code: @[to_additive]
theorem mem_closure {a : G} : a ∈ s → a ∈ closure s 
goal: a ∈ s → a ∈ AddGroup.closure s

full_name: Group.mem_closure
code: @[to_additive]
theorem mem_closure {a : G} : a ∈ s → a ∈ closure s 
goal: a ∈ s → a ∈ Group.closure s

full_name: AddGroup.closure.isAddSubgroup
code: @[to_additive]
theorem closure.isSubgroup (s : Set G) : IsSubgroup (closure s) 
goal: IsAddSubgroup (AddGroup.closure s)

full_name: Group.closure.isSubgroup
code: @[to_additive]
theorem closure.isSubgroup (s : Set G) : IsSubgroup (closure s) 
goal: IsSubgroup (Group.closure s)

full_name: Group.subset_closure
code: @[to_additive]
theorem subset_closure {s : Set G} : s ⊆ closure s 
goal: s ⊆ Group.closure s

full_name: AddGroup.subset_closure
code: @[to_additive]
theorem subset_closure {s : Set G} : s ⊆ closure s 
goal: s ⊆ AddGroup.closure s

full_name: AddGroup.closure_subset
code: @[to_additive]
theorem closure_subset {s t : Set G} (ht : IsSubgroup t) (h : s ⊆ t) : closure s ⊆ t 
goal: AddGroup.closure s ⊆ t

full_name: Group.closure_subset
code: @[to_additive]
theorem closure_subset {s t : Set G} (ht : IsSubgroup t) (h : s ⊆ t) : closure s ⊆ t 
goal: Group.closure s ⊆ t

full_name: Group.closure_subset_iff
code: @[to_additive]
theorem closure_subset_iff {s t : Set G} (ht : IsSubgroup t) : closure s ⊆ t ↔ s ⊆ t 
goal: Group.closure s ⊆ t ↔ s ⊆ t

full_name: AddGroup.closure_subset_iff
code: @[to_additive]
theorem closure_subset_iff {s t : Set G} (ht : IsSubgroup t) : closure s ⊆ t ↔ s ⊆ t 
goal: AddGroup.closure s ⊆ t ↔ s ⊆ t

full_name: Group.closure_mono
code: @[to_additive]
theorem closure_mono {s t : Set G} (h : s ⊆ t) : closure s ⊆ closure t 
goal: Group.closure s ⊆ Group.closure t

full_name: AddGroup.closure_mono
code: @[to_additive]
theorem closure_mono {s t : Set G} (h : s ⊆ t) : closure s ⊆ closure t 
goal: AddGroup.closure s ⊆ AddGroup.closure t

full_name: Group.closure_subgroup
code: @[to_additive (attr := simp)]
theorem closure_subgroup {s : Set G} (hs : IsSubgroup s) : closure s = s 
goal: Group.closure s = s

full_name: AddGroup.closure_addSubgroup
code: @[to_additive (attr := simp)]
theorem closure_subgroup {s : Set G} (hs : IsSubgroup s) : closure s = s 
goal: AddGroup.closure s = s

full_name: AddGroup.exists_list_of_mem_closure
code: @[to_additive]
theorem exists_list_of_mem_closure {s : Set G} {a : G} (h : a ∈ closure s) :
    ∃ l : List G, (∀ x ∈ l, x ∈ s ∨ x⁻¹ ∈ s) ∧ l.prod = a 
goal: ∃ l, (∀ x ∈ l, x ∈ s ∨ -x ∈ s) ∧ l.sum = a

full_name: Group.exists_list_of_mem_closure
code: @[to_additive]
theorem exists_list_of_mem_closure {s : Set G} {a : G} (h : a ∈ closure s) :
    ∃ l : List G, (∀ x ∈ l, x ∈ s ∨ x⁻¹ ∈ s) ∧ l.prod = a 
goal: ∃ l, (∀ x ∈ l, x ∈ s ∨ x⁻¹ ∈ s) ∧ l.prod = a

full_name: AddGroup.image_closure
code: @[to_additive]
theorem image_closure [Group H] {f : G → H} (hf : IsGroupHom f) (s : Set G) :
    f '' closure s = closure (f '' s) 
goal: f '' AddGroup.closure s = AddGroup.closure (f '' s)

full_name: Group.image_closure
code: @[to_additive]
theorem image_closure [Group H] {f : G → H} (hf : IsGroupHom f) (s : Set G) :
    f '' closure s = closure (f '' s) 
goal: f '' Group.closure s = Group.closure (f '' s)

full_name: Group.mclosure_subset
code: @[to_additive]
theorem mclosure_subset {s : Set G} : Monoid.Closure s ⊆ closure s 
goal: Monoid.Closure s ⊆ Group.closure s

full_name: AddGroup.mclosure_subset
code: @[to_additive]
theorem mclosure_subset {s : Set G} : Monoid.Closure s ⊆ closure s 
goal: AddMonoid.Closure s ⊆ AddGroup.closure s

full_name: Group.mclosure_inv_subset
code: @[to_additive]
theorem mclosure_inv_subset {s : Set G} : Monoid.Closure (Inv.inv ⁻¹' s) ⊆ closure s 
goal: Monoid.Closure (Inv.inv ⁻¹' s) ⊆ Group.closure s

full_name: AddGroup.mclosure_neg_subset
code: @[to_additive]
theorem mclosure_inv_subset {s : Set G} : Monoid.Closure (Inv.inv ⁻¹' s) ⊆ closure s 
goal: AddMonoid.Closure (Neg.neg ⁻¹' s) ⊆ AddGroup.closure s

full_name: Group.closure_eq_mclosure
code: @[to_additive]
theorem closure_eq_mclosure {s : Set G} : closure s = Monoid.Closure (s ∪ Inv.inv ⁻¹' s) 
goal: Group.closure s = Monoid.Closure (s ∪ Inv.inv ⁻¹' s)

full_name: AddGroup.closure_eq_mclosure
code: @[to_additive]
theorem closure_eq_mclosure {s : Set G} : closure s = Monoid.Closure (s ∪ Inv.inv ⁻¹' s) 
goal: AddGroup.closure s = AddMonoid.Closure (s ∪ Neg.neg ⁻¹' s)

full_name: AddGroup.mem_closure_union_iff
code: @[to_additive]
theorem mem_closure_union_iff {G : Type*} [CommGroup G] {s t : Set G} {x : G} :
    x ∈ closure (s ∪ t) ↔ ∃ y ∈ closure s, ∃ z ∈ closure t, y * z = x 
goal: x ∈ AddGroup.closure (s ∪ t) ↔ ∃ y ∈ AddGroup.closure s, ∃ z ∈ AddGroup.closure t, y + z = x

full_name: Group.mem_closure_union_iff
code: @[to_additive]
theorem mem_closure_union_iff {G : Type*} [CommGroup G] {s t : Set G} {x : G} :
    x ∈ closure (s ∪ t) ↔ ∃ y ∈ closure s, ∃ z ∈ closure t, y * z = x 
goal: x ∈ Group.closure (s ∪ t) ↔ ∃ y ∈ Group.closure s, ∃ z ∈ Group.closure t, y * z = x

full_name: IsSubgroup.trivial_eq_closure
code: @[to_additive]
theorem trivial_eq_closure : trivial G = Group.closure ∅ 
goal: IsSubgroup.trivial G = Group.closure ∅

full_name: IsAddSubgroup.trivial_eq_closure
code: @[to_additive]
theorem trivial_eq_closure : trivial G = Group.closure ∅ 
goal: IsAddSubgroup.trivial G = AddGroup.closure ∅

full_name: Group.conjugatesOf_subset
code: theorem conjugatesOf_subset {t : Set G} (ht : IsNormalSubgroup t) {a : G} (h : a ∈ t) :
    conjugatesOf a ⊆ t 
goal: conjugatesOf a ⊆ t

full_name: Group.conjugatesOfSet_subset'
code: theorem conjugatesOfSet_subset' {s t : Set G} (ht : IsNormalSubgroup t) (h : s ⊆ t) :
    conjugatesOfSet s ⊆ t 
goal: Group.conjugatesOfSet s ⊆ t

full_name: Group.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) : Set G 
goal: Set G

full_name: Group.conjugatesOfSet_subset_normalClosure
code: theorem conjugatesOfSet_subset_normalClosure : conjugatesOfSet s ⊆ normalClosure s 
goal: Group.conjugatesOfSet s ⊆ Group.normalClosure s

full_name: Group.subset_normalClosure
code: theorem subset_normalClosure : s ⊆ normalClosure s 
goal: s ⊆ Group.normalClosure s

full_name: Group.normalClosure.isSubgroup
code: /-- The normal closure of a set is a subgroup. -/
theorem normalClosure.isSubgroup (s : Set G) : IsSubgroup (normalClosure s) 
goal: IsSubgroup (Group.normalClosure s)

full_name: Group.normalClosure.is_normal
code: /-- The normal closure of s is a normal subgroup. -/
theorem normalClosure.is_normal : IsNormalSubgroup (normalClosure s) 
goal: IsNormalSubgroup (Group.normalClosure s)

full_name: Group.normalClosure_subset
code: /-- The normal closure of s is the smallest normal subgroup containing s. -/
theorem normalClosure_subset {s t : Set G} (ht : IsNormalSubgroup t) (h : s ⊆ t) :
    normalClosure s ⊆ t 
goal: Group.normalClosure s ⊆ t

full_name: Group.normalClosure_subset_iff
code: theorem normalClosure_subset_iff {s t : Set G} (ht : IsNormalSubgroup t) :
    s ⊆ t ↔ normalClosure s ⊆ t 
goal: s ⊆ t ↔ Group.normalClosure s ⊆ t

full_name: Group.normalClosure_mono
code: theorem normalClosure_mono {s t : Set G} : s ⊆ t → normalClosure s ⊆ normalClosure t 
goal: s ⊆ t → Group.normalClosure s ⊆ Group.normalClosure t

full_name: Subgroup.of
code: /-- Create a bundled subgroup from a set `s` and `[IsSubgroup s]`. -/
@[to_additive "Create a bundled additive subgroup from a set `s` and `[IsAddSubgroup s]`."]
def Subgroup.of [Group G] {s : Set G} (h : IsSubgroup s) : Subgroup G 
goal: Subgroup G

full_name: AddSubgroup.of
code: /-- Create a bundled subgroup from a set `s` and `[IsSubgroup s]`. -/
@[to_additive "Create a bundled additive subgroup from a set `s` and `[IsAddSubgroup s]`."]
def Subgroup.of [Group G] {s : Set G} (h : IsSubgroup s) : Subgroup G 
goal: AddSubgroup G

full_name: AddSubgroup.isAddSubgroup
code: @[to_additive]
theorem Subgroup.isSubgroup [Group G] (K : Subgroup G) : IsSubgroup (K : Set G) 
goal: IsAddSubgroup ↑K

full_name: Subgroup.isSubgroup
code: @[to_additive]
theorem Subgroup.isSubgroup [Group G] (K : Subgroup G) : IsSubgroup (K : Set G) 
goal: IsSubgroup ↑K

full_name: Subgroup.of_normal
code: @[to_additive]
theorem Subgroup.of_normal [Group G] (s : Set G) (h : IsSubgroup s) (n : IsNormalSubgroup s) :
    Subgroup.Normal (Subgroup.of h) 
goal: (Subgroup.of h).Normal

full_name: AddSubgroup.of_normal
code: @[to_additive]
theorem Subgroup.of_normal [Group G] (s : Set G) (h : IsSubgroup s) (n : IsNormalSubgroup s) :
    Subgroup.Normal (Subgroup.of h) 
goal: (AddSubgroup.of h).Normal