ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- fixingSubgroup_fixedPoints_gc
theorem fixingSubgroup_fixedPoints_gc :
    GaloisConnection (OrderDual.toDual ∘ fixingSubgroup M)
      ((fun P : Subgroup M => fixedPoints P α) ∘ OrderDual.ofDual) 
Arguments: (M : Type u_1) (α : Type u_2) [Group M] [MulAction M α]
Goal: GaloisConnection (⇑OrderDual.toDual ∘ fixingSubgroup M) ((fun P => MulAction.fixedPoints (↥P) α) ∘ ⇑OrderDual.ofDual)
-- fixingSubgroup_antitone
theorem fixingSubgroup_antitone : Antitone (fixingSubgroup M : Set α → Subgroup M) 
Arguments: (M : Type u_1) (α : Type u_2) [Group M] [MulAction M α]
Goal: Antitone (fixingSubgroup M)
-- fixedPoints_subgroup_antitone
theorem fixedPoints_subgroup_antitone : Antitone fun P : Subgroup M => fixedPoints P α 
Arguments: (M : Type u_1) (α : Type u_2) [Group M] [MulAction M α]
Goal: Antitone fun P => MulAction.fixedPoints (↥P) α
-- fixingSubgroup_union
theorem fixingSubgroup_union {s t : Set α} :
    fixingSubgroup M (s ∪ t) = fixingSubgroup M s ⊓ fixingSubgroup M t 
Arguments: (M : Type u_1) (α : Type u_2) [Group M] [MulAction M α] {s t : Set α}
Goal: fixingSubgroup M (s ∪ t) = fixingSubgroup M s ⊓ fixingSubgroup M t
-- fixingSubgroup_iUnion
theorem fixingSubgroup_iUnion {ι : Sort*} {s : ι → Set α} :
    fixingSubgroup M (⋃ i, s i) = ⨅ i, fixingSubgroup M (s i) 
Arguments: (M : Type u_1) (α : Type u_2) [Group M] [MulAction M α] {ι : Sort u_3} {s : ι → Set α}
Goal: fixingSubgroup M (⋃ i, s i) = ⨅ i, fixingSubgroup M (s i)
-- fixedPoints_subgroup_sup
theorem fixedPoints_subgroup_sup {P Q : Subgroup M} :
    fixedPoints (↥(P ⊔ Q)) α = fixedPoints P α ∩ fixedPoints Q α 
Arguments: (M : Type u_1) (α : Type u_2) [Group M] [MulAction M α] {P Q : Subgroup M}
Goal: MulAction.fixedPoints (↥(P ⊔ Q)) α = MulAction.fixedPoints (↥P) α ∩ MulAction.fixedPoints (↥Q) α
-- fixedPoints_subgroup_iSup
theorem fixedPoints_subgroup_iSup {ι : Sort*} {P : ι → Subgroup M} :
    fixedPoints (↥(iSup P)) α = ⋂ i, fixedPoints (P i) α 
Arguments: (M : Type u_1) (α : Type u_2) [Group M] [MulAction M α] {ι : Sort u_3} {P : ι → Subgroup M}
Goal: MulAction.fixedPoints (↥(iSup P)) α = ⋂ i, MulAction.fixedPoints (↥(P i)) α
-- orbit_fixingSubgroup_compl_subset
theorem orbit_fixingSubgroup_compl_subset {s : Set α} {a : α} (a_in_s : a ∈ s) :
    MulAction.orbit (fixingSubgroup M sᶜ) a ⊆ s 
Arguments: (M : Type u_1) (α : Type u_2) [Group M] [MulAction M α] {s : Set α} {a : α} (a_in_s : a ∈ s)
Goal: MulAction.orbit (↥(fixingSubgroup M sᶜ)) a ⊆ s
-- MulAction.le_period
@[to_additive "If the action is periodic, then a lower bound for its period can be computed."]
theorem le_period {m : M} {a : α} {n : ℕ} (period_pos : 0 < period m a)
    (moved : ∀ k, 0 < k → k < n → m ^ k • a ≠ a) : n ≤ period m a 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] {m : M} {a : α} {n : ℕ} (period_pos : 0 < MulAction.period m a) (moved : ∀ (k : ℕ), 0 < k → k < n → m ^ k • a ≠ a)
