ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- IsTorsion.not_torsion_free
@[to_additive AddMonoid.IsTorsion.not_torsion_free
      "A nontrivial additive torsion group is not torsion-free."]
theorem IsTorsion.not_torsion_free [hN : Nontrivial G] : IsTorsion G → ¬IsTorsionFree G 
Arguments: {G : Type u_1} [Group G] [hN : Nontrivial G]
Goal: Monoid.IsTorsion G → ¬Monoid.IsTorsionFree G
-- AddMonoid.IsTorsion.not_torsion_free
@[to_additive AddMonoid.IsTorsion.not_torsion_free
      "A nontrivial additive torsion group is not torsion-free."]
theorem IsTorsion.not_torsion_free [hN : Nontrivial G] : IsTorsion G → ¬IsTorsionFree G 
Arguments: {G : Type u_1} [AddGroup G] [hN : Nontrivial G]
Goal: AddMonoid.IsTorsion G → ¬AddMonoid.IsTorsionFree G
-- AddMonoid.IsTorsionFree.not_torsion
@[to_additive AddMonoid.IsTorsionFree.not_torsion
      "A nontrivial torsion-free additive group is not torsion."]
theorem IsTorsionFree.not_torsion [hN : Nontrivial G] : IsTorsionFree G → ¬IsTorsion G 
Arguments: {G : Type u_1} [AddGroup G] [hN : Nontrivial G]
Goal: AddMonoid.IsTorsionFree G → ¬AddMonoid.IsTorsion G
-- IsTorsionFree.not_torsion
@[to_additive AddMonoid.IsTorsionFree.not_torsion
      "A nontrivial torsion-free additive group is not torsion."]
theorem IsTorsionFree.not_torsion [hN : Nontrivial G] : IsTorsionFree G → ¬IsTorsion G 
Arguments: {G : Type u_1} [Group G] [hN : Nontrivial G]
Goal: Monoid.IsTorsionFree G → ¬Monoid.IsTorsion G
-- IsTorsionFree.subgroup
@[to_additive "Subgroups of additive torsion-free groups are additively torsion-free."]
theorem IsTorsionFree.subgroup (tG : IsTorsionFree G) (H : Subgroup G) : IsTorsionFree H 
Arguments: {G : Type u_1} [Group G] (tG : Monoid.IsTorsionFree G) (H : Subgroup G)
Goal: Monoid.IsTorsionFree ↥H
-- IsTorsionFree.addSubgroup
@[to_additive "Subgroups of additive torsion-free groups are additively torsion-free."]
theorem IsTorsionFree.subgroup (tG : IsTorsionFree G) (H : Subgroup G) : IsTorsionFree H 
Arguments: {G : Type u_1} [AddGroup G] (tG : AddMonoid.IsTorsionFree G) (H : AddSubgroup G)
Goal: AddMonoid.IsTorsionFree ↥H
-- IsTorsionFree.prod
@[to_additive AddMonoid.IsTorsionFree.prod
      "Direct products of additive torsion free groups are torsion free."]
theorem IsTorsionFree.prod {η : Type*} {Gs : η → Type*} [∀ i, Group (Gs i)]
    (tfGs : ∀ i, IsTorsionFree (Gs i)) : IsTorsionFree <| ∀ i, Gs i 
Arguments: {η : Type u_3} {Gs : η → Type u_4} [(i : η) → Group (Gs i)] (tfGs : ∀ (i : η), Monoid.IsTorsionFree (Gs i))
Goal: Monoid.IsTorsionFree ((i : η) → Gs i)
-- AddMonoid.IsTorsionFree.prod
@[to_additive AddMonoid.IsTorsionFree.prod
      "Direct products of additive torsion free groups are torsion free."]
theorem IsTorsionFree.prod {η : Type*} {Gs : η → Type*} [∀ i, Group (Gs i)]
    (tfGs : ∀ i, IsTorsionFree (Gs i)) : IsTorsionFree <| ∀ i, Gs i 
Arguments: {η : Type u_3} {Gs : η → Type u_4} [(i : η) → AddGroup (Gs i)] (tfGs : ∀ (i : η), AddMonoid.IsTorsionFree (Gs i))
Goal: AddMonoid.IsTorsionFree ((i : η) → Gs i)
-- AddIsTorsionFree.quotient_torsion
@[to_additive AddIsTorsionFree.quotient_torsion
      "Quotienting a group by its additive torsion subgroup yields an additive torsion free group."]
