ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/GroupTheory/Subgroup/Saturated.lean

full_name: Subgroup.Saturated
code: /-- A subgroup `H` of `G` is *saturated* if for all `n : ℕ` and `g : G` with `g^n ∈ H`
we have `n = 0` or `g ∈ H`. -/
@[to_additive
      "An additive subgroup `H` of `G` is *saturated* if for all `n : ℕ` and `g : G` with `n•g ∈ H`
      we have `n = 0` or `g ∈ H`."]
def Saturated (H : Subgroup G) : Prop 
goal: Prop

full_name: AddSubgroup.Saturated
code: /-- A subgroup `H` of `G` is *saturated* if for all `n : ℕ` and `g : G` with `g^n ∈ H`
we have `n = 0` or `g ∈ H`. -/
@[to_additive
      "An additive subgroup `H` of `G` is *saturated* if for all `n : ℕ` and `g : G` with `n•g ∈ H`
      we have `n = 0` or `g ∈ H`."]
def Saturated (H : Subgroup G) : Prop 
goal: Prop

full_name: AddSubgroup.saturated_iff_nsmul
code: @[to_additive]
theorem saturated_iff_npow {H : Subgroup G} :
    Saturated H ↔ ∀ (n : ℕ) (g : G), g ^ n ∈ H → n = 0 ∨ g ∈ H 
goal: H.Saturated ↔ ∀ (n : ℕ) (g : G), n • g ∈ H → n = 0 ∨ g ∈ H

full_name: Subgroup.saturated_iff_npow
code: @[to_additive]
theorem saturated_iff_npow {H : Subgroup G} :
    Saturated H ↔ ∀ (n : ℕ) (g : G), g ^ n ∈ H → n = 0 ∨ g ∈ H 
goal: H.Saturated ↔ ∀ (n : ℕ) (g : G), g ^ n ∈ H → n = 0 ∨ g ∈ H

full_name: Subgroup.saturated_iff_zpow
code: @[to_additive]
theorem saturated_iff_zpow {H : Subgroup G} :
    Saturated H ↔ ∀ (n : ℤ) (g : G), g ^ n ∈ H → n = 0 ∨ g ∈ H 
goal: H.Saturated ↔ ∀ (n : ℤ) (g : G), g ^ n ∈ H → n = 0 ∨ g ∈ H

full_name: AddSubgroup.saturated_iff_zsmul
code: @[to_additive]
theorem saturated_iff_zpow {H : Subgroup G} :
    Saturated H ↔ ∀ (n : ℤ) (g : G), g ^ n ∈ H → n = 0 ∨ g ∈ H 
goal: H.Saturated ↔ ∀ (n : ℤ) (g : G), n • g ∈ H → n = 0 ∨ g ∈ H

full_name: AddSubgroup.ker_saturated
code: theorem ker_saturated {A₁ A₂ : Type*} [AddCommGroup A₁] [AddCommGroup A₂] [NoZeroSMulDivisors ℕ A₂]
    (f : A₁ →+ A₂) : f.ker.Saturated 
goal: f.ker.Saturated
File: Mathlib/GroupTheory/ClassEquation.lean

full_name: sum_conjClasses_card_eq_card
code: /-- Conjugacy classes form a partition of G, stated in terms of cardinality. -/
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 
goal: ∑ x : ConjClasses G, x.carrier.toFinset.card = Fintype.card G

full_name: Group.sum_card_conj_classes_eq_card
code: /-- Conjugacy classes form a partition of G, stated in terms of cardinality. -/
theorem Group.sum_card_conj_classes_eq_card [Finite G] :
    ∑ᶠ x : ConjClasses G, x.carrier.ncard = Nat.card G 
goal: ∑ᶠ (x : ConjClasses G), x.carrier.ncard = Nat.card G

full_name: Group.nat_card_center_add_sum_card_noncenter_eq_card
code: /-- The **class equation** for finite groups. The cardinality of a group is equal to the size
of its center plus the sum of the size of all its nontrivial conjugacy classes. -/
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 
goal: Nat.card ↥(Subgroup.center G) + ∑ᶠ (x : ConjClasses G) (_ : x ∈ ConjClasses.noncenter G), Nat.card ↑x.carrier =
  Nat.card G

full_name: Group.card_center_add_sum_card_noncenter_eq_card
code: 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 
goal: Fintype.card ↥(Subgroup.center G) + ∑ x ∈ (ConjClasses.noncenter G).toFinset, x.carrier.toFinset.card = Fintype.card G
File: Mathlib/GroupTheory/Congruence/BigOperators.lean

full_name: Con.list_prod
code: /-- Multiplicative congruence relations preserve product indexed by a list. -/
@[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 
goal: c (List.map f l).prod (List.map g l).prod

full_name: AddCon.list_sum
code: /-- Multiplicative congruence relations preserve product indexed by a list. -/
@[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 
goal: c (List.map f l).sum (List.map g l).sum

full_name: AddCon.multiset_sum
code: /-- Multiplicative congruence relations preserve product indexed by a multiset. -/
@[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 
goal: c (Multiset.map f s).sum (Multiset.map g s).sum

full_name: Con.multiset_prod
code: /-- Multiplicative congruence relations preserve product indexed by a multiset. -/
@[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 
goal: c (Multiset.map f s).prod (Multiset.map g s).prod

full_name: Con.finset_prod
code: /-- Multiplicative congruence relations preserve finite product. -/
@[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) 
goal: c (s.prod f) (s.prod g)

full_name: AddCon.finset_sum
code: /-- Multiplicative congruence relations preserve finite product. -/
@[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) 
goal: c (s.sum f) (s.sum g)
File: Mathlib/GroupTheory/Frattini.lean

full_name: frattini
code: /-- The Frattini subgroup of a group is the intersection of the maximal subgroups. -/
def frattini (G : Type*) [Group G] : Subgroup G 
goal: Subgroup G

full_name: frattini_le_coatom
code: lemma frattini_le_coatom {K : Subgroup G} (h : IsCoatom K) : frattini G ≤ K 
goal: frattini G ≤ K

full_name: frattini_le_comap_frattini_of_surjective
code: lemma frattini_le_comap_frattini_of_surjective : frattini G ≤ (frattini H).comap φ 
goal: frattini G ≤ Subgroup.comap φ (frattini H)

full_name: frattini_characteristic
code: /-- The Frattini subgroup is characteristic. -/
instance frattini_characteristic : (frattini G).Characteristic 
goal: (frattini G).Characteristic

full_name: frattini_nongenerating
code: /--
The Frattini subgroup consists of "non-generating" elements in the following sense:

If a subgroup together with the Frattini subgroup generates the whole group,
then the subgroup is already the whole group.
-/
theorem frattini_nongenerating [IsCoatomic (Subgroup G)] {K : Subgroup G}
    (h : K ⊔ frattini G = ⊤) : K = ⊤ 
goal: K = ⊤

full_name: frattini_nilpotent
code: /-- When `G` is finite, the Frattini subgroup is nilpotent. -/
theorem frattini_nilpotent [Finite G] : Group.IsNilpotent (frattini G) 
goal: Group.IsNilpotent ↥(frattini G)
File: Mathlib/GroupTheory/GroupAction/Support.lean

full_name: AddAction.Supports
code: /-- A set `s` supports `b` if `g • b = b` whenever `g • a = a` for all `a ∈ s`. -/
@[to_additive "A set `s` supports `b` if `g +ᵥ b = b` whenever `g +ᵥ a = a` for all `a ∈ s`."]
def Supports (s : Set α) (b : β) 
goal: Prop

full_name: MulAction.Supports
code: /-- A set `s` supports `b` if `g • b = b` whenever `g • a = a` for all `a ∈ s`. -/
@[to_additive "A set `s` supports `b` if `g +ᵥ b = b` whenever `g +ᵥ a = a` for all `a ∈ s`."]
def Supports (s : Set α) (b : β) 
goal: Prop

full_name: AddAction.supports_of_mem
code: @[to_additive]
theorem supports_of_mem (ha : a ∈ s) : Supports G s a 
goal: AddAction.Supports G s a

full_name: MulAction.supports_of_mem
code: @[to_additive]
theorem supports_of_mem (ha : a ∈ s) : Supports G s a 
goal: MulAction.Supports G s a

full_name: AddAction.Supports.mono
code: @[to_additive]
theorem Supports.mono (h : s ⊆ t) (hs : Supports G s b) : Supports G t b 
goal: AddAction.Supports G t b

full_name: MulAction.Supports.mono
code: @[to_additive]
theorem Supports.mono (h : s ⊆ t) (hs : Supports G s b) : Supports G t b 
goal: MulAction.Supports G t b

full_name: AddAction.Supports.vadd
code: @[to_additive]
theorem Supports.smul (g : H) (h : Supports G s b) : Supports G (g • s) (g • b) 
goal: AddAction.Supports G (g +ᵥ s) (g +ᵥ b)

full_name: MulAction.Supports.smul
code: @[to_additive]
theorem Supports.smul (g : H) (h : Supports G s b) : Supports G (g • s) (g • b) 
goal: MulAction.Supports G (g • s) (g • b)
File: Mathlib/GroupTheory/GroupAction/BigOperators.lean

full_name: List.smul_sum
code: theorem List.smul_sum {r : α} {l : List β} : r • l.sum = (l.map (r • ·)).sum 
goal: r • l.sum = (List.map (fun x => r • x) l).sum

full_name: List.smul_prod
code: theorem List.smul_prod {r : α} {l : List β} : r • l.prod = (l.map (r • ·)).prod 
goal: r • l.prod = (List.map (fun x => r • x) l).prod

full_name: Multiset.smul_sum
code: theorem Multiset.smul_sum {r : α} {s : Multiset β} : r • s.sum = (s.map (r • ·)).sum 
goal: r • s.sum = (Multiset.map (fun x => r • x) s).sum

full_name: Finset.smul_sum
code: theorem Finset.smul_sum {r : α} {f : γ → β} {s : Finset γ} :
    (r • ∑ x ∈ s, f x) = ∑ x ∈ s, r • f x 
goal: r • ∑ x ∈ s, f x = ∑ x ∈ s, r • f x

full_name: Multiset.smul_prod
code: theorem Multiset.smul_prod {r : α} {s : Multiset β} : r • s.prod = (s.map (r • ·)).prod 
goal: r • s.prod = (Multiset.map (fun x => r • x) s).prod

full_name: Finset.smul_prod
code: theorem Finset.smul_prod {r : α} {f : γ → β} {s : Finset γ} :
    (r • ∏ x ∈ s, f x) = ∏ x ∈ s, r • f x 
goal: r • ∏ x ∈ s, f x = ∏ x ∈ s, r • f x
File: Mathlib/GroupTheory/GroupAction/Embedding.lean

full_name: Function.Embedding.smul
code: @[to_additive]
instance smul [Group G] [MulAction G β] : SMul G (α ↪ β) 
goal: SMul G (α ↪ β)

full_name: Function.Embedding.vadd
code: @[to_additive]
instance smul [Group G] [MulAction G β] : SMul G (α ↪ β) 
goal: VAdd G (α ↪ β)

full_name: Function.Embedding.vadd_def
code: @[to_additive]
theorem smul_def [Group G] [MulAction G β] (g : G) (f : α ↪ β) :
    g • f = f.trans (MulAction.toPerm g).toEmbedding 
goal: g +ᵥ f = f.trans (Equiv.toEmbedding (AddAction.toPerm g))

full_name: Function.Embedding.smul_def
code: @[to_additive]
theorem smul_def [Group G] [MulAction G β] (g : G) (f : α ↪ β) :
    g • f = f.trans (MulAction.toPerm g).toEmbedding 
goal: g • f = f.trans (Equiv.toEmbedding (MulAction.toPerm g))

full_name: Function.Embedding.vadd_apply
code: @[to_additive (attr := simp)]
theorem smul_apply [Group G] [MulAction G β] (g : G) (f : α ↪ β) (a : α) : (g • f) a = g • f a 
goal: (g +ᵥ f) a = g +ᵥ f a

full_name: Function.Embedding.smul_apply
code: @[to_additive (attr := simp)]
theorem smul_apply [Group G] [MulAction G β] (g : G) (f : α ↪ β) (a : α) : (g • f) a = g • f a 
goal: (g • f) a = g • f a

full_name: Function.Embedding.coe_smul
code: @[to_additive]
theorem coe_smul [Group G] [MulAction G β] (g : G) (f : α ↪ β) : ⇑(g • f) = g • ⇑f 
goal: ⇑(g • f) = g • ⇑f

full_name: Function.Embedding.coe_vadd
code: @[to_additive]
theorem coe_smul [Group G] [MulAction G β] (g : G) (f : α ↪ β) : ⇑(g • f) = g • ⇑f 
goal: ⇑(g +ᵥ f) = g +ᵥ ⇑f

full_name: Function.Embedding.instIsScalarTower
code: instance [Group G] [Group G'] [SMul G G'] [MulAction G β] [MulAction G' β]
    [IsScalarTower G G' β] : IsScalarTower G G' (α ↪ β) 
goal: IsScalarTower G G' (α ↪ β)

full_name: Function.Embedding.instVAddCommClass
code: @[to_additive]
instance [Group G] [Group G'] [MulAction G β] [MulAction G' β] [SMulCommClass G G' β] :
    SMulCommClass G G' (α ↪ β) 
goal: VAddCommClass G G' (α ↪ β)

full_name: Function.Embedding.instSMulCommClass
code: @[to_additive]
instance [Group G] [Group G'] [MulAction G β] [MulAction G' β] [SMulCommClass G G' β] :
    SMulCommClass G G' (α ↪ β) 
goal: SMulCommClass G G' (α ↪ β)

full_name: Function.Embedding.instIsCentralScalar
code: instance [Group G] [MulAction G β] [MulAction Gᵐᵒᵖ β] [IsCentralScalar G β] :
    IsCentralScalar G (α ↪ β) 
goal: IsCentralScalar G (α ↪ β)

full_name: Function.Embedding.instAddAction
code: @[to_additive]
instance [Group G] [MulAction G β] : MulAction G (α ↪ β) 
goal: AddAction G (α ↪ β)

full_name: Function.Embedding.instMulAction
code: @[to_additive]
instance [Group G] [MulAction G β] : MulAction G (α ↪ β) 
goal: MulAction G (α ↪ β)
File: Mathlib/GroupTheory/GroupAction/DomAct/ActionHom.lean

full_name: DomMulAct.instSMulMulActionHomId
code: instance : SMul Mᵈᵐᵃ (α →[N] β) 
goal: SMul Mᵈᵐᵃ (α →ₑ[id] β)

full_name: DomMulAct.instSMulCommClassMulActionHomId
code: instance {M' : Type*} [SMul M' α] [SMulCommClass M' N α] [SMulCommClass M M' α] :
    SMulCommClass Mᵈᵐᵃ M'ᵈᵐᵃ (α →[N] β) 
goal: SMulCommClass Mᵈᵐᵃ M'ᵈᵐᵃ (α →ₑ[id] β)

full_name: DomMulAct.smul_mulActionHom_apply
code: theorem smul_mulActionHom_apply (c : Mᵈᵐᵃ) (f : α →[N] β) (a : α) :
    (c • f) a = f (mk.symm c • a) 
goal: (c • f) a = f (DomMulAct.mk.symm c • a)

full_name: DomMulAct.mk_smul_mulActionHom_apply
code: @[simp]
theorem mk_smul_mulActionHom_apply (c : M) (f : α →[N] β) (a : α) : (mk c • f) a = f (c • a) 
goal: (DomMulAct.mk c • f) a = f (c • a)

full_name: DomMulAct.instMulActionMulActionHomIdOfSMulCommClass
code: instance {M α N β : Type*} [Monoid M] [MulAction M α] [SMul N α] [SMulCommClass M N α] [SMul N β] :
    MulAction Mᵈᵐᵃ (α →[N] β) 
goal: MulAction Mᵈᵐᵃ (α →ₑ[id] β)

full_name: DomMulAct.instSMulDistribMulActionHomId
code: instance : SMul Mᵈᵐᵃ (A →+[N] B) 
goal: SMul Mᵈᵐᵃ (A →+[N] B)

full_name: DomMulAct.instSMulCommClassDistribMulActionHomId
code: instance {M' : Type*} [DistribSMul M' A] [SMulCommClass M' N A] [SMulCommClass M M' A] :
    SMulCommClass Mᵈᵐᵃ M'ᵈᵐᵃ (A →+[N] B) 
goal: SMulCommClass Mᵈᵐᵃ M'ᵈᵐᵃ (A →+[N] B)

full_name: DomMulAct.smul_mulDistribActionHom_apply
code: theorem smul_mulDistribActionHom_apply (c : Mᵈᵐᵃ) (f : A →+[N] B) (a : A) :
    (c • f) a = f (mk.symm c • a) 
goal: (c • f) a = f (DomMulAct.mk.symm c • a)

full_name: DomMulAct.mk_smul_mulDistribActionHom_apply
code: @[simp]
theorem mk_smul_mulDistribActionHom_apply (c : M) (f : A →+[N] B) (a : A) :
    (mk c • f) a = f (c • a) 
goal: (DomMulAct.mk c • f) a = f (c • a)

full_name: DomMulAct.instMulActionDistribMulActionHomIdOfSMulCommClass
code: instance {M N A B : Type*} [Monoid M] [AddMonoid A] [DistribMulAction M A] [Monoid N] [AddMonoid B]
    [DistribMulAction N A] [SMulCommClass M N A] [DistribMulAction N B] :
    MulAction Mᵈᵐᵃ (A →+[N] B) 
goal: MulAction Mᵈᵐᵃ (A →+[N] B)
File: Mathlib/GroupTheory/GroupAction/IterateAct.lean

full_name: IterateAddAct
code: /-- A structure with a single field `val : ℕ`
that additively acts on `α` by `⟨n⟩ +ᵥ x = f^[n] x`. -/
structure IterateAddAct {α : Type*} (f : α → α) where
  /-- The value of `n : IterateAddAct f`. -/
  val : ℕ
goal: Type

full_name: IterateAddAct.val
code: /-- A structure with a single field `val : ℕ`
that additively acts on `α` by `⟨n⟩ +ᵥ x = f^[n] x`. -/
structure IterateAddAct {α : Type*} (f : α → α) where
  /-- The value of `n : IterateAddAct f`. -/
  val : ℕ
goal: ℕ

full_name: IterateMulAct
code: /-- A structure with a single field `val : ℕ` that acts on `α` by `⟨n⟩ • x = f^[n] x`. -/
@[to_additive (attr := ext)]
structure IterateMulAct {α : Type*} (f : α → α) where
  /-- The value of `n : IterateMulAct f`. -/
  val : ℕ
goal: Type

full_name: IterateMulAct.val
code: /-- A structure with a single field `val : ℕ` that acts on `α` by `⟨n⟩ • x = f^[n] x`. -/
@[to_additive (attr := ext)]
structure IterateMulAct {α : Type*} (f : α → α) where
  /-- The value of `n : IterateMulAct f`. -/
  val : ℕ
goal: ℕ

full_name: IterateAddAct.instAddCommMonoid
code: @[to_additive]
instance instCommMonoid : CommMonoid (IterateMulAct f) 
goal: AddCommMonoid (IterateAddAct f)

full_name: IterateMulAct.instCommMonoid
code: @[to_additive]
instance instCommMonoid : CommMonoid (IterateMulAct f) 
goal: CommMonoid (IterateMulAct f)

full_name: IterateMulAct.instMulAction
code: @[to_additive]
instance instMulAction : MulAction (IterateMulAct f) α 
goal: MulAction (IterateMulAct f) α

full_name: IterateAddAct.instAddAction
code: @[to_additive]
instance instMulAction : MulAction (IterateMulAct f) α 
goal: AddAction (IterateAddAct f) α

full_name: IterateAddAct.mk_vadd
code: @[to_additive (attr := simp)]
theorem mk_smul (n : ℕ) (x : α) : mk (f := f) n • x = f^[n] x 
goal: { val := n } +ᵥ x = f^[n] x

full_name: IterateMulAct.mk_smul
code: @[to_additive (attr := simp)]
theorem mk_smul (n : ℕ) (x : α) : mk (f := f) n • x = f^[n] x 
goal: { val := n } • x = f^[n] x
File: Mathlib/GroupTheory/GroupAction/Ring.lean

full_name: NonUnitalNonAssocSemiring.nat_smulCommClass
code: /-- Note that `AddMonoid.nat_smulCommClass` requires stronger assumptions on `α`. -/
instance NonUnitalNonAssocSemiring.nat_smulCommClass [NonUnitalNonAssocSemiring α] :
    SMulCommClass ℕ α α 
goal: SMulCommClass ℕ α α

full_name: NonUnitalNonAssocSemiring.nat_isScalarTower
code: /-- Note that `AddCommMonoid.nat_isScalarTower` requires stronger assumptions on `α`. -/
instance NonUnitalNonAssocSemiring.nat_isScalarTower [NonUnitalNonAssocSemiring α] :
    IsScalarTower ℕ α α 
goal: IsScalarTower ℕ α α

full_name: NonUnitalNonAssocRing.int_smulCommClass
code: /-- Note that `AddMonoid.int_smulCommClass` requires stronger assumptions on `α`. -/
instance NonUnitalNonAssocRing.int_smulCommClass [NonUnitalNonAssocRing α] :
    SMulCommClass ℤ α α 
goal: SMulCommClass ℤ α α

full_name: NonUnitalNonAssocRing.int_isScalarTower
code: /-- Note that `AddCommGroup.int_isScalarTower` requires stronger assumptions on `α`. -/
instance NonUnitalNonAssocRing.int_isScalarTower [NonUnitalNonAssocRing α] :
    IsScalarTower ℤ α α 
goal: IsScalarTower ℤ α α
File: Mathlib/GroupTheory/GroupAction/SubMulAction/Pointwise.lean

full_name: SubMulAction.instOne
code: instance : One (SubMulAction R M) 
goal: One (SubMulAction R M)

full_name: SubMulAction.coe_one
code: theorem coe_one : ↑(1 : SubMulAction R M) = Set.range fun r : R => r • (1 : M) 
goal: ↑1 = Set.range fun r => r • 1

full_name: SubMulAction.mem_one
code: @[simp]
theorem mem_one {x : M} : x ∈ (1 : SubMulAction R M) ↔ ∃ r : R, r • (1 : M) = x 
goal: x ∈ 1 ↔ ∃ r, r • 1 = x

full_name: SubMulAction.subset_coe_one
code: theorem subset_coe_one : (1 : Set M) ⊆ (1 : SubMulAction R M) 
goal: 1 ⊆ ↑1

full_name: SubMulAction.instMul
code: instance : Mul (SubMulAction R M) 
goal: Mul (SubMulAction R M)

full_name: SubMulAction.coe_mul
code: @[norm_cast]
theorem coe_mul (p q : SubMulAction R M) : ↑(p * q) = (p * q : Set M) 
goal: ↑(p * q) = ↑p * ↑q

full_name: SubMulAction.mem_mul
code: theorem mem_mul {p q : SubMulAction R M} {x : M} : x ∈ p * q ↔ ∃ y ∈ p, ∃ z ∈ q, y * z = x 
goal: x ∈ p * q ↔ ∃ y ∈ p, ∃ z ∈ q, y * z = x

full_name: SubMulAction.mulOneClass
code: instance mulOneClass : MulOneClass (SubMulAction R M) 
goal: MulOneClass (SubMulAction R M)

full_name: SubMulAction.semiGroup
code: instance semiGroup : Semigroup (SubMulAction R M) 
goal: Semigroup (SubMulAction R M)

full_name: SubMulAction.instMonoid
code: instance : Monoid (SubMulAction R M) 
goal: Monoid (SubMulAction R M)

full_name: SubMulAction.coe_pow
code: theorem coe_pow (p : SubMulAction R M) : ∀ {n : ℕ} (_ : n ≠ 0), ↑(p ^ n) = (p : Set M) ^ n
  
goal: n ≠ 0 → ↑(p ^ n) = ↑p ^ n

full_name: SubMulAction.subset_coe_pow
code: theorem subset_coe_pow (p : SubMulAction R M) : ∀ {n : ℕ}, (p : Set M) ^ n ⊆ ↑(p ^ n)
  
goal: ↑p ^ n ⊆ ↑(p ^ n)
File: Mathlib/GroupTheory/GroupAction/Pointwise.lean

full_name: MulAction.smul_bijective_of_is_unit
code: theorem MulAction.smul_bijective_of_is_unit
    {M : Type*} [Monoid M] {α : Type*} [MulAction M α] {m : M} (hm : IsUnit m) :
    Function.Bijective (fun (a : α) ↦ m • a) 
goal: Function.Bijective fun a => m • a

full_name: image_smul_setₛₗ
code: theorem image_smul_setₛₗ :
    h '' (c • s) = σ c • h '' s 
goal: ⇑h '' (c • s) = σ c • ⇑h '' s

full_name: smul_preimage_set_leₛₗ
code: /-- Translation of preimage is contained in preimage of translation -/
theorem smul_preimage_set_leₛₗ :
    c • h ⁻¹' t ⊆ h ⁻¹' (σ c • t) 
goal: c • ⇑h ⁻¹' t ⊆ ⇑h ⁻¹' (σ c • t)

full_name: preimage_smul_setₛₗ'
code: /-- General version of `preimage_smul_setₛₗ` -/
theorem preimage_smul_setₛₗ'
    (hc : Function.Surjective (fun (m : M) ↦ c • m))
    (hc' : Function.Injective (fun (n : N) ↦ σ c • n)) :
    h ⁻¹' (σ c • t) = c • h ⁻¹' t 
goal: ⇑h ⁻¹' (σ c • t) = c • ⇑h ⁻¹' t

full_name: preimage_smul_setₛₗ_of_units
code: /-- `preimage_smul_setₛₗ` when both scalars act by unit -/
theorem preimage_smul_setₛₗ_of_units (hc : IsUnit c) (hc' : IsUnit (σ c)) :
    h ⁻¹' (σ c • t) = c • h ⁻¹' t 
goal: ⇑h ⁻¹' (σ c • t) = c • ⇑h ⁻¹' t

full_name: MonoidHom.preimage_smul_setₛₗ
code: /-- `preimage_smul_setₛₗ` in the context of a `MonoidHom` -/
theorem MonoidHom.preimage_smul_setₛₗ (σ : R →* S)
    {F : Type*} [FunLike F M N] [MulActionSemiHomClass F ⇑σ M N] (h : F)
    {c : R} (hc : IsUnit c) (t : Set N) :
    h ⁻¹' (σ c • t) = c • h ⁻¹' t 
goal: ⇑h ⁻¹' (σ c • t) = c • ⇑h ⁻¹' t

full_name: preimage_smul_setₛₗ
code: /-- `preimage_smul_setₛₗ` in the context of a `MonoidHomClass` -/
theorem preimage_smul_setₛₗ
    {G : Type*} [FunLike G R S] [MonoidHomClass G R S] (σ : G)
    {F : Type*} [FunLike F M N] [MulActionSemiHomClass F σ M N] (h : F)
    {c : R} (hc : IsUnit c) (t : Set N) :
    h ⁻¹' (σ c • t) = c • h ⁻¹' t 
goal: ⇑h ⁻¹' (σ c • t) = c • ⇑h ⁻¹' t

full_name: Group.preimage_smul_setₛₗ
code: /-- `preimage_smul_setₛₗ` in the context of a groups -/
theorem Group.preimage_smul_setₛₗ
    {R S : Type*} [Group R] [Group S] (σ : R → S)
    [MulAction R M] [MulAction S N]
    {F : Type*} [FunLike F M N] [MulActionSemiHomClass F σ M N] (h : F)
    (c : R) (t : Set N) :
    h ⁻¹' (σ c • t) = c • h ⁻¹' t 
goal: ⇑h ⁻¹' (σ c • t) = c • ⇑h ⁻¹' t

full_name: image_smul_set
code: @[simp] -- This can be safely removed as a `@[simp]` lemma if `image_smul_setₛₗ` is readded.
theorem image_smul_set :
    h '' (c • s) = c • h '' s 
goal: ⇑h '' (c • s) = c • ⇑h '' s

full_name: smul_preimage_set_le
code: theorem smul_preimage_set_le :
    c • h ⁻¹' t ⊆ h ⁻¹' (c • t) 
goal: c • ⇑h ⁻¹' t ⊆ ⇑h ⁻¹' (c • t)

full_name: preimage_smul_set
code: theorem preimage_smul_set (hc : IsUnit c) :
    h ⁻¹' (c • t) = c • h ⁻¹' t 
goal: ⇑h ⁻¹' (c • t) = c • ⇑h ⁻¹' t

full_name: Group.preimage_smul_set
code: theorem Group.preimage_smul_set
    {R : Type*} [Group R] (M₁ M₂ : Type*)
    [MulAction R M₁] [MulAction R M₂]
    {F : Type*} [FunLike F M₁ M₂] [MulActionHomClass F R M₁ M₂] (h : F)
    (c : R) (t : Set M₂) :
    h ⁻¹' (c • t) = c • h ⁻¹' t 
goal: ⇑h ⁻¹' (c • t) = c • ⇑h ⁻¹' t