Goal: n ≤ MulAction.period m a
-- AddAction.le_period
@[to_additive "If the action is periodic, then a lower bound for its period can be computed."]
theorem le_period {m : M} {a : α} {n : ℕ} (period_pos : 0 < period m a)
    (moved : ∀ k, 0 < k → k < n → m ^ k • a ≠ a) : n ≤ period m a 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] {m : M} {a : α} {n : ℕ} (period_pos : 0 < AddAction.period m a) (moved : ∀ (k : ℕ), 0 < k → k < n → k • m +ᵥ a ≠ a)
Goal: n ≤ AddAction.period m a
-- AddAction.period_le_of_fixed
@[to_additive "If for some `n`, `(n • m) +ᵥ a = a`, then `period m a ≤ n`."]
theorem period_le_of_fixed {m : M} {a : α} {n : ℕ} (n_pos : 0 < n) (fixed : m ^ n • a = a) :
    period m a ≤ n 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] {m : M} {a : α} {n : ℕ} (n_pos : 0 < n) (fixed : n • m +ᵥ a = a)
Goal: AddAction.period m a ≤ n
-- MulAction.period_le_of_fixed
@[to_additive "If for some `n`, `(n • m) +ᵥ a = a`, then `period m a ≤ n`."]
theorem period_le_of_fixed {m : M} {a : α} {n : ℕ} (n_pos : 0 < n) (fixed : m ^ n • a = a) :
    period m a ≤ n 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] {m : M} {a : α} {n : ℕ} (n_pos : 0 < n) (fixed : m ^ n • a = a)
Goal: MulAction.period m a ≤ n
-- MulAction.period_pos_of_fixed
@[to_additive "If for some `n`, `(n • m) +ᵥ a = a`, then `0 < period m a`."]
theorem period_pos_of_fixed {m : M} {a : α} {n : ℕ} (n_pos : 0 < n) (fixed : m ^ n • a = a) :
    0 < period m a 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] {m : M} {a : α} {n : ℕ} (n_pos : 0 < n) (fixed : m ^ n • a = a)
Goal: 0 < MulAction.period m a
-- AddAction.period_pos_of_fixed
@[to_additive "If for some `n`, `(n • m) +ᵥ a = a`, then `0 < period m a`."]
theorem period_pos_of_fixed {m : M} {a : α} {n : ℕ} (n_pos : 0 < n) (fixed : m ^ n • a = a) :
    0 < period m a 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] {m : M} {a : α} {n : ℕ} (n_pos : 0 < n) (fixed : n • m +ᵥ a = a)
Goal: 0 < AddAction.period m a
-- MulAction.period_eq_one_iff
@[to_additive]
theorem period_eq_one_iff {m : M} {a : α} : period m a = 1 ↔ m • a = a 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] {m : M} {a : α}
Goal: MulAction.period m a = 1 ↔ m • a = a
-- AddAction.period_eq_zero_iff
@[to_additive]
theorem period_eq_one_iff {m : M} {a : α} : period m a = 1 ↔ m • a = a 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] {m : M} {a : α}
Goal: AddAction.period m a = 1 ↔ m +ᵥ a = a
-- MulAction.pow_smul_ne_of_lt_period
@[to_additive "For any non-zero `n` less than the period of `m` on `a`, `a` is moved by `n • m`."]
theorem pow_smul_ne_of_lt_period {m : M} {a : α} {n : ℕ} (n_pos : 0 < n)
    (n_lt_period : n < period m a) : m ^ n • a ≠ a 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] {m : M} {a : α} {n : ℕ} (n_pos : 0 < n) (n_lt_period : n < MulAction.period m a)
Goal: m ^ n • a ≠ a
-- AddAction.nsmul_vadd_ne_of_lt_period
@[to_additive "For any non-zero `n` less than the period of `m` on `a`, `a` is moved by `n • m`."]
theorem pow_smul_ne_of_lt_period {m : M} {a : α} {n : ℕ} (n_pos : 0 < n)
    (n_lt_period : n < period m a) : m ^ n • a ≠ a 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] {m : M} {a : α} {n : ℕ} (n_pos : 0 < n) (n_lt_period : n < AddAction.period m a)
