ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Doset.bot_rel_eq_leftRel
theorem bot_rel_eq_leftRel (H : Subgroup G) :
    (setoid ↑(⊥ : Subgroup G) ↑H).Rel = (QuotientGroup.leftRel H).Rel 
Arguments: {G : Type u_1} [Group G] (H : Subgroup G)
Goal: (Doset.setoid ↑⊥ ↑H).Rel = (QuotientGroup.leftRel H).Rel
-- Doset.rel_bot_eq_right_group_rel
theorem rel_bot_eq_right_group_rel (H : Subgroup G) :
    (setoid ↑H ↑(⊥ : Subgroup G)).Rel = (QuotientGroup.rightRel H).Rel 
Arguments: {G : Type u_1} [Group G] (H : Subgroup G)
Goal: (Doset.setoid ↑H ↑⊥).Rel = (QuotientGroup.rightRel H).Rel
-- Doset.eq
theorem eq (H K : Subgroup G) (a b : G) :
    mk H K a = mk H K b ↔ ∃ h ∈ H, ∃ k ∈ K, b = h * a * k 
Arguments: {G : Type u_1} [Group G] (H K : Subgroup G) (a b : G)
Goal: Doset.mk H K a = Doset.mk H K b ↔ ∃ h ∈ H, ∃ k ∈ K, b = h * a * k
-- Doset.out_eq'
theorem out_eq' (H K : Subgroup G) (q : Quotient ↑H ↑K) : mk H K q.out' = q 
Arguments: {G : Type u_1} [Group G] (H K : Subgroup G) (q : Doset.Quotient ↑H ↑K)
Goal: Doset.mk H K (Quotient.out' q) = q
-- Doset.mk_out'_eq_mul
theorem mk_out'_eq_mul (H K : Subgroup G) (g : G) :
    ∃ h k : G, h ∈ H ∧ k ∈ K ∧ (mk H K g : Quotient ↑H ↑K).out' = h * g * k 
Arguments: {G : Type u_1} [Group G] (H K : Subgroup G) (g : G)
Goal: ∃ h k, h ∈ H ∧ k ∈ K ∧ Quotient.out' (Doset.mk H K g) = h * g * k
-- Doset.mk_eq_of_doset_eq
theorem mk_eq_of_doset_eq {H K : Subgroup G} {a b : G} (h : doset a H K = doset b H K) :
    mk H K a = mk H K b 
Arguments: {G : Type u_1} [Group G] {H K : Subgroup G} {a b : G} (h : Doset.doset a ↑H ↑K = Doset.doset b ↑H ↑K)
Goal: Doset.mk H K a = Doset.mk H K b
-- Doset.disjoint_out'
theorem disjoint_out' {H K : Subgroup G} {a b : Quotient H.1 K} :
    a ≠ b → Disjoint (doset a.out' H K) (doset b.out' (H : Set G) K) 
Arguments: {G : Type u_1} [Group G] {H K : Subgroup G} {a b : Doset.Quotient ↑H.toSubmonoid ↑K}
Goal: a ≠ b → Disjoint (Doset.doset (Quotient.out' a) ↑H ↑K) (Doset.doset (Quotient.out' b) ↑H ↑K)
-- Doset.union_quotToDoset
theorem union_quotToDoset (H K : Subgroup G) : ⋃ q, quotToDoset H K q = Set.univ 
Arguments: {G : Type u_1} [Group G] (H K : Subgroup G)
Goal: ⋃ q, Doset.quotToDoset H K q = Set.univ
-- Doset.doset_union_rightCoset
theorem doset_union_rightCoset (H K : Subgroup G) (a : G) :
    ⋃ k : K, op (a * k) • ↑H = doset a H K 
Arguments: {G : Type u_1} [Group G] (H K : Subgroup G) (a : G)
Goal: ⋃ k, MulOpposite.op (a * ↑k) • ↑H = Doset.doset a ↑H ↑K
-- Doset.doset_union_leftCoset
theorem doset_union_leftCoset (H K : Subgroup G) (a : G) :
    ⋃ h : H, (h * a : G) • ↑K = doset a H K 
Arguments: {G : Type u_1} [Group G] (H K : Subgroup G) (a : G)
Goal: ⋃ h, (↑h * a) • ↑K = Doset.doset a ↑H ↑K
-- Doset.left_bot_eq_left_quot
theorem left_bot_eq_left_quot (H : Subgroup G) :
    Quotient (⊥ : Subgroup G).1 (H : Set G) = (G ⧸ H) 
Arguments: {G : Type u_1} [Group G] (H : Subgroup G)
Goal: Doset.Quotient ↑⊥.toSubmonoid ↑H = (G ⧸ H)
-- Doset.right_bot_eq_right_quot
theorem right_bot_eq_right_quot (H : Subgroup G) :
    Quotient (H.1 : Set G) (⊥ : Subgroup G) = _root_.Quotient (QuotientGroup.rightRel H) 
Arguments: {G : Type u_1} [Group G] (H : Subgroup G)
Goal: Doset.Quotient ↑H.toSubmonoid ↑⊥ = Quotient (QuotientGroup.rightRel H)
-- commProb_def
theorem commProb_def :
    commProb M = Nat.card { p : M × M // Commute p.1 p.2 } / (Nat.card M : ℚ) ^ 2 
Arguments: (M : Type u_1) [Mul M]
Goal: commProb M = ↑(Nat.card { p // Commute p.1 p.2 }) / ↑(Nat.card M) ^ 2
-- commProb_prod
theorem commProb_prod (M' : Type*) [Mul M'] : commProb (M × M') = commProb M * commProb M' 
Arguments: (M : Type u_1) [Mul M] (M' : Type u_2) [Mul M']
Goal: commProb (M × M') = commProb M * commProb M'
-- commProb_pi
theorem commProb_pi {α : Type*} (i : α → Type*) [Fintype α] [∀ a, Mul (i a)] :
    commProb (∀ a, i a) = ∏ a, commProb (i a) 
Arguments: {α : Type u_2} (i : α → Type u_3) [Fintype α] [(a : α) → Mul (i a)]
Goal: commProb ((a : α) → i a) = ∏ a : α, commProb (i a)
-- commProb_function
theorem commProb_function {α β : Type*} [Fintype α] [Mul β] :
    commProb (α → β) = (commProb β) ^ Fintype.card α 
Arguments: {α : Type u_2} {β : Type u_3} [Fintype α] [Mul β]
Goal: commProb (α → β) = commProb β ^ Fintype.card α
-- commProb_eq_zero_of_infinite
@[simp]
theorem commProb_eq_zero_of_infinite [Infinite M] : commProb M = 0 
Arguments: (M : Type u_1) [Mul M] [Infinite M]
Goal: commProb M = 0
-- commProb_pos
theorem commProb_pos [h : Nonempty M] : 0 < commProb M 
Arguments: (M : Type u_1) [Mul M] [Finite M] [h : Nonempty M]
Goal: 0 < commProb M
-- commProb_le_one
theorem commProb_le_one : commProb M ≤ 1 
Arguments: (M : Type u_1) [Mul M] [Finite M]
Goal: commProb M ≤ 1
-- commProb_eq_one_iff
theorem commProb_eq_one_iff [h : Nonempty M] :
    commProb M = 1 ↔ Commutative ((· * ·) : M → M → M) 
Arguments: {M : Type u_1} [Mul M] [Finite M] [h : Nonempty M]
Goal: commProb M = 1 ↔ Commutative fun x x_1 => x * x_1
-- commProb_def'
theorem commProb_def' : commProb G = Nat.card (ConjClasses G) / Nat.card G 
Arguments: (G : Type u_2) [Group G]
Goal: commProb G = ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)
-- Subgroup.commProb_subgroup_le
theorem Subgroup.commProb_subgroup_le : commProb H ≤ commProb G * (H.index : ℚ) ^ 2 
Arguments: {G : Type u_2} [Group G] [Finite G] (H : Subgroup G)
Goal: commProb ↥H ≤ commProb G * ↑H.index ^ 2
-- Subgroup.commProb_quotient_le
theorem Subgroup.commProb_quotient_le [H.Normal] : commProb (G ⧸ H) ≤ commProb G * Nat.card H 
Arguments: {G : Type u_2} [Group G] [Finite G] (H : Subgroup G) [H.Normal]
Goal: commProb (G ⧸ H) ≤ commProb G * ↑(Nat.card ↥H)
-- inv_card_commutator_le_commProb
theorem inv_card_commutator_le_commProb : (↑(Nat.card (commutator G)))⁻¹ ≤ commProb G 
Arguments: (G : Type u_2) [Group G] [Finite G]
Goal: (↑(Nat.card ↥(commutator G)))⁻¹ ≤ commProb G
-- DihedralGroup.commProb_odd
lemma commProb_odd {n : ℕ} (hn : Odd n) :
    commProb (DihedralGroup n) = (n + 3) / (4 * n) 
Arguments: {n : ℕ} (hn : Odd n)
Goal: commProb (DihedralGroup n) = (↑n + 3) / (4 * ↑n)
-- _private.Mathlib.GroupTheory.CommutingProbability.0.DihedralGroup.div_two_lt
private lemma div_two_lt {n : ℕ} (h0 : n ≠ 0) : n / 2 < n 
Arguments: {n : ℕ} (h0 : n ≠ 0)
Goal: n / 2 < n
-- _private.Mathlib.GroupTheory.CommutingProbability.0.DihedralGroup.div_four_lt
private lemma div_four_lt : {n : ℕ} → (h0 : n ≠ 0) → (h1 : n ≠ 1) → n / 4 + 1 < n
  
Arguments: {n : ℕ} (h0 : n ≠ 0) (h1 : n ≠ 1)
Goal: n / 4 + 1 < n
-- DihedralGroup.reciprocalFactors_zero
@[simp] lemma reciprocalFactors_zero : reciprocalFactors 0 = [0] 
Goal: DihedralGroup.reciprocalFactors 0 = [0]
-- DihedralGroup.reciprocalFactors_one
@[simp] lemma reciprocalFactors_one : reciprocalFactors 1 = [] 
Goal: DihedralGroup.reciprocalFactors 1 = []
-- DihedralGroup.reciprocalFactors_even
lemma reciprocalFactors_even {n : ℕ} (h0 : n ≠ 0) (h2 : Even n) :
    reciprocalFactors n = 3 :: reciprocalFactors (n / 2) 
Arguments: {n : ℕ} (h0 : n ≠ 0) (h2 : Even n)
Goal: DihedralGroup.reciprocalFactors n = 3 :: DihedralGroup.reciprocalFactors (n / 2)
-- DihedralGroup.reciprocalFactors_odd
lemma reciprocalFactors_odd {n : ℕ} (h1 : n ≠ 1) (h2 : Odd n) :
    reciprocalFactors n = n % 4 * n :: reciprocalFactors (n / 4 + 1) 
Arguments: {n : ℕ} (h1 : n ≠ 1) (h2 : Odd n)
Goal: DihedralGroup.reciprocalFactors n = n % 4 * n :: DihedralGroup.reciprocalFactors (n / 4 + 1)
-- DihedralGroup.commProb_nil
lemma commProb_nil : commProb (Product []) = 1 
Goal: commProb (DihedralGroup.Product []) = 1
-- DihedralGroup.commProb_cons
lemma commProb_cons (n : ℕ) (l : List ℕ) :
    commProb (Product (n :: l)) = commProb (DihedralGroup n) * commProb (Product l) 
Arguments: (n : ℕ) (l : List ℕ)
Goal: commProb (DihedralGroup.Product (n :: l)) = commProb (DihedralGroup n) * commProb (DihedralGroup.Product l)
-- DihedralGroup.commProb_reciprocal
theorem commProb_reciprocal (n : ℕ) :
    commProb (Product (reciprocalFactors n)) = 1 / n 
Arguments: (n : ℕ)
Goal: commProb (DihedralGroup.Product (DihedralGroup.reciprocalFactors n)) = 1 / ↑n
-- PresentedGroup.closure_range_of
@[simp]
theorem closure_range_of (rels : Set (FreeGroup α)) :
    Subgroup.closure (Set.range (PresentedGroup.of : α → PresentedGroup rels)) = ⊤ 
Arguments: {α : Type u_1} (rels : Set (FreeGroup α))
Goal: Subgroup.closure (Set.range PresentedGroup.of) = ⊤
-- PresentedGroup.closure_rels_subset_ker
theorem closure_rels_subset_ker : Subgroup.normalClosure rels ≤ MonoidHom.ker F 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] {f : α → G} {rels : Set (FreeGroup α)} (h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1)
Goal: Subgroup.normalClosure rels ≤ (FreeGroup.lift f).ker
-- PresentedGroup.to_group_eq_one_of_mem_closure
theorem to_group_eq_one_of_mem_closure : ∀ x ∈ Subgroup.normalClosure rels, F x = 1 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] {f : α → G} {rels : Set (FreeGroup α)} (h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1) (x : FreeGroup α)
Goal: x ∈ Subgroup.normalClosure rels → (FreeGroup.lift f) x = 1
-- PresentedGroup.toGroup.of
@[simp]
theorem toGroup.of {x : α} : toGroup h (of x) = f x 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] {f : α → G} {rels : Set (FreeGroup α)} (h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1) {x : α}
Goal: (PresentedGroup.toGroup h) (PresentedGroup.of x) = f x
-- PresentedGroup.toGroup.unique
theorem toGroup.unique (g : PresentedGroup rels →* G)
    (hg : ∀ x : α, g (PresentedGroup.of x) = f x) : ∀ {x}, g x = toGroup h x 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] {f : α → G} {rels : Set (FreeGroup α)} (h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1) (g : PresentedGroup rels →* G) (hg : ∀ (x : α), g (PresentedGroup.of x) = f x) {x : PresentedGroup rels}
Goal: g x = (PresentedGroup.toGroup h) x
-- PresentedGroup.ext
@[ext]
theorem ext {φ ψ : PresentedGroup rels →* G} (hx : ∀ (x : α), φ (.of x) = ψ (.of x)) : φ = ψ 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] {rels : Set (FreeGroup α)} {φ ψ : PresentedGroup rels →* G} (hx : ∀ (x : α), φ (PresentedGroup.of x) = ψ (PresentedGroup.of x))
Goal: φ = ψ
-- PresentedGroup.equivPresentedGroup_apply_of
theorem equivPresentedGroup_apply_of (x : α) (rels : Set (FreeGroup α)) (e : α ≃ β) :
    equivPresentedGroup rels e (PresentedGroup.of x) =
      PresentedGroup.of (rels := FreeGroup.freeGroupCongr e '' rels) (e x) 