theorem IsTorsionFree.quotient_torsion : IsTorsionFree <| G ⧸ torsion G 
Arguments: (G : Type u_1) [AddCommGroup G]
Goal: AddMonoid.IsTorsionFree (G ⧸ AddCommGroup.torsion G)
-- IsTorsionFree.quotient_torsion
@[to_additive AddIsTorsionFree.quotient_torsion
      "Quotienting a group by its additive torsion subgroup yields an additive torsion free group."]
theorem IsTorsionFree.quotient_torsion : IsTorsionFree <| G ⧸ torsion G 
Arguments: (G : Type u_1) [CommGroup G]
Goal: Monoid.IsTorsionFree (G ⧸ CommGroup.torsion G)
-- isTorsionFree_iff_noZeroSMulDivisors_nat
lemma isTorsionFree_iff_noZeroSMulDivisors_nat {M : Type*} [AddMonoid M] :
    AddMonoid.IsTorsionFree M ↔ NoZeroSMulDivisors ℕ M 
Arguments: {M : Type u_3} [AddMonoid M]
Goal: AddMonoid.IsTorsionFree M ↔ NoZeroSMulDivisors ℕ M
-- isTorsionFree_iff_noZeroSMulDivisors_int
lemma isTorsionFree_iff_noZeroSMulDivisors_int [AddGroup G] :
    AddMonoid.IsTorsionFree G ↔ NoZeroSMulDivisors ℤ G 
Arguments: {G : Type u_1} [AddGroup G]
Goal: AddMonoid.IsTorsionFree G ↔ NoZeroSMulDivisors ℤ G
-- IsTorsionFree.of_noZeroSMulDivisors
lemma IsTorsionFree.of_noZeroSMulDivisors {M : Type*} [AddMonoid M] [NoZeroSMulDivisors ℕ M] :
    AddMonoid.IsTorsionFree M 
Arguments: {M : Type u_3} [AddMonoid M] [NoZeroSMulDivisors ℕ M]
Goal: AddMonoid.IsTorsionFree M
-- sum_conjClasses_card_eq_card
theorem sum_conjClasses_card_eq_card [Fintype <| ConjClasses G] [Fintype G]
    [∀ x : ConjClasses G, Fintype x.carrier] :
    ∑ x : ConjClasses G, x.carrier.toFinset.card = Fintype.card G 
Arguments: (G : Type u_1) [Group G] [Fintype (ConjClasses G)] [Fintype G] [(x : ConjClasses G) → Fintype ↑x.carrier]
Goal: ∑ x : ConjClasses G, x.carrier.toFinset.card = Fintype.card G
-- Group.sum_card_conj_classes_eq_card
theorem Group.sum_card_conj_classes_eq_card [Finite G] :
    ∑ᶠ x : ConjClasses G, x.carrier.ncard = Nat.card G 
Arguments: (G : Type u_1) [Group G] [Finite G]
Goal: ∑ᶠ (x : ConjClasses G), x.carrier.ncard = Nat.card G
-- Group.nat_card_center_add_sum_card_noncenter_eq_card
theorem Group.nat_card_center_add_sum_card_noncenter_eq_card [Finite G] :
    Nat.card (Subgroup.center G) + ∑ᶠ x ∈ noncenter G, Nat.card x.carrier = Nat.card G 
Arguments: (G : Type u_1) [Group G] [Finite G]
Goal: Nat.card ↥(Subgroup.center G) + ∑ᶠ (x : ConjClasses G) (_ : x ∈ ConjClasses.noncenter G), Nat.card ↑x.carrier =
  Nat.card G
-- Group.card_center_add_sum_card_noncenter_eq_card
theorem Group.card_center_add_sum_card_noncenter_eq_card (G) [Group G]
    [∀ x : ConjClasses G, Fintype x.carrier] [Fintype G] [Fintype <| Subgroup.center G]
    [Fintype <| noncenter G] : Fintype.card (Subgroup.center G) +
  ∑ x ∈ (noncenter G).toFinset, x.carrier.toFinset.card = Fintype.card G 
Arguments: (G : Type u_2) [Group G] [(x : ConjClasses G) → Fintype ↑x.carrier] [Fintype G] [Fintype ↥(Subgroup.center G)] [Fintype ↑(ConjClasses.noncenter G)]
Goal: Fintype.card ↥(Subgroup.center G) + ∑ x ∈ (ConjClasses.noncenter G).toFinset, x.carrier.toFinset.card = Fintype.card G
-- Con.list_prod
@[to_additive "Additive congruence relations preserve sum indexed by a list."]
protected theorem list_prod {ι M : Type*} [Monoid M] (c : Con M) {l : List ι} {f g : ι → M}
    (h : ∀ x ∈ l, c (f x) (g x)) :
    c (l.map f).prod (l.map g).prod 