Goal: n • m +ᵥ a ≠ a
-- MulAction.period_one
@[to_additive (attr := simp)]
theorem period_one (a : α) : period (1 : M) a = 1 
Arguments: {α : Type v} (M : Type u) [Monoid M] [MulAction M α] (a : α)
Goal: MulAction.period 1 a = 1
-- AddAction.period_zero
@[to_additive (attr := simp)]
theorem period_one (a : α) : period (1 : M) a = 1 
Arguments: {α : Type v} (M : Type u) [AddMonoid M] [AddAction M α] (a : α)
Goal: AddAction.period 0 a = 1
-- MulAction.period_inv
@[to_additive (attr := simp)]
theorem period_inv (g : G) (a : α) : period g⁻¹ a = period g a 
Arguments: {α : Type v} {G : Type u} [Group G] [MulAction G α] (g : G) (a : α)
Goal: MulAction.period g⁻¹ a = MulAction.period g a
-- AddAction.period_neg
@[to_additive (attr := simp)]
theorem period_inv (g : G) (a : α) : period g⁻¹ a = period g a 
Arguments: {α : Type v} {G : Type u} [AddGroup G] [AddAction G α] (g : G) (a : α)
Goal: AddAction.period (-g) a = AddAction.period g a
-- AddAction.period_dvd_addOrderOf
@[to_additive]
theorem period_dvd_orderOf (m : M) (a : α) : period m a ∣ orderOf m 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] (m : M) (a : α)
Goal: AddAction.period m a ∣ addOrderOf m
-- MulAction.period_dvd_orderOf
@[to_additive]
theorem period_dvd_orderOf (m : M) (a : α) : period m a ∣ orderOf m 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] (m : M) (a : α)
Goal: MulAction.period m a ∣ orderOf m
-- AddAction.period_pos_of_addOrderOf_pos
@[to_additive]
theorem period_pos_of_orderOf_pos {m : M} (order_pos : 0 < orderOf m) (a : α) :
    0 < period m a 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] {m : M} (order_pos : 0 < addOrderOf m) (a : α)
Goal: 0 < AddAction.period m a
-- MulAction.period_pos_of_orderOf_pos
@[to_additive]
theorem period_pos_of_orderOf_pos {m : M} (order_pos : 0 < orderOf m) (a : α) :
    0 < period m a 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] {m : M} (order_pos : 0 < orderOf m) (a : α)
Goal: 0 < MulAction.period m a
-- MulAction.period_le_orderOf
@[to_additive]
theorem period_le_orderOf {m : M} (order_pos : 0 < orderOf m) (a : α) :
    period m a ≤ orderOf m 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] {m : M} (order_pos : 0 < orderOf m) (a : α)
Goal: MulAction.period m a ≤ orderOf m
-- AddAction.period_le_addOrderOf
@[to_additive]
theorem period_le_orderOf {m : M} (order_pos : 0 < orderOf m) (a : α) :
    period m a ≤ orderOf m 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] {m : M} (order_pos : 0 < addOrderOf m) (a : α)
Goal: AddAction.period m a ≤ addOrderOf m
-- MulAction.period_dvd_exponent
@[to_additive]
theorem period_dvd_exponent (m : M) (a : α) : period m a ∣ Monoid.exponent M 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] (m : M) (a : α)
Goal: MulAction.period m a ∣ Monoid.exponent M
-- AddAction.period_dvd_exponent
@[to_additive]
theorem period_dvd_exponent (m : M) (a : α) : period m a ∣ Monoid.exponent M 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] (m : M) (a : α)
Goal: AddAction.period m a ∣ AddMonoid.exponent M
-- AddAction.period_pos_of_exponent_pos
@[to_additive]
theorem period_pos_of_exponent_pos (exp_pos : 0 < Monoid.exponent M) (m : M) (a : α) :
    0 < period m a 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] (exp_pos : 0 < AddMonoid.exponent M) (m : M) (a : α)
Goal: 0 < AddAction.period m a
-- MulAction.period_pos_of_exponent_pos
@[to_additive]
theorem period_pos_of_exponent_pos (exp_pos : 0 < Monoid.exponent M) (m : M) (a : α) :
    0 < period m a 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] (exp_pos : 0 < Monoid.exponent M) (m : M) (a : α)