Arguments: {α : Type u_1} {β : Type u_3} (x : α) (rels : Set (FreeGroup α)) (e : α ≃ β)
Goal: (PresentedGroup.equivPresentedGroup rels e) (PresentedGroup.of x) = PresentedGroup.of (e x)
-- PresentedGroup.equivPresentedGroup_symm_apply_of
theorem equivPresentedGroup_symm_apply_of (x : β) (rels : Set (FreeGroup α)) (e : α ≃ β) :
    (equivPresentedGroup rels e).symm (PresentedGroup.of x) =
      PresentedGroup.of (rels := rels) (e.symm x) 
Arguments: {α : Type u_1} {β : Type u_3} (x : β) (rels : Set (FreeGroup α)) (e : α ≃ β)
Goal: (PresentedGroup.equivPresentedGroup rels e).symm (PresentedGroup.of x) = PresentedGroup.of (e.symm x)
-- AddSubmonoid.fg_iff
@[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 
Arguments: {M : Type u_1} [AddMonoid M] (P : AddSubmonoid M)
Goal: P.FG ↔ ∃ S, AddSubmonoid.closure S = P ∧ S.Finite
-- Submonoid.fg_iff
@[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 
Arguments: {M : Type u_1} [Monoid M] (P : Submonoid M)
Goal: P.FG ↔ ∃ S, Submonoid.closure S = P ∧ S.Finite
-- Submonoid.fg_iff_add_fg
theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG 
Arguments: {M : Type u_1} [Monoid M] (P : Submonoid M)
Goal: P.FG ↔ (Submonoid.toAddSubmonoid P).FG
-- AddSubmonoid.fg_iff_mul_fg
theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.FG ↔ P.toSubmonoid.FG 
Arguments: {N : Type u_2} [AddMonoid N] (P : AddSubmonoid N)
Goal: P.FG ↔ (AddSubmonoid.toSubmonoid P).FG
-- Monoid.FG.out
class Monoid.FG : Prop where
  out : (⊤ : Submonoid M).FG
Arguments: {M : Type u_1} [Monoid M] [self : Monoid.FG M]
Goal: ⊤.FG
-- AddMonoid.FG.out
class AddMonoid.FG : Prop where
  out : (⊤ : AddSubmonoid N).FG
Arguments: {N : Type u_2} [AddMonoid N] [self : AddMonoid.FG N]
Goal: ⊤.FG
-- Monoid.fg_def
theorem Monoid.fg_def : Monoid.FG M ↔ (⊤ : Submonoid M).FG 
Arguments: {M : Type u_1} [Monoid M]
Goal: Monoid.FG M ↔ ⊤.FG
-- AddMonoid.fg_def
theorem AddMonoid.fg_def : AddMonoid.FG N ↔ (⊤ : AddSubmonoid N).FG 
Arguments: {N : Type u_2} [AddMonoid N]
Goal: AddMonoid.FG N ↔ ⊤.FG
-- Monoid.fg_iff
@[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 
Arguments: {M : Type u_1} [Monoid M]
Goal: Monoid.FG M ↔ ∃ S, Submonoid.closure S = ⊤ ∧ S.Finite
-- AddMonoid.fg_iff
@[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 
Arguments: {M : Type u_1} [AddMonoid M]
Goal: AddMonoid.FG M ↔ ∃ S, AddSubmonoid.closure S = ⊤ ∧ S.Finite
-- Monoid.fg_iff_add_fg
theorem Monoid.fg_iff_add_fg : Monoid.FG M ↔ AddMonoid.FG (Additive M) 
Arguments: {M : Type u_1} [Monoid M]
Goal: Monoid.FG M ↔ AddMonoid.FG (Additive M)
-- AddMonoid.fg_iff_mul_fg
theorem AddMonoid.fg_iff_mul_fg : AddMonoid.FG N ↔ Monoid.FG (Multiplicative N) 
Arguments: {N : Type u_2} [AddMonoid N]
Goal: AddMonoid.FG N ↔ Monoid.FG (Multiplicative N)
-- Submonoid.FG.map
@[to_additive]
theorem Submonoid.FG.map {M' : Type*} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M') :
    (P.map e).FG 
Arguments: {M : Type u_1} [Monoid M] {M' : Type u_3} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M')
Goal: (Submonoid.map e P).FG
-- AddSubmonoid.FG.map
@[to_additive]
theorem Submonoid.FG.map {M' : Type*} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M') :
    (P.map e).FG 
Arguments: {M : Type u_1} [AddMonoid M] {M' : Type u_3} [AddMonoid M'] {P : AddSubmonoid M} (h : P.FG) (e : M →+ M')
Goal: (AddSubmonoid.map e P).FG
-- Submonoid.FG.map_injective
@[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 
Arguments: {M : Type u_1} [Monoid M] {M' : Type u_3} [Monoid M'] {P : Submonoid M} (e : M →* M') (he : Function.Injective ⇑e) (h : (Submonoid.map e P).FG)
Goal: P.FG
-- AddSubmonoid.FG.map_injective
@[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 
Arguments: {M : Type u_1} [AddMonoid M] {M' : Type u_3} [AddMonoid M'] {P : AddSubmonoid M} (e : M →+ M') (he : Function.Injective ⇑e) (h : (AddSubmonoid.map e P).FG)
Goal: P.FG
-- AddMonoid.fg_iff_addSubmonoid_fg
@[to_additive (attr := simp)]
theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG 
Arguments: {M : Type u_1} [AddMonoid M] (N : AddSubmonoid M)
Goal: AddMonoid.FG ↥N ↔ N.FG
-- Monoid.fg_iff_submonoid_fg
@[to_additive (attr := simp)]
theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG 
Arguments: {M : Type u_1} [Monoid M] (N : Submonoid M)
Goal: Monoid.FG ↥N ↔ N.FG
-- Monoid.fg_of_surjective
@[to_additive]
theorem Monoid.fg_of_surjective {M' : Type*} [Monoid M'] [Monoid.FG M] (f : M →* M')
    (hf : Function.Surjective f) : Monoid.FG M' 
Arguments: {M : Type u_1} [Monoid M] {M' : Type u_3} [Monoid M'] [Monoid.FG M] (f : M →* M') (hf : Function.Surjective ⇑f)
Goal: Monoid.FG M'
-- AddMonoid.fg_of_surjective
@[to_additive]
theorem Monoid.fg_of_surjective {M' : Type*} [Monoid M'] [Monoid.FG M] (f : M →* M')
    (hf : Function.Surjective f) : Monoid.FG M' 
Arguments: {M : Type u_1} [AddMonoid M] {M' : Type u_3} [AddMonoid M'] [AddMonoid.FG M] (f : M →+ M') (hf : Function.Surjective ⇑f)
Goal: AddMonoid.FG M'
-- AddSubmonoid.multiples_fg
@[to_additive]
theorem Submonoid.powers_fg (r : M) : (Submonoid.powers r).FG 
Arguments: {M : Type u_1} [AddMonoid M] (r : M)
Goal: (AddSubmonoid.multiples r).FG
-- Submonoid.powers_fg
@[to_additive]
theorem Submonoid.powers_fg (r : M) : (Submonoid.powers r).FG 
Arguments: {M : Type u_1} [Monoid M] (r : M)
Goal: (Submonoid.powers r).FG
-- Subgroup.fg_iff
@[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 
Arguments: {G : Type u_3} [Group G] (P : Subgroup G)
Goal: P.FG ↔ ∃ S, Subgroup.closure S = P ∧ S.Finite
-- AddSubgroup.fg_iff
@[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 
Arguments: {G : Type u_3} [AddGroup G] (P : AddSubgroup G)
Goal: P.FG ↔ ∃ S, AddSubgroup.closure S = P ∧ S.Finite
-- AddSubgroup.fg_iff_addSubmonoid_fg
@[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 
Arguments: {G : Type u_3} [AddGroup G] (P : AddSubgroup G)
Goal: P.FG ↔ P.FG
-- Subgroup.fg_iff_submonoid_fg
@[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 
Arguments: {G : Type u_3} [Group G] (P : Subgroup G)
Goal: P.FG ↔ P.FG
-- Subgroup.fg_iff_add_fg
theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.FG ↔ P.toAddSubgroup.FG 
Arguments: {G : Type u_3} [Group G] (P : Subgroup G)
Goal: P.FG ↔ (Subgroup.toAddSubgroup P).FG
-- AddSubgroup.fg_iff_mul_fg
theorem AddSubgroup.fg_iff_mul_fg (P : AddSubgroup H) : P.FG ↔ P.toSubgroup.FG 
Arguments: {H : Type u_4} [AddGroup H] (P : AddSubgroup H)
Goal: P.FG ↔ (AddSubgroup.toSubgroup P).FG
-- Group.FG.out
class Group.FG : Prop where
  out : (⊤ : Subgroup G).FG
Arguments: {G : Type u_3} [Group G] [self : Group.FG G]
Goal: ⊤.FG
-- AddGroup.FG.out
class AddGroup.FG : Prop where
  out : (⊤ : AddSubgroup H).FG
Arguments: {H : Type u_4} [AddGroup H] [self : AddGroup.FG H]
Goal: ⊤.FG
-- Group.fg_def
theorem Group.fg_def : Group.FG G ↔ (⊤ : Subgroup G).FG 
Arguments: {G : Type u_3} [Group G]
Goal: Group.FG G ↔ ⊤.FG
-- AddGroup.fg_def
theorem AddGroup.fg_def : AddGroup.FG H ↔ (⊤ : AddSubgroup H).FG 
Arguments: {H : Type u_4} [AddGroup H]
Goal: AddGroup.FG H ↔ ⊤.FG
-- Group.fg_iff
@[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 
Arguments: {G : Type u_3} [Group G]
Goal: Group.FG G ↔ ∃ S, Subgroup.closure S = ⊤ ∧ S.Finite
-- AddGroup.fg_iff
@[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 
Arguments: {G : Type u_3} [AddGroup G]
Goal: AddGroup.FG G ↔ ∃ S, AddSubgroup.closure S = ⊤ ∧ S.Finite
-- Group.fg_iff'
@[to_additive]
theorem Group.fg_iff' :
    Group.FG G ↔ ∃ (n : _) (S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ 
Arguments: {G : Type u_3} [Group G]
Goal: Group.FG G ↔ ∃ n S, S.card = n ∧ Subgroup.closure ↑S = ⊤
-- AddGroup.fg_iff'
@[to_additive]
theorem Group.fg_iff' :
    Group.FG G ↔ ∃ (n : _) (S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ 
Arguments: {G : Type u_3} [AddGroup G]
Goal: AddGroup.FG G ↔ ∃ n S, S.card = n ∧ AddSubgroup.closure ↑S = ⊤
-- AddGroup.fg_iff_addMonoid_fg
@[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 
Arguments: {G : Type u_3} [AddGroup G]
Goal: AddGroup.FG G ↔ AddMonoid.FG G
-- Group.fg_iff_monoid_fg
@[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 
Arguments: {G : Type u_3} [Group G]
Goal: Group.FG G ↔ Monoid.FG G
-- AddGroup.fg_iff_addSubgroup_fg
@[to_additive (attr := simp)]
theorem Group.fg_iff_subgroup_fg (H : Subgroup G) : Group.FG H ↔ H.FG 
Arguments: {G : Type u_3} [AddGroup G] (H : AddSubgroup G)
Goal: AddGroup.FG ↥H ↔ H.FG
-- Group.fg_iff_subgroup_fg
@[to_additive (attr := simp)]
theorem Group.fg_iff_subgroup_fg (H : Subgroup G) : Group.FG H ↔ H.FG 
Arguments: {G : Type u_3} [Group G] (H : Subgroup G)
Goal: Group.FG ↥H ↔ H.FG
-- GroupFG.iff_add_fg
theorem GroupFG.iff_add_fg : Group.FG G ↔ AddGroup.FG (Additive G) 
Arguments: {G : Type u_3} [Group G]
Goal: Group.FG G ↔ AddGroup.FG (Additive G)
-- AddGroup.fg_iff_mul_fg
theorem AddGroup.fg_iff_mul_fg : AddGroup.FG H ↔ Group.FG (Multiplicative H) 
Arguments: {H : Type u_4} [AddGroup H]
Goal: AddGroup.FG H ↔ Group.FG (Multiplicative H)
-- AddGroup.fg_of_surjective
@[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' 
Arguments: {G : Type u_3} [AddGroup G] {G' : Type u_5} [AddGroup G'] [hG : AddGroup.FG G] {f : G →+ G'} (hf : Function.Surjective ⇑f)
Goal: AddGroup.FG G'
-- Group.fg_of_surjective
@[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' 
Arguments: {G : Type u_3} [Group G] {G' : Type u_5} [Group G'] [hG : Group.FG G] {f : G →* G'} (hf : Function.Surjective ⇑f)
Goal: Group.FG G'
-- Group.rank_spec
@[to_additive]
theorem Group.rank_spec [h : Group.FG G] :
    ∃ S : Finset G, S.card = Group.rank G ∧ Subgroup.closure (S : Set G) = ⊤ 
Arguments: (G : Type u_3) [Group G] [h : Group.FG G]
Goal: ∃ S, S.card = Group.rank G ∧ Subgroup.closure ↑S = ⊤
-- AddGroup.rank_spec
@[to_additive]
theorem Group.rank_spec [h : Group.FG G] :
    ∃ S : Finset G, S.card = Group.rank G ∧ Subgroup.closure (S : Set G) = ⊤ 
Arguments: (G : Type u_3) [AddGroup G] [h : AddGroup.FG G]
Goal: ∃ S, S.card = AddGroup.rank G ∧ AddSubgroup.closure ↑S = ⊤
-- Group.rank_le
@[to_additive]
theorem Group.rank_le [h : Group.FG G] {S : Finset G} (hS : Subgroup.closure (S : Set G) = ⊤) :
    Group.rank G ≤ S.card 
Arguments: (G : Type u_3) [Group G] [h : Group.FG G] {S : Finset G} (hS : Subgroup.closure ↑S = ⊤)
Goal: Group.rank G ≤ S.card
-- AddGroup.rank_le
@[to_additive]
theorem Group.rank_le [h : Group.FG G] {S : Finset G} (hS : Subgroup.closure (S : Set G) = ⊤) :
    Group.rank G ≤ S.card 
Arguments: (G : Type u_3) [AddGroup G] [h : AddGroup.FG G] {S : Finset G} (hS : AddSubgroup.closure ↑S = ⊤)
Goal: AddGroup.rank G ≤ S.card
-- Group.rank_le_of_surjective
@[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 
Arguments: {G : Type u_3} [Group G] {G' : Type u_5} [Group G'] [Group.FG G] [Group.FG G'] (f : G →* G') (hf : Function.Surjective ⇑f)
Goal: Group.rank G' ≤ Group.rank G
-- AddGroup.rank_le_of_surjective
@[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 
Arguments: {G : Type u_3} [AddGroup G] {G' : Type u_5} [AddGroup G'] [AddGroup.FG G] [AddGroup.FG G'] (f : G →+ G') (hf : Function.Surjective ⇑f)
Goal: AddGroup.rank G' ≤ AddGroup.rank G
-- Group.rank_range_le
@[to_additive]
theorem Group.rank_range_le [Group.FG G] {f : G →* G'} : Group.rank f.range ≤ Group.rank G 
Arguments: {G : Type u_3} [Group G] {G' : Type u_5} [Group G'] [Group.FG G] {f : G →* G'}
Goal: Group.rank ↥f.range ≤ Group.rank G
-- AddGroup.rank_range_le
@[to_additive]
theorem Group.rank_range_le [Group.FG G] {f : G →* G'} : Group.rank f.range ≤ Group.rank G 
Arguments: {G : Type u_3} [AddGroup G] {G' : Type u_5} [AddGroup G'] [AddGroup.FG G] {f : G →+ G'}
Goal: AddGroup.rank ↥f.range ≤ AddGroup.rank G