Arguments: {ι : Type u_1} {M : Type u_2} [Monoid M] (c : Con M) {l : List ι} {f g : ι → M} (h : ∀ x ∈ l, c (f x) (g x))
Goal: c (List.map f l).prod (List.map g l).prod
-- AddCon.list_sum
@[to_additive "Additive congruence relations preserve sum indexed by a list."]
protected theorem list_prod {ι M : Type*} [Monoid M] (c : Con M) {l : List ι} {f g : ι → M}
    (h : ∀ x ∈ l, c (f x) (g x)) :
    c (l.map f).prod (l.map g).prod 
Arguments: {ι : Type u_1} {M : Type u_2} [AddMonoid M] (c : AddCon M) {l : List ι} {f g : ι → M} (h : ∀ x ∈ l, c (f x) (g x))
Goal: c (List.map f l).sum (List.map g l).sum
-- AddCon.multiset_sum
@[to_additive "Additive congruence relations preserve sum indexed by a multiset."]
protected theorem multiset_prod {ι M : Type*} [CommMonoid M] (c : Con M) {s : Multiset ι}
    {f g : ι → M} (h : ∀ x ∈ s, c (f x) (g x)) :
    c (s.map f).prod (s.map g).prod 
Arguments: {ι : Type u_1} {M : Type u_2} [AddCommMonoid M] (c : AddCon M) {s : Multiset ι} {f g : ι → M} (h : ∀ x ∈ s, c (f x) (g x))
Goal: c (Multiset.map f s).sum (Multiset.map g s).sum
-- Con.multiset_prod
@[to_additive "Additive congruence relations preserve sum indexed by a multiset."]
protected theorem multiset_prod {ι M : Type*} [CommMonoid M] (c : Con M) {s : Multiset ι}
    {f g : ι → M} (h : ∀ x ∈ s, c (f x) (g x)) :
    c (s.map f).prod (s.map g).prod 
Arguments: {ι : Type u_1} {M : Type u_2} [CommMonoid M] (c : Con M) {s : Multiset ι} {f g : ι → M} (h : ∀ x ∈ s, c (f x) (g x))
Goal: c (Multiset.map f s).prod (Multiset.map g s).prod
-- Con.finset_prod
@[to_additive "Additive congruence relations preserve finite sum."]
protected theorem finset_prod {ι M : Type*} [CommMonoid M] (c : Con M) (s : Finset ι)
    {f g : ι → M} (h : ∀ i ∈ s, c (f i) (g i)) :
    c (s.prod f) (s.prod g) 
Arguments: {ι : Type u_1} {M : Type u_2} [CommMonoid M] (c : Con M) (s : Finset ι) {f g : ι → M} (h : ∀ i ∈ s, c (f i) (g i))
Goal: c (s.prod f) (s.prod g)
-- AddCon.finset_sum
@[to_additive "Additive congruence relations preserve finite sum."]
protected theorem finset_prod {ι M : Type*} [CommMonoid M] (c : Con M) (s : Finset ι)
    {f g : ι → M} (h : ∀ i ∈ s, c (f i) (g i)) :
    c (s.prod f) (s.prod g) 
Arguments: {ι : Type u_1} {M : Type u_2} [AddCommMonoid M] (c : AddCon M) (s : Finset ι) {f g : ι → M} (h : ∀ i ∈ s, c (f i) (g i))
Goal: c (s.sum f) (s.sum g)
-- Finsupp.toFreeAbelianGroup_comp_singleAddHom
@[simp]
theorem Finsupp.toFreeAbelianGroup_comp_singleAddHom (x : X) :
    Finsupp.toFreeAbelianGroup.comp (Finsupp.singleAddHom x) =
      (smulAddHom ℤ (FreeAbelianGroup X)).flip (of x) 
Arguments: {X : Type u_1} (x : X)
Goal: Finsupp.toFreeAbelianGroup.comp (Finsupp.singleAddHom x) =
  (smulAddHom ℤ (FreeAbelianGroup X)).flip (FreeAbelianGroup.of x)
-- FreeAbelianGroup.toFinsupp_comp_toFreeAbelianGroup
@[simp]
theorem FreeAbelianGroup.toFinsupp_comp_toFreeAbelianGroup :
    toFinsupp.comp toFreeAbelianGroup = AddMonoidHom.id (X →₀ ℤ) 