Goal: 0 < MulAction.period m a
-- AddAction.period_le_exponent
@[to_additive]
theorem period_le_exponent (exp_pos : 0 < Monoid.exponent M) (m : M) (a : α) :
    period m a ≤ Monoid.exponent M 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] (exp_pos : 0 < AddMonoid.exponent M) (m : M) (a : α)
Goal: AddAction.period m a ≤ AddMonoid.exponent M
-- MulAction.period_le_exponent
@[to_additive]
theorem period_le_exponent (exp_pos : 0 < Monoid.exponent M) (m : M) (a : α) :
    period m a ≤ Monoid.exponent M 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] (exp_pos : 0 < Monoid.exponent M) (m : M) (a : α)
Goal: MulAction.period m a ≤ Monoid.exponent M
-- MulAction.period_bounded_of_exponent_pos
@[to_additive]
theorem period_bounded_of_exponent_pos (exp_pos : 0 < Monoid.exponent M) (m : M) :
    BddAbove (Set.range (fun a : α => period m a)) 
Arguments: (α : Type v) {M : Type u} [Monoid M] [MulAction M α] (exp_pos : 0 < Monoid.exponent M) (m : M)
Goal: BddAbove (Set.range fun a => MulAction.period m a)
-- AddAction.period_bounded_of_exponent_pos
@[to_additive]
theorem period_bounded_of_exponent_pos (exp_pos : 0 < Monoid.exponent M) (m : M) :
    BddAbove (Set.range (fun a : α => period m a)) 
Arguments: (α : Type v) {M : Type u} [AddMonoid M] [AddAction M α] (exp_pos : 0 < AddMonoid.exponent M) (m : M)
Goal: BddAbove (Set.range fun a => AddAction.period m a)
-- SubMulAction.coe_one
theorem coe_one : ↑(1 : SubMulAction R M) = Set.range fun r : R => r • (1 : M) 
Arguments: {R : Type u_1} {M : Type u_2} [Monoid R] [MulAction R M] [One M]
Goal: ↑1 = Set.range fun r => r • 1
-- SubMulAction.mem_one
@[simp]
theorem mem_one {x : M} : x ∈ (1 : SubMulAction R M) ↔ ∃ r : R, r • (1 : M) = x 
Arguments: {R : Type u_1} {M : Type u_2} [Monoid R] [MulAction R M] [One M] {x : M}
Goal: x ∈ 1 ↔ ∃ r, r • 1 = x
-- SubMulAction.subset_coe_one
theorem subset_coe_one : (1 : Set M) ⊆ (1 : SubMulAction R M) 
Arguments: {R : Type u_1} {M : Type u_2} [Monoid R] [MulAction R M] [One M]
Goal: 1 ⊆ ↑1
-- SubMulAction.coe_mul
@[norm_cast]
theorem coe_mul (p q : SubMulAction R M) : ↑(p * q) = (p * q : Set M) 
Arguments: {R : Type u_1} {M : Type u_2} [Monoid R] [MulAction R M] [Mul M] [IsScalarTower R M M] (p q : SubMulAction R M)
Goal: ↑(p * q) = ↑p * ↑q
-- SubMulAction.mem_mul
theorem mem_mul {p q : SubMulAction R M} {x : M} : x ∈ p * q ↔ ∃ y ∈ p, ∃ z ∈ q, y * z = x 
Arguments: {R : Type u_1} {M : Type u_2} [Monoid R] [MulAction R M] [Mul M] [IsScalarTower R M M] {p q : SubMulAction R M} {x : M}
Goal: x ∈ p * q ↔ ∃ y ∈ p, ∃ z ∈ q, y * z = x
-- SubMulAction.coe_pow
theorem coe_pow (p : SubMulAction R M) : ∀ {n : ℕ} (_ : n ≠ 0), ↑(p ^ n) = (p : Set M) ^ n
  
Arguments: {R : Type u_1} {M : Type u_2} [Monoid R] [MulAction R M] [Monoid M] [IsScalarTower R M M] [SMulCommClass R M M] (p : SubMulAction R M) {n : ℕ}
Goal: n ≠ 0 → ↑(p ^ n) = ↑p ^ n
-- SubMulAction.subset_coe_pow
theorem subset_coe_pow (p : SubMulAction R M) : ∀ {n : ℕ}, (p : Set M) ^ n ⊆ ↑(p ^ n)
  
