File: Mathlib/GroupTheory/Finiteness.lean

full_name: Submonoid.FG
code: /-- A submonoid of `M` is finitely generated if it is the closure of a finite subset of `M`. -/
@[to_additive]
def Submonoid.FG (P : Submonoid M) : Prop 
goal: Prop

full_name: AddSubmonoid.FG
code: /-- A submonoid of `M` is finitely generated if it is the closure of a finite subset of `M`. -/
@[to_additive]
def Submonoid.FG (P : Submonoid M) : Prop 
goal: Prop

full_name: AddSubmonoid.fg_iff
code: /-- An equivalent expression of `Submonoid.FG` in terms of `Set.Finite` instead of `Finset`. -/
@[to_additive "An equivalent expression of `AddSubmonoid.FG` in terms of `Set.Finite` instead of
`Finset`."]
theorem Submonoid.fg_iff (P : Submonoid M) :
    Submonoid.FG P ↔ ∃ S : Set M, Submonoid.closure S = P ∧ S.Finite 
goal: P.FG ↔ ∃ S, AddSubmonoid.closure S = P ∧ S.Finite

full_name: Submonoid.fg_iff
code: /-- An equivalent expression of `Submonoid.FG` in terms of `Set.Finite` instead of `Finset`. -/
@[to_additive "An equivalent expression of `AddSubmonoid.FG` in terms of `Set.Finite` instead of
`Finset`."]
theorem Submonoid.fg_iff (P : Submonoid M) :
    Submonoid.FG P ↔ ∃ S : Set M, Submonoid.closure S = P ∧ S.Finite 
goal: P.FG ↔ ∃ S, Submonoid.closure S = P ∧ S.Finite

full_name: Submonoid.fg_iff_add_fg
code: theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG 
goal: P.FG ↔ (Submonoid.toAddSubmonoid P).FG

full_name: AddSubmonoid.fg_iff_mul_fg
code: theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.FG ↔ P.toSubmonoid.FG 
goal: P.FG ↔ (AddSubmonoid.toSubmonoid P).FG

full_name: Monoid.FG
code: /-- A monoid is finitely generated if it is finitely generated as a submonoid of itself. -/
class Monoid.FG : Prop where
  out : (⊤ : Submonoid M).FG
goal: Prop

full_name: Monoid.FG.out
code: /-- A monoid is finitely generated if it is finitely generated as a submonoid of itself. -/
class Monoid.FG : Prop where
  out : (⊤ : Submonoid M).FG
goal: ⊤.FG

full_name: AddMonoid.FG.out
code: /-- An additive monoid is finitely generated if it is finitely generated as an additive submonoid of
itself. -/
class AddMonoid.FG : Prop where
  out : (⊤ : AddSubmonoid N).FG
goal: ⊤.FG

full_name: AddMonoid.FG
code: /-- An additive monoid is finitely generated if it is finitely generated as an additive submonoid of
itself. -/
class AddMonoid.FG : Prop where
  out : (⊤ : AddSubmonoid N).FG
goal: Prop

full_name: Monoid.fg_def
code: theorem Monoid.fg_def : Monoid.FG M ↔ (⊤ : Submonoid M).FG 
goal: Monoid.FG M ↔ ⊤.FG

full_name: AddMonoid.fg_def
code: theorem AddMonoid.fg_def : AddMonoid.FG N ↔ (⊤ : AddSubmonoid N).FG 
goal: AddMonoid.FG N ↔ ⊤.FG

full_name: Monoid.fg_iff
code: /-- An equivalent expression of `Monoid.FG` in terms of `Set.Finite` instead of `Finset`. -/
@[to_additive
      "An equivalent expression of `AddMonoid.FG` in terms of `Set.Finite` instead of `Finset`."]
theorem Monoid.fg_iff :
    Monoid.FG M ↔ ∃ S : Set M, Submonoid.closure S = (⊤ : Submonoid M) ∧ S.Finite 
goal: Monoid.FG M ↔ ∃ S, Submonoid.closure S = ⊤ ∧ S.Finite

full_name: AddMonoid.fg_iff
code: /-- An equivalent expression of `Monoid.FG` in terms of `Set.Finite` instead of `Finset`. -/
@[to_additive
      "An equivalent expression of `AddMonoid.FG` in terms of `Set.Finite` instead of `Finset`."]
theorem Monoid.fg_iff :
    Monoid.FG M ↔ ∃ S : Set M, Submonoid.closure S = (⊤ : Submonoid M) ∧ S.Finite 
goal: AddMonoid.FG M ↔ ∃ S, AddSubmonoid.closure S = ⊤ ∧ S.Finite

full_name: Monoid.fg_iff_add_fg
code: theorem Monoid.fg_iff_add_fg : Monoid.FG M ↔ AddMonoid.FG (Additive M) 
goal: Monoid.FG M ↔ AddMonoid.FG (Additive M)

full_name: AddMonoid.fg_iff_mul_fg
code: theorem AddMonoid.fg_iff_mul_fg : AddMonoid.FG N ↔ Monoid.FG (Multiplicative N) 
goal: AddMonoid.FG N ↔ Monoid.FG (Multiplicative N)

full_name: AddMonoid.fg_of_monoid_fg
code: instance AddMonoid.fg_of_monoid_fg [Monoid.FG M] : AddMonoid.FG (Additive M) 
goal: AddMonoid.FG (Additive M)

full_name: Monoid.fg_of_addMonoid_fg
code: instance Monoid.fg_of_addMonoid_fg [AddMonoid.FG N] : Monoid.FG (Multiplicative N) 
goal: Monoid.FG (Multiplicative N)

full_name: AddMonoid.fg_of_finite
code: @[to_additive]
instance (priority := 100) Monoid.fg_of_finite [Finite M] : Monoid.FG M 
goal: AddMonoid.FG M

full_name: Monoid.fg_of_finite
code: @[to_additive]
instance (priority := 100) Monoid.fg_of_finite [Finite M] : Monoid.FG M 
goal: Monoid.FG M

full_name: Submonoid.FG.map
code: @[to_additive]
theorem Submonoid.FG.map {M' : Type*} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M') :
    (P.map e).FG 
goal: (Submonoid.map e P).FG

full_name: AddSubmonoid.FG.map
code: @[to_additive]
theorem Submonoid.FG.map {M' : Type*} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M') :
    (P.map e).FG 
goal: (AddSubmonoid.map e P).FG

full_name: Submonoid.FG.map_injective
code: @[to_additive]
theorem Submonoid.FG.map_injective {M' : Type*} [Monoid M'] {P : Submonoid M} (e : M →* M')
    (he : Function.Injective e) (h : (P.map e).FG) : P.FG 
goal: P.FG

full_name: AddSubmonoid.FG.map_injective
code: @[to_additive]
theorem Submonoid.FG.map_injective {M' : Type*} [Monoid M'] {P : Submonoid M} (e : M →* M')
    (he : Function.Injective e) (h : (P.map e).FG) : P.FG 
goal: P.FG

full_name: AddMonoid.fg_iff_addSubmonoid_fg
code: @[to_additive (attr := simp)]
theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG 
goal: AddMonoid.FG ↥N ↔ N.FG

full_name: Monoid.fg_iff_submonoid_fg
code: @[to_additive (attr := simp)]
theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG 
goal: Monoid.FG ↥N ↔ N.FG

full_name: Monoid.fg_of_surjective
code: @[to_additive]
theorem Monoid.fg_of_surjective {M' : Type*} [Monoid M'] [Monoid.FG M] (f : M →* M')
    (hf : Function.Surjective f) : Monoid.FG M' 
goal: Monoid.FG M'

full_name: AddMonoid.fg_of_surjective
code: @[to_additive]
theorem Monoid.fg_of_surjective {M' : Type*} [Monoid M'] [Monoid.FG M] (f : M →* M')
    (hf : Function.Surjective f) : Monoid.FG M' 
goal: AddMonoid.FG M'

full_name: Monoid.fg_range
code: @[to_additive]
instance Monoid.fg_range {M' : Type*} [Monoid M'] [Monoid.FG M] (f : M →* M') :
    Monoid.FG (MonoidHom.mrange f) 
goal: Monoid.FG ↥(MonoidHom.mrange f)

full_name: AddMonoid.fg_range
code: @[to_additive]
instance Monoid.fg_range {M' : Type*} [Monoid M'] [Monoid.FG M] (f : M →* M') :
    Monoid.FG (MonoidHom.mrange f) 
goal: AddMonoid.FG ↥(AddMonoidHom.mrange f)

full_name: AddSubmonoid.multiples_fg
code: @[to_additive]
theorem Submonoid.powers_fg (r : M) : (Submonoid.powers r).FG 
goal: (AddSubmonoid.multiples r).FG

full_name: Submonoid.powers_fg
code: @[to_additive]
theorem Submonoid.powers_fg (r : M) : (Submonoid.powers r).FG 
goal: (Submonoid.powers r).FG

full_name: Monoid.powers_fg
code: @[to_additive]
instance Monoid.powers_fg (r : M) : Monoid.FG (Submonoid.powers r) 
goal: Monoid.FG ↥(Submonoid.powers r)

full_name: AddMonoid.multiples_fg
code: @[to_additive]
instance Monoid.powers_fg (r : M) : Monoid.FG (Submonoid.powers r) 
goal: AddMonoid.FG ↥(AddSubmonoid.multiples r)

full_name: Monoid.closure_finset_fg
code: @[to_additive]
instance Monoid.closure_finset_fg (s : Finset M) : Monoid.FG (Submonoid.closure (s : Set M)) 
goal: Monoid.FG ↥(Submonoid.closure ↑s)

full_name: AddMonoid.closure_finset_fg
code: @[to_additive]
instance Monoid.closure_finset_fg (s : Finset M) : Monoid.FG (Submonoid.closure (s : Set M)) 
goal: AddMonoid.FG ↥(AddSubmonoid.closure ↑s)

full_name: Monoid.closure_finite_fg
code: @[to_additive]
instance Monoid.closure_finite_fg (s : Set M) [Finite s] : Monoid.FG (Submonoid.closure s) 
goal: Monoid.FG ↥(Submonoid.closure s)

full_name: AddMonoid.closure_finite_fg
code: @[to_additive]
instance Monoid.closure_finite_fg (s : Set M) [Finite s] : Monoid.FG (Submonoid.closure s) 
goal: AddMonoid.FG ↥(AddSubmonoid.closure s)

full_name: AddSubgroup.FG
code: /-- A subgroup of `G` is finitely generated if it is the closure of a finite subset of `G`. -/
@[to_additive]
def Subgroup.FG (P : Subgroup G) : Prop 
goal: Prop

full_name: Subgroup.FG
code: /-- A subgroup of `G` is finitely generated if it is the closure of a finite subset of `G`. -/
@[to_additive]
def Subgroup.FG (P : Subgroup G) : Prop 
goal: Prop

full_name: Subgroup.fg_iff
code: /-- An equivalent expression of `Subgroup.FG` in terms of `Set.Finite` instead of `Finset`. -/
@[to_additive "An equivalent expression of `AddSubgroup.fg` in terms of `Set.Finite` instead of
`Finset`."]
theorem Subgroup.fg_iff (P : Subgroup G) :
    Subgroup.FG P ↔ ∃ S : Set G, Subgroup.closure S = P ∧ S.Finite 
goal: P.FG ↔ ∃ S, Subgroup.closure S = P ∧ S.Finite

full_name: AddSubgroup.fg_iff
code: /-- An equivalent expression of `Subgroup.FG` in terms of `Set.Finite` instead of `Finset`. -/
@[to_additive "An equivalent expression of `AddSubgroup.fg` in terms of `Set.Finite` instead of
`Finset`."]
theorem Subgroup.fg_iff (P : Subgroup G) :
    Subgroup.FG P ↔ ∃ S : Set G, Subgroup.closure S = P ∧ S.Finite 
goal: P.FG ↔ ∃ S, AddSubgroup.closure S = P ∧ S.Finite

full_name: AddSubgroup.fg_iff_addSubmonoid_fg
code: /-- A subgroup is finitely generated if and only if it is finitely generated as a submonoid. -/
@[to_additive "An additive subgroup is finitely generated if
and only if it is finitely generated as an additive submonoid."]
theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.FG ↔ P.toSubmonoid.FG 
goal: P.FG ↔ P.FG

full_name: Subgroup.fg_iff_submonoid_fg
code: /-- A subgroup is finitely generated if and only if it is finitely generated as a submonoid. -/
@[to_additive "An additive subgroup is finitely generated if
and only if it is finitely generated as an additive submonoid."]
theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.FG ↔ P.toSubmonoid.FG 
goal: P.FG ↔ P.FG

full_name: Subgroup.fg_iff_add_fg
code: theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.FG ↔ P.toAddSubgroup.FG 
goal: P.FG ↔ (Subgroup.toAddSubgroup P).FG

full_name: AddSubgroup.fg_iff_mul_fg
code: theorem AddSubgroup.fg_iff_mul_fg (P : AddSubgroup H) : P.FG ↔ P.toSubgroup.FG 
goal: P.FG ↔ (AddSubgroup.toSubgroup P).FG

full_name: Group.FG
code: /-- A group is finitely generated if it is finitely generated as a submonoid of itself. -/
class Group.FG : Prop where
  out : (⊤ : Subgroup G).FG
goal: Prop

full_name: Group.FG.out
code: /-- A group is finitely generated if it is finitely generated as a submonoid of itself. -/
class Group.FG : Prop where
  out : (⊤ : Subgroup G).FG
goal: ⊤.FG

full_name: AddGroup.FG
code: /-- An additive group is finitely generated if it is finitely generated as an additive submonoid of
itself. -/
class AddGroup.FG : Prop where
  out : (⊤ : AddSubgroup H).FG
goal: Prop

full_name: AddGroup.FG.out
code: /-- An additive group is finitely generated if it is finitely generated as an additive submonoid of
itself. -/
class AddGroup.FG : Prop where
  out : (⊤ : AddSubgroup H).FG
goal: ⊤.FG

full_name: Group.fg_def
code: theorem Group.fg_def : Group.FG G ↔ (⊤ : Subgroup G).FG 
goal: Group.FG G ↔ ⊤.FG

full_name: AddGroup.fg_def
code: theorem AddGroup.fg_def : AddGroup.FG H ↔ (⊤ : AddSubgroup H).FG 
goal: AddGroup.FG H ↔ ⊤.FG

full_name: Group.fg_iff
code: /-- An equivalent expression of `Group.FG` in terms of `Set.Finite` instead of `Finset`. -/
@[to_additive
      "An equivalent expression of `AddGroup.fg` in terms of `Set.Finite` instead of `Finset`."]
theorem Group.fg_iff : Group.FG G ↔ ∃ S : Set G, Subgroup.closure S = (⊤ : Subgroup G) ∧ S.Finite 
goal: Group.FG G ↔ ∃ S, Subgroup.closure S = ⊤ ∧ S.Finite

full_name: AddGroup.fg_iff
code: /-- An equivalent expression of `Group.FG` in terms of `Set.Finite` instead of `Finset`. -/
@[to_additive
      "An equivalent expression of `AddGroup.fg` in terms of `Set.Finite` instead of `Finset`."]
theorem Group.fg_iff : Group.FG G ↔ ∃ S : Set G, Subgroup.closure S = (⊤ : Subgroup G) ∧ S.Finite 
goal: AddGroup.FG G ↔ ∃ S, AddSubgroup.closure S = ⊤ ∧ S.Finite

full_name: Group.fg_iff'
code: @[to_additive]
theorem Group.fg_iff' :
    Group.FG G ↔ ∃ (n : _) (S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ 
goal: Group.FG G ↔ ∃ n S, S.card = n ∧ Subgroup.closure ↑S = ⊤

full_name: AddGroup.fg_iff'
code: @[to_additive]
theorem Group.fg_iff' :
    Group.FG G ↔ ∃ (n : _) (S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ 
goal: AddGroup.FG G ↔ ∃ n S, S.card = n ∧ AddSubgroup.closure ↑S = ⊤

full_name: AddGroup.fg_iff_addMonoid_fg
code: /-- A group is finitely generated if and only if it is finitely generated as a monoid. -/
@[to_additive "An additive group is finitely generated if and only
if it is finitely generated as an additive monoid."]
theorem Group.fg_iff_monoid_fg : Group.FG G ↔ Monoid.FG G 
goal: AddGroup.FG G ↔ AddMonoid.FG G

full_name: Group.fg_iff_monoid_fg
code: /-- A group is finitely generated if and only if it is finitely generated as a monoid. -/
@[to_additive "An additive group is finitely generated if and only
if it is finitely generated as an additive monoid."]
theorem Group.fg_iff_monoid_fg : Group.FG G ↔ Monoid.FG G 
goal: Group.FG G ↔ Monoid.FG G

full_name: AddGroup.fg_iff_addSubgroup_fg
code: @[to_additive (attr := simp)]
theorem Group.fg_iff_subgroup_fg (H : Subgroup G) : Group.FG H ↔ H.FG 
goal: AddGroup.FG ↥H ↔ H.FG

full_name: Group.fg_iff_subgroup_fg
code: @[to_additive (attr := simp)]
theorem Group.fg_iff_subgroup_fg (H : Subgroup G) : Group.FG H ↔ H.FG 
goal: Group.FG ↥H ↔ H.FG

full_name: GroupFG.iff_add_fg
code: theorem GroupFG.iff_add_fg : Group.FG G ↔ AddGroup.FG (Additive G) 
goal: Group.FG G ↔ AddGroup.FG (Additive G)

full_name: AddGroup.fg_iff_mul_fg
code: theorem AddGroup.fg_iff_mul_fg : AddGroup.FG H ↔ Group.FG (Multiplicative H) 
goal: AddGroup.FG H ↔ Group.FG (Multiplicative H)

full_name: AddGroup.fg_of_group_fg
code: instance AddGroup.fg_of_group_fg [Group.FG G] : AddGroup.FG (Additive G) 
goal: AddGroup.FG (Additive G)

full_name: Group.fg_of_mul_group_fg
code: instance Group.fg_of_mul_group_fg [AddGroup.FG H] : Group.FG (Multiplicative H) 
goal: Group.FG (Multiplicative H)

full_name: AddGroup.fg_of_finite
code: @[to_additive]
instance (priority := 100) Group.fg_of_finite [Finite G] : Group.FG G 
goal: AddGroup.FG G

full_name: Group.fg_of_finite
code: @[to_additive]
instance (priority := 100) Group.fg_of_finite [Finite G] : Group.FG G 
goal: Group.FG G

full_name: AddGroup.fg_of_surjective
code: @[to_additive]
theorem Group.fg_of_surjective {G' : Type*} [Group G'] [hG : Group.FG G] {f : G →* G'}
    (hf : Function.Surjective f) : Group.FG G' 
goal: AddGroup.FG G'

full_name: Group.fg_of_surjective
code: @[to_additive]
theorem Group.fg_of_surjective {G' : Type*} [Group G'] [hG : Group.FG G] {f : G →* G'}
    (hf : Function.Surjective f) : Group.FG G' 
goal: Group.FG G'

full_name: AddGroup.fg_range
code: @[to_additive]
instance Group.fg_range {G' : Type*} [Group G'] [Group.FG G] (f : G →* G') : Group.FG f.range 
goal: AddGroup.FG ↥f.range

full_name: Group.fg_range
code: @[to_additive]
instance Group.fg_range {G' : Type*} [Group G'] [Group.FG G] (f : G →* G') : Group.FG f.range 
goal: Group.FG ↥f.range

full_name: AddGroup.closure_finset_fg
code: @[to_additive]
instance Group.closure_finset_fg (s : Finset G) : Group.FG (Subgroup.closure (s : Set G)) 
goal: AddGroup.FG ↥(AddSubgroup.closure ↑s)

full_name: Group.closure_finset_fg
code: @[to_additive]
instance Group.closure_finset_fg (s : Finset G) : Group.FG (Subgroup.closure (s : Set G)) 
goal: Group.FG ↥(Subgroup.closure ↑s)

full_name: Group.closure_finite_fg
code: @[to_additive]
instance Group.closure_finite_fg (s : Set G) [Finite s] : Group.FG (Subgroup.closure s) 
goal: Group.FG ↥(Subgroup.closure s)

full_name: AddGroup.closure_finite_fg
code: @[to_additive]
instance Group.closure_finite_fg (s : Set G) [Finite s] : Group.FG (Subgroup.closure s) 
goal: AddGroup.FG ↥(AddSubgroup.closure s)

full_name: Group.rank
code: /-- The minimum number of generators of a group. -/
@[to_additive "The minimum number of generators of an additive group"]
noncomputable def Group.rank [h : Group.FG G] 
goal: ℕ

full_name: AddGroup.rank
code: /-- The minimum number of generators of a group. -/
@[to_additive "The minimum number of generators of an additive group"]
noncomputable def Group.rank [h : Group.FG G] 
goal: ℕ

full_name: Group.rank_spec
code: @[to_additive]
theorem Group.rank_spec [h : Group.FG G] :
    ∃ S : Finset G, S.card = Group.rank G ∧ Subgroup.closure (S : Set G) = ⊤ 
goal: ∃ S, S.card = Group.rank G ∧ Subgroup.closure ↑S = ⊤

full_name: AddGroup.rank_spec
code: @[to_additive]
theorem Group.rank_spec [h : Group.FG G] :
    ∃ S : Finset G, S.card = Group.rank G ∧ Subgroup.closure (S : Set G) = ⊤ 
goal: ∃ S, S.card = AddGroup.rank G ∧ AddSubgroup.closure ↑S = ⊤

full_name: Group.rank_le
code: @[to_additive]
theorem Group.rank_le [h : Group.FG G] {S : Finset G} (hS : Subgroup.closure (S : Set G) = ⊤) :
    Group.rank G ≤ S.card 
goal: Group.rank G ≤ S.card

full_name: AddGroup.rank_le
code: @[to_additive]
theorem Group.rank_le [h : Group.FG G] {S : Finset G} (hS : Subgroup.closure (S : Set G) = ⊤) :
    Group.rank G ≤ S.card 
goal: AddGroup.rank G ≤ S.card

full_name: Group.rank_le_of_surjective
code: @[to_additive]
theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')
    (hf : Function.Surjective f) : Group.rank G' ≤ Group.rank G 
goal: Group.rank G' ≤ Group.rank G

full_name: AddGroup.rank_le_of_surjective
code: @[to_additive]
theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')
    (hf : Function.Surjective f) : Group.rank G' ≤ Group.rank G 
goal: AddGroup.rank G' ≤ AddGroup.rank G

full_name: Group.rank_range_le
code: @[to_additive]
theorem Group.rank_range_le [Group.FG G] {f : G →* G'} : Group.rank f.range ≤ Group.rank G 
goal: Group.rank ↥f.range ≤ Group.rank G

full_name: AddGroup.rank_range_le
code: @[to_additive]
theorem Group.rank_range_le [Group.FG G] {f : G →* G'} : Group.rank f.range ≤ Group.rank G 
goal: AddGroup.rank ↥f.range ≤ AddGroup.rank G

full_name: AddGroup.rank_congr
code: @[to_additive]
theorem Group.rank_congr [Group.FG G] [Group.FG G'] (f : G ≃* G') : Group.rank G = Group.rank G' 
goal: AddGroup.rank G = AddGroup.rank G'

full_name: Group.rank_congr
code: @[to_additive]
theorem Group.rank_congr [Group.FG G] [Group.FG G'] (f : G ≃* G') : Group.rank G = Group.rank G' 
goal: Group.rank G = Group.rank G'

full_name: AddSubgroup.rank_congr
code: @[to_additive]
theorem rank_congr {H K : Subgroup G} [Group.FG H] [Group.FG K] (h : H = K) :
    Group.rank H = Group.rank K 
goal: AddGroup.rank ↥H = AddGroup.rank ↥K

full_name: Subgroup.rank_congr
code: @[to_additive]
theorem rank_congr {H K : Subgroup G} [Group.FG H] [Group.FG K] (h : H = K) :
    Group.rank H = Group.rank K 
goal: Group.rank ↥H = Group.rank ↥K

full_name: Subgroup.rank_closure_finset_le_card
code: @[to_additive]
theorem rank_closure_finset_le_card (s : Finset G) : Group.rank (closure (s : Set G)) ≤ s.card 
goal: Group.rank ↥(Subgroup.closure ↑s) ≤ s.card

full_name: AddSubgroup.rank_closure_finset_le_card
code: @[to_additive]
theorem rank_closure_finset_le_card (s : Finset G) : Group.rank (closure (s : Set G)) ≤ s.card 
goal: AddGroup.rank ↥(AddSubgroup.closure ↑s) ≤ s.card

full_name: Subgroup.rank_closure_finite_le_nat_card
code: @[to_additive]
theorem rank_closure_finite_le_nat_card (s : Set G) [Finite s] :
    Group.rank (closure s) ≤ Nat.card s 
goal: Group.rank ↥(Subgroup.closure s) ≤ Nat.card ↑s

full_name: AddSubgroup.rank_closure_finite_le_nat_card
code: @[to_additive]
theorem rank_closure_finite_le_nat_card (s : Set G) [Finite s] :
    Group.rank (closure s) ≤ Nat.card s 
goal: AddGroup.rank ↥(AddSubgroup.closure s) ≤ Nat.card ↑s

full_name: QuotientGroup.fg
code: @[to_additive]
instance QuotientGroup.fg [Group.FG G] (N : Subgroup G) [Subgroup.Normal N] : Group.FG <| G ⧸ N 
goal: Group.FG (G ⧸ N)

full_name: QuotientAddGroup.fg
code: @[to_additive]
instance QuotientGroup.fg [Group.FG G] (N : Subgroup G) [Subgroup.Normal N] : Group.FG <| G ⧸ N 
goal: AddGroup.FG (G ⧸ N)