Arguments: {X : Type u_1}
Goal: FreeAbelianGroup.toFinsupp.comp Finsupp.toFreeAbelianGroup = AddMonoidHom.id (X →₀ ℤ)
-- Finsupp.toFreeAbelianGroup_comp_toFinsupp
@[simp]
theorem Finsupp.toFreeAbelianGroup_comp_toFinsupp :
    toFreeAbelianGroup.comp toFinsupp = AddMonoidHom.id (FreeAbelianGroup X) 
Arguments: {X : Type u_1}
Goal: Finsupp.toFreeAbelianGroup.comp FreeAbelianGroup.toFinsupp = AddMonoidHom.id (FreeAbelianGroup X)
-- Finsupp.toFreeAbelianGroup_toFinsupp
@[simp]
theorem Finsupp.toFreeAbelianGroup_toFinsupp {X} (x : FreeAbelianGroup X) :
    Finsupp.toFreeAbelianGroup (FreeAbelianGroup.toFinsupp x) = x 
Arguments: {X : Type u_2} (x : FreeAbelianGroup X)
Goal: Finsupp.toFreeAbelianGroup (FreeAbelianGroup.toFinsupp x) = x
-- FreeAbelianGroup.toFinsupp_of
@[simp]
theorem toFinsupp_of (x : X) : toFinsupp (of x) = Finsupp.single x 1 
Arguments: {X : Type u_1} (x : X)
Goal: FreeAbelianGroup.toFinsupp (FreeAbelianGroup.of x) = Finsupp.single x 1
-- FreeAbelianGroup.toFinsupp_toFreeAbelianGroup
@[simp]
theorem toFinsupp_toFreeAbelianGroup (f : X →₀ ℤ) :
    FreeAbelianGroup.toFinsupp (Finsupp.toFreeAbelianGroup f) = f 
Arguments: {X : Type u_1} (f : X →₀ ℤ)
Goal: FreeAbelianGroup.toFinsupp (Finsupp.toFreeAbelianGroup f) = f
-- FreeAbelianGroup.equivFinsupp_symm_apply
@[simps!]
def equivFinsupp : FreeAbelianGroup X ≃+ (X →₀ ℤ) 
Arguments: (X : Type u_1) (a : X →₀ ℤ)
Goal: (FreeAbelianGroup.equivFinsupp X).symm a = Finsupp.toFreeAbelianGroup a
-- FreeAbelianGroup.equivFinsupp_apply
@[simps!]
def equivFinsupp : FreeAbelianGroup X ≃+ (X →₀ ℤ) 
Arguments: (X : Type u_1) (a : FreeAbelianGroup X)
Goal: (FreeAbelianGroup.equivFinsupp X) a = FreeAbelianGroup.toFinsupp a
-- FreeAbelianGroup.mem_support_iff
theorem mem_support_iff (x : X) (a : FreeAbelianGroup X) : x ∈ a.support ↔ coeff x a ≠ 0 
Arguments: {X : Type u_1} (x : X) (a : FreeAbelianGroup X)
Goal: x ∈ a.support ↔ (FreeAbelianGroup.coeff x) a ≠ 0
-- FreeAbelianGroup.not_mem_support_iff
theorem not_mem_support_iff (x : X) (a : FreeAbelianGroup X) : x ∉ a.support ↔ coeff x a = 0 
Arguments: {X : Type u_1} (x : X) (a : FreeAbelianGroup X)
Goal: x ∉ a.support ↔ (FreeAbelianGroup.coeff x) a = 0
-- FreeAbelianGroup.support_zero
@[simp]
theorem support_zero : support (0 : FreeAbelianGroup X) = ∅ 
Arguments: {X : Type u_1}
Goal: FreeAbelianGroup.support 0 = ∅
-- FreeAbelianGroup.support_of
@[simp]
theorem support_of (x : X) : support (of x) = {x} 
Arguments: {X : Type u_1} (x : X)
Goal: (FreeAbelianGroup.of x).support = {x}
-- FreeAbelianGroup.support_neg
@[simp]
theorem support_neg (a : FreeAbelianGroup X) : support (-a) = support a 
Arguments: {X : Type u_1} (a : FreeAbelianGroup X)
Goal: (-a).support = a.support
-- FreeAbelianGroup.support_zsmul
@[simp]
theorem support_zsmul (k : ℤ) (h : k ≠ 0) (a : FreeAbelianGroup X) :
    support (k • a) = support a 