Arguments: {R : Type u_1} {M : Type u_2} [Monoid R] [MulAction R M] [Monoid M] [IsScalarTower R M M] [SMulCommClass R M M] (p : SubMulAction R M) {n : ℕ}
Goal: ↑p ^ n ⊆ ↑(p ^ n)
-- MulAction.fixedBy_inv
@[to_additive (attr := simp)
  "In an additive group action, the points fixed by `g` are also fixed by `g⁻¹`"]
theorem fixedBy_inv (g : G) : fixedBy α g⁻¹ = fixedBy α g 
Arguments: (α : Type u_1) {G : Type u_2} [Group G] [MulAction G α] (g : G)
Goal: MulAction.fixedBy α g⁻¹ = MulAction.fixedBy α g
-- AddAction.fixedBy_neg
@[to_additive (attr := simp)
  "In an additive group action, the points fixed by `g` are also fixed by `g⁻¹`"]
theorem fixedBy_inv (g : G) : fixedBy α g⁻¹ = fixedBy α g 
Arguments: (α : Type u_1) {G : Type u_2} [AddGroup G] [AddAction G α] (g : G)
Goal: AddAction.fixedBy α (-g) = AddAction.fixedBy α g
-- MulAction.smul_mem_fixedBy_iff_mem_fixedBy
@[to_additive]
theorem smul_mem_fixedBy_iff_mem_fixedBy {a : α} {g : G} :
    g • a ∈ fixedBy α g ↔ a ∈ fixedBy α g 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] [MulAction G α] {a : α} {g : G}
Goal: g • a ∈ MulAction.fixedBy α g ↔ a ∈ MulAction.fixedBy α g
-- AddAction.vadd_mem_fixedBy_iff_mem_fixedBy
@[to_additive]
theorem smul_mem_fixedBy_iff_mem_fixedBy {a : α} {g : G} :
    g • a ∈ fixedBy α g ↔ a ∈ fixedBy α g 
Arguments: {α : Type u_1} {G : Type u_2} [AddGroup G] [AddAction G α] {a : α} {g : G}
Goal: g +ᵥ a ∈ AddAction.fixedBy α g ↔ a ∈ AddAction.fixedBy α g
-- AddAction.vadd_neg_mem_fixedBy_iff_mem_fixedBy
@[to_additive]
theorem smul_inv_mem_fixedBy_iff_mem_fixedBy {a : α} {g : G} :
    g⁻¹ • a ∈ fixedBy α g ↔ a ∈ fixedBy α g 
Arguments: {α : Type u_1} {G : Type u_2} [AddGroup G] [AddAction G α] {a : α} {g : G}
Goal: -g +ᵥ a ∈ AddAction.fixedBy α g ↔ a ∈ AddAction.fixedBy α g
-- MulAction.smul_inv_mem_fixedBy_iff_mem_fixedBy
@[to_additive]
theorem smul_inv_mem_fixedBy_iff_mem_fixedBy {a : α} {g : G} :
    g⁻¹ • a ∈ fixedBy α g ↔ a ∈ fixedBy α g 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] [MulAction G α] {a : α} {g : G}
Goal: g⁻¹ • a ∈ MulAction.fixedBy α g ↔ a ∈ MulAction.fixedBy α g
-- MulAction.minimalPeriod_eq_one_iff_fixedBy
@[to_additive minimalPeriod_eq_one_iff_fixedBy]
theorem minimalPeriod_eq_one_iff_fixedBy {a : α} {g : G} :
    Function.minimalPeriod (fun x => g • x) a = 1 ↔ a ∈ fixedBy α g 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] [MulAction G α] {a : α} {g : G}
Goal: Function.minimalPeriod (fun x => g • x) a = 1 ↔ a ∈ MulAction.fixedBy α g
-- AddAction.minimalPeriod_eq_one_iff_fixedBy
@[to_additive minimalPeriod_eq_one_iff_fixedBy]
theorem minimalPeriod_eq_one_iff_fixedBy {a : α} {g : G} :
    Function.minimalPeriod (fun x => g • x) a = 1 ↔ a ∈ fixedBy α g 
Arguments: {α : Type u_1} {G : Type u_2} [AddGroup G] [AddAction G α] {a : α} {g : G}
Goal: Function.minimalPeriod (fun x => g +ᵥ x) a = 1 ↔ a ∈ AddAction.fixedBy α g
-- AddAction.fixedBy_subset_fixedBy_zsmul
@[to_additive]
theorem fixedBy_subset_fixedBy_zpow (g : G) (j : ℤ) :
    fixedBy α g ⊆ fixedBy α (g ^ j) 
Arguments: (α : Type u_1) {G : Type u_2} [AddGroup G] [AddAction G α] (g : G) (j : ℤ)
Goal: AddAction.fixedBy α g ⊆ AddAction.fixedBy α (j • g)
-- MulAction.fixedBy_subset_fixedBy_zpow
@[to_additive]
theorem fixedBy_subset_fixedBy_zpow (g : G) (j : ℤ) :
    fixedBy α g ⊆ fixedBy α (g ^ j) 
Arguments: (α : Type u_1) {G : Type u_2} [Group G] [MulAction G α] (g : G) (j : ℤ)
Goal: MulAction.fixedBy α g ⊆ MulAction.fixedBy α (g ^ j)
-- AddAction.fixedBy_zero_eq_univ
@[to_additive (attr := simp)]
theorem fixedBy_one_eq_univ : fixedBy α (1 : M) = Set.univ 
Arguments: (α : Type u_1) (M : Type u_3) [AddMonoid M] [AddAction M α]
Goal: AddAction.fixedBy α 0 = Set.univ
-- MulAction.fixedBy_one_eq_univ
@[to_additive (attr := simp)]
theorem fixedBy_one_eq_univ : fixedBy α (1 : M) = Set.univ 
Arguments: (α : Type u_1) (M : Type u_3) [Monoid M] [MulAction M α]
Goal: MulAction.fixedBy α 1 = Set.univ
-- MulAction.fixedBy_mul
@[to_additive]
theorem fixedBy_mul (m₁ m₂ : M) : fixedBy α m₁ ∩ fixedBy α m₂ ⊆ fixedBy α (m₁ * m₂) 
Arguments: (α : Type u_1) {M : Type u_3} [Monoid M] [MulAction M α] (m₁ m₂ : M)
Goal: MulAction.fixedBy α m₁ ∩ MulAction.fixedBy α m₂ ⊆ MulAction.fixedBy α (m₁ * m₂)
-- AddAction.fixedBy_add
@[to_additive]
theorem fixedBy_mul (m₁ m₂ : M) : fixedBy α m₁ ∩ fixedBy α m₂ ⊆ fixedBy α (m₁ * m₂) 
Arguments: (α : Type u_1) {M : Type u_3} [AddMonoid M] [AddAction M α] (m₁ m₂ : M)
Goal: AddAction.fixedBy α m₁ ∩ AddAction.fixedBy α m₂ ⊆ AddAction.fixedBy α (m₁ + m₂)
-- AddAction.vadd_fixedBy
@[to_additive]
theorem smul_fixedBy (g h : G) :
    h • fixedBy α g = fixedBy α (h * g * h⁻¹) 
Arguments: (α : Type u_1) {G : Type u_2} [AddGroup G] [AddAction G α] (g h : G)
Goal: h +ᵥ AddAction.fixedBy α g = AddAction.fixedBy α (h + g + -h)
-- MulAction.smul_fixedBy
@[to_additive]
theorem smul_fixedBy (g h : G) :
    h • fixedBy α g = fixedBy α (h * g * h⁻¹) 
Arguments: (α : Type u_1) {G : Type u_2} [Group G] [MulAction G α] (g h : G)
Goal: h • MulAction.fixedBy α g = MulAction.fixedBy α (h * g * h⁻¹)
-- AddAction.set_mem_fixedBy_iff
@[to_additive "If a set `s : Set α` is in `fixedBy (Set α) g`, then all points of `s` will stay in
`s` after being moved by `g`."]
theorem set_mem_fixedBy_iff (s : Set α) (g : G) :
    s ∈ fixedBy (Set α) g ↔ ∀ x, g • x ∈ s ↔ x ∈ s 
Arguments: {α : Type u_1} {G : Type u_2} [AddGroup G] [AddAction G α] (s : Set α) (g : G)
Goal: s ∈ AddAction.fixedBy (Set α) g ↔ ∀ (x : α), g +ᵥ x ∈ s ↔ x ∈ s
-- MulAction.set_mem_fixedBy_iff
@[to_additive "If a set `s : Set α` is in `fixedBy (Set α) g`, then all points of `s` will stay in
`s` after being moved by `g`."]
theorem set_mem_fixedBy_iff (s : Set α) (g : G) :
    s ∈ fixedBy (Set α) g ↔ ∀ x, g • x ∈ s ↔ x ∈ s 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] [MulAction G α] (s : Set α) (g : G)
Goal: s ∈ MulAction.fixedBy (Set α) g ↔ ∀ (x : α), g • x ∈ s ↔ x ∈ s
-- MulAction.smul_mem_of_set_mem_fixedBy
theorem smul_mem_of_set_mem_fixedBy {s : Set α} {g : G} (s_in_fixedBy : s ∈ fixedBy (Set α) g)
    {x : α} : g • x ∈ s ↔ x ∈ s 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] [MulAction G α] {s : Set α} {g : G} (s_in_fixedBy : s ∈ MulAction.fixedBy (Set α) g) {x : α}