Arguments: {X : Type u_1} (k : ℤ) (h : k ≠ 0) (a : FreeAbelianGroup X)
Goal: (k • a).support = a.support
-- FreeAbelianGroup.support_nsmul
@[simp]
theorem support_nsmul (k : ℕ) (h : k ≠ 0) (a : FreeAbelianGroup X) :
    support (k • a) = support a 
Arguments: {X : Type u_1} (k : ℕ) (h : k ≠ 0) (a : FreeAbelianGroup X)
Goal: (k • a).support = a.support
-- FreeAbelianGroup.support_add
theorem support_add (a b : FreeAbelianGroup X) : support (a + b) ⊆ a.support ∪ b.support 
Arguments: {X : Type u_1} (a b : FreeAbelianGroup X)
Goal: (a + b).support ⊆ a.support ∪ b.support
-- Localization.mk_le_mk
@[to_additive]
theorem mk_le_mk : mk a₁ a₂ ≤ mk b₁ b₂ ↔ ↑b₂ * a₁ ≤ a₂ * b₁ 
Arguments: {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} {a₁ b₁ : α} {a₂ b₂ : ↥s}
Goal: Localization.mk a₁ a₂ ≤ Localization.mk b₁ b₂ ↔ ↑b₂ * a₁ ≤ ↑a₂ * b₁
-- AddLocalization.mk_le_mk
@[to_additive]
theorem mk_le_mk : mk a₁ a₂ ≤ mk b₁ b₂ ↔ ↑b₂ * a₁ ≤ a₂ * b₁ 
Arguments: {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} {a₁ b₁ : α} {a₂ b₂ : ↥s}
Goal: AddLocalization.mk a₁ a₂ ≤ AddLocalization.mk b₁ b₂ ↔ ↑b₂ + a₁ ≤ ↑a₂ + b₁
-- AddLocalization.mk_lt_mk
@[to_additive]
theorem mk_lt_mk : mk a₁ a₂ < mk b₁ b₂ ↔ ↑b₂ * a₁ < a₂ * b₁ 
Arguments: {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} {a₁ b₁ : α} {a₂ b₂ : ↥s}
Goal: AddLocalization.mk a₁ a₂ < AddLocalization.mk b₁ b₂ ↔ ↑b₂ + a₁ < ↑a₂ + b₁
-- Localization.mk_lt_mk
@[to_additive]
theorem mk_lt_mk : mk a₁ a₂ < mk b₁ b₂ ↔ ↑b₂ * a₁ < a₂ * b₁ 
Arguments: {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} {a₁ b₁ : α} {a₂ b₂ : ↥s}
Goal: Localization.mk a₁ a₂ < Localization.mk b₁ b₂ ↔ ↑b₂ * a₁ < ↑a₂ * b₁
-- AddLocalization.mkOrderEmbedding_apply
@[to_additive (attr := simps!) "An ordered cancellative monoid injects into its localization by
sending `a` to `a - b`."]
def mkOrderEmbedding (b : s) : α ↪o Localization s 
Arguments: {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (b : ↥s) (a : α)
Goal: (AddLocalization.mkOrderEmbedding b) a = (AddLocalization.addMonoidOf s).mk' a b
-- Localization.mkOrderEmbedding_apply
@[to_additive (attr := simps!) "An ordered cancellative monoid injects into its localization by
sending `a` to `a - b`."]
def mkOrderEmbedding (b : s) : α ↪o Localization s 
Arguments: {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} (b : ↥s) (a : α)
Goal: (Localization.mkOrderEmbedding b) a = (Localization.monoidOf s).mk' a b
-- IsAddKleinFour.exponent_two
class IsAddKleinFour (G : Type*) [AddGroup G] : Prop where
  card_four : Nat.card G = 4
  exponent_two : AddMonoid.exponent G = 2
Arguments: {G : Type u_1} [AddGroup G] [self : IsAddKleinFour G]
Goal: AddMonoid.exponent G = 2
-- IsAddKleinFour.card_four
class IsAddKleinFour (G : Type*) [AddGroup G] : Prop where
  card_four : Nat.card G = 4
  exponent_two : AddMonoid.exponent G = 2
Arguments: {G : Type u_1} [AddGroup G] [self : IsAddKleinFour G]
Goal: Nat.card G = 4
-- IsKleinFour.exponent_two
@[to_additive existing IsAddKleinFour]
class IsKleinFour (G : Type*) [Group G] : Prop where
  card_four : Nat.card G = 4
  exponent_two : Monoid.exponent G = 2
Arguments: {G : Type u_1} [Group G] [self : IsKleinFour G]
Goal: Monoid.exponent G = 2
-- IsKleinFour.card_four
@[to_additive existing IsAddKleinFour]
class IsKleinFour (G : Type*) [Group G] : Prop where
  card_four : Nat.card G = 4
  exponent_two : Monoid.exponent G = 2
Arguments: {G : Type u_1} [Group G] [self : IsKleinFour G]
Goal: Nat.card G = 4
-- IsAddKleinFour.card_four'
@[to_additive (attr := simp)]
lemma card_four' {G : Type*} [Group G] [Fintype G] [IsKleinFour G] :
    Fintype.card G = 4 
Arguments: {G : Type u_1} [AddGroup G] [Fintype G] [IsAddKleinFour G]
Goal: Fintype.card G = 4
-- IsKleinFour.card_four'
@[to_additive (attr := simp)]
lemma card_four' {G : Type*} [Group G] [Fintype G] [IsKleinFour G] :
    Fintype.card G = 4 
Arguments: {G : Type u_1} [Group G] [Fintype G] [IsKleinFour G]
Goal: Fintype.card G = 4
-- IsAddKleinFour.not_isAddCyclic
@[to_additive]
lemma not_isCyclic : ¬ IsCyclic G 
Arguments: {G : Type u_1} [AddGroup G] [IsAddKleinFour G]
Goal: ¬IsAddCyclic G
-- IsKleinFour.not_isCyclic
@[to_additive]
lemma not_isCyclic : ¬ IsCyclic G 
Arguments: {G : Type u_1} [Group G] [IsKleinFour G]
Goal: ¬IsCyclic G
-- IsAddKleinFour.neg_eq_self
@[to_additive]
lemma inv_eq_self (x : G) : x⁻¹ = x 
Arguments: {G : Type u_1} [AddGroup G] [IsAddKleinFour G] (x : G)
Goal: -x = x
-- IsKleinFour.inv_eq_self
@[to_additive]
lemma inv_eq_self (x : G) : x⁻¹ = x 
Arguments: {G : Type u_1} [Group G] [IsKleinFour G] (x : G)
Goal: x⁻¹ = x
-- IsAddKleinFour.add_self
@[to_additive]
lemma mul_self (x : G) : x * x = 1 
Arguments: {G : Type u_1} [AddGroup G] [IsAddKleinFour G] (x : G)
Goal: x + x = 0
-- IsKleinFour.mul_self
@[to_additive]
lemma mul_self (x : G) : x * x = 1 
Arguments: {G : Type u_1} [Group G] [IsKleinFour G] (x : G)
Goal: x * x = 1
-- IsKleinFour.eq_finset_univ
@[to_additive]
lemma eq_finset_univ [Fintype G] [DecidableEq G]
    {x y : G} (hx : x ≠ 1) (hy : y ≠ 1) (hxy : x ≠ y) : {x * y, x, y, (1 : G)} = Finset.univ 
Arguments: {G : Type u_1} [Group G] [IsKleinFour G] [Fintype G] [DecidableEq G] {x y : G} (hx : x ≠ 1) (hy : y ≠ 1) (hxy : x ≠ y)
Goal: {x * y, x, y, 1} = Finset.univ
-- IsAddKleinFour.eq_finset_univ
@[to_additive]
lemma eq_finset_univ [Fintype G] [DecidableEq G]
    {x y : G} (hx : x ≠ 1) (hy : y ≠ 1) (hxy : x ≠ y) : {x * y, x, y, (1 : G)} = Finset.univ 
Arguments: {G : Type u_1} [AddGroup G] [IsAddKleinFour G] [Fintype G] [DecidableEq G] {x y : G} (hx : x ≠ 0) (hy : y ≠ 0) (hxy : x ≠ y)
Goal: {x + y, x, y, 0} = Finset.univ
-- IsAddKleinFour.eq_add_of_ne_all
@[to_additive]
lemma eq_mul_of_ne_all {x y z : G} (hx : x ≠ 1)
    (hy : y ≠ 1) (hxy : x ≠ y) (hz : z ≠ 1) (hzx : z ≠ x) (hzy : z ≠ y) : z = x * y 
Arguments: {G : Type u_1} [AddGroup G] [IsAddKleinFour G] {x y z : G} (hx : x ≠ 0) (hy : y ≠ 0) (hxy : x ≠ y) (hz : z ≠ 0) (hzx : z ≠ x) (hzy : z ≠ y)
Goal: z = x + y
-- IsKleinFour.eq_mul_of_ne_all
@[to_additive]
lemma eq_mul_of_ne_all {x y z : G} (hx : x ≠ 1)
    (hy : y ≠ 1) (hxy : x ≠ y) (hz : z ≠ 1) (hzx : z ≠ x) (hzy : z ≠ y) : z = x * y 
Arguments: {G : Type u_1} [Group G] [IsKleinFour G] {x y z : G} (hx : x ≠ 1) (hy : y ≠ 1) (hxy : x ≠ y) (hz : z ≠ 1) (hzx : z ≠ x) (hzy : z ≠ y)
Goal: z = x * y
-- IsAddKleinFour.nonempty_addEquiv
@[to_additive "Any two `IsAddKleinFour` groups are isomorphic."]
lemma nonempty_mulEquiv [IsKleinFour G₂] : Nonempty (G₁ ≃* G₂) 
Arguments: {G₁ : Type u_2} {G₂ : Type u_3} [AddGroup G₁] [AddGroup G₂] [IsAddKleinFour G₁] [IsAddKleinFour G₂]
Goal: Nonempty (G₁ ≃+ G₂)
-- IsKleinFour.nonempty_mulEquiv
@[to_additive "Any two `IsAddKleinFour` groups are isomorphic."]
lemma nonempty_mulEquiv [IsKleinFour G₂] : Nonempty (G₁ ≃* G₂) 
Arguments: {G₁ : Type u_2} {G₂ : Type u_3} [Group G₁] [Group G₂] [IsKleinFour G₁] [IsKleinFour G₂]
Goal: Nonempty (G₁ ≃* G₂)
-- Con.orderIsoOp_symm_apply
@[to_additive (attr := simps) "The additive congruences on `M` bijects to the additive congruences
on `Mᵃᵒᵖ`"]
def orderIsoOp : Con M ≃o Con Mᵐᵒᵖ 
Arguments: {M : Type u_1} [Mul M] (c : Con Mᵐᵒᵖ)
Goal: (RelIso.symm Con.orderIsoOp) c = c.unop
-- AddCon.orderIsoOp_apply
@[to_additive (attr := simps) "The additive congruences on `M` bijects to the additive congruences
on `Mᵃᵒᵖ`"]
def orderIsoOp : Con M ≃o Con Mᵐᵒᵖ 
Arguments: {M : Type u_1} [Add M] (c : AddCon M)
Goal: AddCon.orderIsoOp c = c.op
-- AddCon.orderIsoOp_symm_apply
@[to_additive (attr := simps) "The additive congruences on `M` bijects to the additive congruences
on `Mᵃᵒᵖ`"]
def orderIsoOp : Con M ≃o Con Mᵐᵒᵖ 
Arguments: {M : Type u_1} [Add M] (c : AddCon Mᵃᵒᵖ)
Goal: (RelIso.symm AddCon.orderIsoOp) c = c.unop
-- Con.orderIsoOp_apply
@[to_additive (attr := simps) "The additive congruences on `M` bijects to the additive congruences
on `Mᵃᵒᵖ`"]
def orderIsoOp : Con M ≃o Con Mᵐᵒᵖ 
Arguments: {M : Type u_1} [Mul M] (c : Con M)
Goal: Con.orderIsoOp c = c.op
-- Submonoid.LocalizationMap.toMap_injective_iff
@[to_additive]
theorem toMap_injective_iff
    {M N : Type*} [CommMonoid M] {S : Submonoid M} [CommMonoid N] (f : LocalizationMap S N) :
    Injective (LocalizationMap.toMap f) ↔ ∀ ⦃x⦄, x ∈ S → IsLeftRegular x 
Arguments: {M : Type u_1} {N : Type u_2} [CommMonoid M] {S : Submonoid M} [CommMonoid N] (f : S.LocalizationMap N)
Goal: Function.Injective ⇑f.toMap ↔ ∀ ⦃x : M⦄, x ∈ S → IsLeftRegular x
-- AddSubmonoid.LocalizationMap.toMap_injective_iff
@[to_additive]
theorem toMap_injective_iff
    {M N : Type*} [CommMonoid M] {S : Submonoid M} [CommMonoid N] (f : LocalizationMap S N) :
    Injective (LocalizationMap.toMap f) ↔ ∀ ⦃x⦄, x ∈ S → IsLeftRegular x 
Arguments: {M : Type u_1} {N : Type u_2} [AddCommMonoid M] {S : AddSubmonoid M} [AddCommMonoid N] (f : S.LocalizationMap N)
Goal: Function.Injective ⇑f.toMap ↔ ∀ ⦃x : M⦄, x ∈ S → IsAddLeftRegular x
-- Submonoid.LocalizationMap.subsingleton
theorem LocalizationMap.subsingleton  (f : Submonoid.LocalizationMap S N) (h : 0 ∈ S) :
    Subsingleton N 
Arguments: {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [CommMonoidWithZero N] (f : S.LocalizationMap N) (h : 0 ∈ S)
Goal: Subsingleton N
-- Submonoid.LocalizationWithZeroMap.map_zero'
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure LocalizationWithZeroMap extends LocalizationMap S N where
  map_zero' : toFun 0 = 0
Arguments: {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [CommMonoidWithZero N] (self : S.LocalizationWithZeroMap N)
Goal: (↑self.toMonoidHom).toFun 0 = 0
-- Localization.mk_zero
theorem mk_zero (x : S) : mk 0 (x : S) = 0 
Arguments: {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} (x : ↥S)
Goal: Localization.mk 0 x = 0
-- Localization.liftOn_zero
theorem liftOn_zero {p : Type*} (f : M → S → p) (H) : liftOn 0 f H = f 0 1 
Arguments: {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} {p : Type u_4} (f : M → ↥S → p) (H : ∀ {a c : M} {b d : ↥S}, (Localization.r S) (a, b) (c, d) → f a b = f c d)
Goal: Localization.liftOn 0 f H = f 0 1
-- Submonoid.LocalizationMap.sec_zero_fst
@[simp]
theorem LocalizationMap.sec_zero_fst {f : LocalizationMap S N} : f.toMap (f.sec 0).fst = 0 
Arguments: {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [CommMonoidWithZero N] {f : S.LocalizationMap N}
Goal: f.toMap (f.sec 0).1 = 0
-- Submonoid.LocalizationWithZeroMap.leftCancelMulZero_of_le_isLeftRegular
theorem leftCancelMulZero_of_le_isLeftRegular
    (f : LocalizationWithZeroMap S N) [IsLeftCancelMulZero M]
    (h : ∀ ⦃x⦄, x ∈ S → IsLeftRegular x) : IsLeftCancelMulZero N 
Arguments: {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [CommMonoidWithZero N] (f : S.LocalizationWithZeroMap N) [IsLeftCancelMulZero M] (h : ∀ ⦃x : M⦄, x ∈ S → IsLeftRegular x)
Goal: IsLeftCancelMulZero N
-- Submonoid.LocalizationWithZeroMap.isLeftRegular_of_le_isCancelMulZero
theorem isLeftRegular_of_le_isCancelMulZero (f : LocalizationWithZeroMap S N)
    [IsCancelMulZero M] (h : ∀ ⦃x⦄, x ∈ S → IsRegular x) : IsCancelMulZero N 
Arguments: {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [CommMonoidWithZero N] (f : S.LocalizationWithZeroMap N) [IsCancelMulZero M] (h : ∀ ⦃x : M⦄, x ∈ S → IsRegular x)
Goal: IsCancelMulZero N
-- IsPGroup.iff_orderOf
theorem iff_orderOf [hp : Fact p.Prime] : IsPGroup p G ↔ ∀ g : G, ∃ k : ℕ, orderOf g = p ^ k 
Arguments: {p : ℕ} {G : Type u_1} [Group G] [hp : Fact (Nat.Prime p)]
Goal: IsPGroup p G ↔ ∀ (g : G), ∃ k, orderOf g = p ^ k
-- IsPGroup.of_card
theorem of_card {n : ℕ} (hG : Nat.card G = p ^ n) : IsPGroup p G 
Arguments: {p : ℕ} {G : Type u_1} [Group G] {n : ℕ} (hG : Nat.card G = p ^ n)
Goal: IsPGroup p G
-- IsPGroup.of_bot
theorem of_bot : IsPGroup p (⊥ : Subgroup G) 
Arguments: {p : ℕ} {G : Type u_1} [Group G]
Goal: IsPGroup p ↥⊥
-- IsPGroup.iff_card
theorem iff_card [Fact p.Prime] [Finite G] : IsPGroup p G ↔ ∃ n : ℕ, Nat.card G = p ^ n 
Arguments: {p : ℕ} {G : Type u_1} [Group G] [Fact (Nat.Prime p)] [Finite G]
Goal: IsPGroup p G ↔ ∃ n, Nat.card G = p ^ n