Goal: g • x ∈ s ↔ x ∈ s
-- MulAction.set_mem_fixedBy_of_subset_fixedBy
@[to_additive "If `s ⊆ fixedBy α g`, then `g +ᵥ s = s`, which means that `s ∈ fixedBy (Set α) g`.

Note that the reverse implication is in general not true, as `s ∈ fixedBy (Set α) g` is a
weaker statement (it allows for points `x ∈ s` for which `g +ᵥ x ≠ x` and `g +ᵥ x ∈ s`)."]
theorem set_mem_fixedBy_of_subset_fixedBy {s : Set α} {g : G} (s_ss_fixedBy : s ⊆ fixedBy α g) :
    s ∈ fixedBy (Set α) g 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] [MulAction G α] {s : Set α} {g : G} (s_ss_fixedBy : s ⊆ MulAction.fixedBy α g)
Goal: s ∈ MulAction.fixedBy (Set α) g
-- AddAction.set_mem_fixedBy_of_subset_fixedBy
@[to_additive "If `s ⊆ fixedBy α g`, then `g +ᵥ s = s`, which means that `s ∈ fixedBy (Set α) g`.

Note that the reverse implication is in general not true, as `s ∈ fixedBy (Set α) g` is a
weaker statement (it allows for points `x ∈ s` for which `g +ᵥ x ≠ x` and `g +ᵥ x ∈ s`)."]
theorem set_mem_fixedBy_of_subset_fixedBy {s : Set α} {g : G} (s_ss_fixedBy : s ⊆ fixedBy α g) :
    s ∈ fixedBy (Set α) g 
Arguments: {α : Type u_1} {G : Type u_2} [AddGroup G] [AddAction G α] {s : Set α} {g : G} (s_ss_fixedBy : s ⊆ AddAction.fixedBy α g)
Goal: s ∈ AddAction.fixedBy (Set α) g
-- MulAction.smul_subset_of_set_mem_fixedBy
theorem smul_subset_of_set_mem_fixedBy {s t : Set α} {g : G} (t_ss_s : t ⊆ s)
    (s_in_fixedBy : s ∈ fixedBy (Set α) g) : g • t ⊆ s 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] [MulAction G α] {s t : Set α} {g : G} (t_ss_s : t ⊆ s) (s_in_fixedBy : s ∈ MulAction.fixedBy (Set α) g)
Goal: g • t ⊆ s
-- MulAction.set_mem_fixedBy_of_movedBy_subset
@[to_additive "If `(fixedBy α g)ᶜ ⊆ s`, then `g` cannot move a point of `s` outside of `s`."]
theorem set_mem_fixedBy_of_movedBy_subset {s : Set α} {g : G} (s_subset : (fixedBy α g)ᶜ ⊆ s) :
    s ∈ fixedBy (Set α) g 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] [MulAction G α] {s : Set α} {g : G} (s_subset : (MulAction.fixedBy α g)ᶜ ⊆ s)
Goal: s ∈ MulAction.fixedBy (Set α) g
-- AddAction.set_mem_fixedBy_of_movedBy_subset
@[to_additive "If `(fixedBy α g)ᶜ ⊆ s`, then `g` cannot move a point of `s` outside of `s`."]
theorem set_mem_fixedBy_of_movedBy_subset {s : Set α} {g : G} (s_subset : (fixedBy α g)ᶜ ⊆ s) :
    s ∈ fixedBy (Set α) g 
Arguments: {α : Type u_1} {G : Type u_2} [AddGroup G] [AddAction G α] {s : Set α} {g : G} (s_subset : (AddAction.fixedBy α g)ᶜ ⊆ s)
Goal: s ∈ AddAction.fixedBy (Set α) g
-- AddAction.fixedBy_mem_fixedBy_of_addCommute
@[to_additive "If `g` and `h` commute, then `g` fixes `h +ᵥ x` iff `g` fixes `x`.
This is equivalent to say that the set `fixedBy α g` is fixed by `h`.
"]
theorem fixedBy_mem_fixedBy_of_commute {g h : G} (comm : Commute g h) :
    (fixedBy α g) ∈ fixedBy (Set α) h 
Arguments: {α : Type u_1} {G : Type u_2} [AddGroup G] [AddAction G α] {g h : G} (comm : AddCommute g h)
Goal: AddAction.fixedBy α g ∈ AddAction.fixedBy (Set α) h
-- MulAction.fixedBy_mem_fixedBy_of_commute
@[to_additive "If `g` and `h` commute, then `g` fixes `h +ᵥ x` iff `g` fixes `x`.
This is equivalent to say that the set `fixedBy α g` is fixed by `h`.
"]
theorem fixedBy_mem_fixedBy_of_commute {g h : G} (comm : Commute g h) :
    (fixedBy α g) ∈ fixedBy (Set α) h 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] [MulAction G α] {g h : G} (comm : Commute g h)
Goal: MulAction.fixedBy α g ∈ MulAction.fixedBy (Set α) h
-- AddAction.vadd_zsmul_fixedBy_eq_of_addCommute
@[to_additive "If `g` and `h` commute, then `g` fixes `(j • h) +ᵥ x` iff `g` fixes `x`."]
theorem smul_zpow_fixedBy_eq_of_commute {g h : G} (comm : Commute g h) (j : ℤ) :
    h ^ j • fixedBy α g = fixedBy α g 
Arguments: {α : Type u_1} {G : Type u_2} [AddGroup G] [AddAction G α] {g h : G} (comm : AddCommute g h) (j : ℤ)
Goal: j • h +ᵥ AddAction.fixedBy α g = AddAction.fixedBy α g
-- MulAction.smul_zpow_fixedBy_eq_of_commute
@[to_additive "If `g` and `h` commute, then `g` fixes `(j • h) +ᵥ x` iff `g` fixes `x`."]
theorem smul_zpow_fixedBy_eq_of_commute {g h : G} (comm : Commute g h) (j : ℤ) :
    h ^ j • fixedBy α g = fixedBy α g 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] [MulAction G α] {g h : G} (comm : Commute g h) (j : ℤ)
Goal: h ^ j • MulAction.fixedBy α g = MulAction.fixedBy α g
-- AddAction.movedBy_mem_fixedBy_of_addCommute
@[to_additive "If `g` and `h` commute, then `g` moves `h +ᵥ x` iff `g` moves `x`.
This is equivalent to say that the set `(fixedBy α g)ᶜ` is fixed by `h`."]
theorem movedBy_mem_fixedBy_of_commute {g h : G} (comm : Commute g h) :
    (fixedBy α g)ᶜ ∈ fixedBy (Set α) h 
Arguments: {α : Type u_1} {G : Type u_2} [AddGroup G] [AddAction G α] {g h : G} (comm : AddCommute g h)
Goal: (AddAction.fixedBy α g)ᶜ ∈ AddAction.fixedBy (Set α) h
-- MulAction.movedBy_mem_fixedBy_of_commute
@[to_additive "If `g` and `h` commute, then `g` moves `h +ᵥ x` iff `g` moves `x`.
This is equivalent to say that the set `(fixedBy α g)ᶜ` is fixed by `h`."]
theorem movedBy_mem_fixedBy_of_commute {g h : G} (comm : Commute g h) :
    (fixedBy α g)ᶜ ∈ fixedBy (Set α) h 
Arguments: {α : Type u_1} {G : Type u_2} [Group G] [MulAction G α] {g h : G} (comm : Commute g h)
Goal: (MulAction.fixedBy α g)ᶜ ∈ MulAction.fixedBy (Set α) h