File: Mathlib/GroupTheory/GroupAction/Basic.lean

full_name: AddAction.orbit
code: /-- The orbit of an element under an action. -/
@[to_additive "The orbit of an element under an action."]
def orbit (a : α) 
goal: Set α

full_name: MulAction.orbit
code: /-- The orbit of an element under an action. -/
@[to_additive "The orbit of an element under an action."]
def orbit (a : α) 
goal: Set α

full_name: AddAction.mem_orbit_iff
code: @[to_additive]
theorem mem_orbit_iff {a₁ a₂ : α} : a₂ ∈ orbit M a₁ ↔ ∃ x : M, x • a₁ = a₂ 
goal: a₂ ∈ AddAction.orbit M a₁ ↔ ∃ x, x +ᵥ a₁ = a₂

full_name: MulAction.mem_orbit_iff
code: @[to_additive]
theorem mem_orbit_iff {a₁ a₂ : α} : a₂ ∈ orbit M a₁ ↔ ∃ x : M, x • a₁ = a₂ 
goal: a₂ ∈ MulAction.orbit M a₁ ↔ ∃ x, x • a₁ = a₂

full_name: MulAction.mem_orbit
code: @[to_additive (attr := simp)]
theorem mem_orbit (a : α) (m : M) : m • a ∈ orbit M a 
goal: m • a ∈ MulAction.orbit M a

full_name: AddAction.mem_orbit
code: @[to_additive (attr := simp)]
theorem mem_orbit (a : α) (m : M) : m • a ∈ orbit M a 
goal: m +ᵥ a ∈ AddAction.orbit M a

full_name: MulAction.mem_orbit_self
code: @[to_additive (attr := simp)]
theorem mem_orbit_self (a : α) : a ∈ orbit M a 
goal: a ∈ MulAction.orbit M a

full_name: AddAction.mem_orbit_self
code: @[to_additive (attr := simp)]
theorem mem_orbit_self (a : α) : a ∈ orbit M a 
goal: a ∈ AddAction.orbit M a

full_name: AddAction.orbit_nonempty
code: @[to_additive]
theorem orbit_nonempty (a : α) : Set.Nonempty (orbit M a) 
goal: (AddAction.orbit M a).Nonempty

full_name: MulAction.orbit_nonempty
code: @[to_additive]
theorem orbit_nonempty (a : α) : Set.Nonempty (orbit M a) 
goal: (MulAction.orbit M a).Nonempty

full_name: MulAction.mapsTo_smul_orbit
code: @[to_additive]
theorem mapsTo_smul_orbit (m : M) (a : α) : Set.MapsTo (m • ·) (orbit M a) (orbit M a) 
goal: Set.MapsTo (fun x => m • x) (MulAction.orbit M a) (MulAction.orbit M a)

full_name: AddAction.mapsTo_vadd_orbit
code: @[to_additive]
theorem mapsTo_smul_orbit (m : M) (a : α) : Set.MapsTo (m • ·) (orbit M a) (orbit M a) 
goal: Set.MapsTo (fun x => m +ᵥ x) (AddAction.orbit M a) (AddAction.orbit M a)

full_name: MulAction.smul_orbit_subset
code: @[to_additive]
theorem smul_orbit_subset (m : M) (a : α) : m • orbit M a ⊆ orbit M a 
goal: m • MulAction.orbit M a ⊆ MulAction.orbit M a

full_name: AddAction.vadd_orbit_subset
code: @[to_additive]
theorem smul_orbit_subset (m : M) (a : α) : m • orbit M a ⊆ orbit M a 
goal: m +ᵥ AddAction.orbit M a ⊆ AddAction.orbit M a

full_name: AddAction.orbit_vadd_subset
code: @[to_additive]
theorem orbit_smul_subset (m : M) (a : α) : orbit M (m • a) ⊆ orbit M a 
goal: AddAction.orbit M (m +ᵥ a) ⊆ AddAction.orbit M a

full_name: MulAction.orbit_smul_subset
code: @[to_additive]
theorem orbit_smul_subset (m : M) (a : α) : orbit M (m • a) ⊆ orbit M a 
goal: MulAction.orbit M (m • a) ⊆ MulAction.orbit M a

full_name: AddAction.instElemOrbit
code: @[to_additive]
instance {a : α} : MulAction M (orbit M a) 
goal: AddAction M ↑(AddAction.orbit M a)

full_name: MulAction.instElemOrbit
code: @[to_additive]
instance {a : α} : MulAction M (orbit M a) 
goal: MulAction M ↑(MulAction.orbit M a)

full_name: AddAction.orbit.coe_vadd
code: @[to_additive (attr := simp)]
theorem orbit.coe_smul {a : α} {m : M} {a' : orbit M a} : ↑(m • a') = m • (a' : α) 
goal: ↑(m +ᵥ a') = m +ᵥ ↑a'

full_name: MulAction.orbit.coe_smul
code: @[to_additive (attr := simp)]
theorem orbit.coe_smul {a : α} {m : M} {a' : orbit M a} : ↑(m • a') = m • (a' : α) 
goal: ↑(m • a') = m • ↑a'

full_name: AddAction.orbit_addSubmonoid_subset
code: @[to_additive]
lemma orbit_submonoid_subset (S : Submonoid M) (a : α) : orbit S a ⊆ orbit M a 
goal: AddAction.orbit (↥S) a ⊆ AddAction.orbit M a

full_name: MulAction.orbit_submonoid_subset
code: @[to_additive]
lemma orbit_submonoid_subset (S : Submonoid M) (a : α) : orbit S a ⊆ orbit M a 
goal: MulAction.orbit (↥S) a ⊆ MulAction.orbit M a

full_name: MulAction.mem_orbit_of_mem_orbit_submonoid
code: @[to_additive]
lemma mem_orbit_of_mem_orbit_submonoid {S : Submonoid M} {a b : α} (h : a ∈ orbit S b) :
    a ∈ orbit M b 
goal: a ∈ MulAction.orbit M b

full_name: AddAction.mem_orbit_of_mem_orbit_addSubmonoid
code: @[to_additive]
lemma mem_orbit_of_mem_orbit_submonoid {S : Submonoid M} {a b : α} (h : a ∈ orbit S b) :
    a ∈ orbit M b 
goal: a ∈ AddAction.orbit M b

full_name: MulAction.fst_mem_orbit_of_mem_orbit
code: @[to_additive]
lemma fst_mem_orbit_of_mem_orbit {x y : α × β} (h : x ∈ MulAction.orbit M y) :
    x.1 ∈ MulAction.orbit M y.1 
goal: x.1 ∈ MulAction.orbit M y.1

full_name: AddAction.fst_mem_orbit_of_mem_orbit
code: @[to_additive]
lemma fst_mem_orbit_of_mem_orbit {x y : α × β} (h : x ∈ MulAction.orbit M y) :
    x.1 ∈ MulAction.orbit M y.1 
goal: x.1 ∈ AddAction.orbit M y.1

full_name: AddAction.snd_mem_orbit_of_mem_orbit
code: @[to_additive]
lemma snd_mem_orbit_of_mem_orbit {x y : α × β} (h : x ∈ MulAction.orbit M y) :
    x.2 ∈ MulAction.orbit M y.2 
goal: x.2 ∈ AddAction.orbit M y.2

full_name: MulAction.snd_mem_orbit_of_mem_orbit
code: @[to_additive]
lemma snd_mem_orbit_of_mem_orbit {x y : α × β} (h : x ∈ MulAction.orbit M y) :
    x.2 ∈ MulAction.orbit M y.2 
goal: x.2 ∈ MulAction.orbit M y.2

full_name: AddAction.orbit_eq_univ
code: @[to_additive]
theorem orbit_eq_univ [IsPretransitive M α] (a : α) : orbit M a = Set.univ 
goal: AddAction.orbit M a = Set.univ

full_name: MulAction.orbit_eq_univ
code: @[to_additive]
theorem orbit_eq_univ [IsPretransitive M α] (a : α) : orbit M a = Set.univ 
goal: MulAction.orbit M a = Set.univ

full_name: AddAction.fixedPoints
code: /-- The set of elements fixed under the whole action. -/
@[to_additive "The set of elements fixed under the whole action."]
def fixedPoints : Set α 
goal: Set α

full_name: MulAction.fixedPoints
code: /-- The set of elements fixed under the whole action. -/
@[to_additive "The set of elements fixed under the whole action."]
def fixedPoints : Set α 
goal: Set α

full_name: AddAction.fixedBy
code: /-- `fixedBy m` is the set of elements fixed by `m`. -/
@[to_additive "`fixedBy m` is the set of elements fixed by `m`."]
def fixedBy (m : M) : Set α 
goal: Set α

full_name: MulAction.fixedBy
code: /-- `fixedBy m` is the set of elements fixed by `m`. -/
@[to_additive "`fixedBy m` is the set of elements fixed by `m`."]
def fixedBy (m : M) : Set α 
goal: Set α

full_name: MulAction.fixed_eq_iInter_fixedBy
code: @[to_additive]
theorem fixed_eq_iInter_fixedBy : fixedPoints M α = ⋂ m : M, fixedBy α m 
goal: MulAction.fixedPoints M α = ⋂ m, MulAction.fixedBy α m

full_name: AddAction.fixed_eq_iInter_fixedBy
code: @[to_additive]
theorem fixed_eq_iInter_fixedBy : fixedPoints M α = ⋂ m : M, fixedBy α m 
goal: AddAction.fixedPoints M α = ⋂ m, AddAction.fixedBy α m

full_name: MulAction.mem_fixedPoints
code: @[to_additive (attr := simp)]
theorem mem_fixedPoints {a : α} : a ∈ fixedPoints M α ↔ ∀ m : M, m • a = a 
goal: a ∈ MulAction.fixedPoints M α ↔ ∀ (m : M), m • a = a

full_name: AddAction.mem_fixedPoints
code: @[to_additive (attr := simp)]
theorem mem_fixedPoints {a : α} : a ∈ fixedPoints M α ↔ ∀ m : M, m • a = a 
goal: a ∈ AddAction.fixedPoints M α ↔ ∀ (m : M), m +ᵥ a = a

full_name: MulAction.mem_fixedBy
code: @[to_additive (attr := simp)]
theorem mem_fixedBy {m : M} {a : α} : a ∈ fixedBy α m ↔ m • a = a 
goal: a ∈ MulAction.fixedBy α m ↔ m • a = a

full_name: AddAction.mem_fixedBy
code: @[to_additive (attr := simp)]
theorem mem_fixedBy {m : M} {a : α} : a ∈ fixedBy α m ↔ m • a = a 
goal: a ∈ AddAction.fixedBy α m ↔ m +ᵥ a = a

full_name: AddAction.mem_fixedPoints'
code: @[to_additive]
theorem mem_fixedPoints' {a : α} : a ∈ fixedPoints M α ↔ ∀ a', a' ∈ orbit M a → a' = a 
goal: a ∈ AddAction.fixedPoints M α ↔ ∀ a' ∈ AddAction.orbit M a, a' = a

full_name: MulAction.mem_fixedPoints'
code: @[to_additive]
theorem mem_fixedPoints' {a : α} : a ∈ fixedPoints M α ↔ ∀ a', a' ∈ orbit M a → a' = a 
goal: a ∈ MulAction.fixedPoints M α ↔ ∀ a' ∈ MulAction.orbit M a, a' = a

full_name: MulAction.mem_fixedPoints_iff_card_orbit_eq_one
code: @[to_additive mem_fixedPoints_iff_card_orbit_eq_one]
theorem mem_fixedPoints_iff_card_orbit_eq_one {a : α} [Fintype (orbit M a)] :
    a ∈ fixedPoints M α ↔ Fintype.card (orbit M a) = 1 
goal: a ∈ MulAction.fixedPoints M α ↔ Fintype.card ↑(MulAction.orbit M a) = 1

full_name: AddAction.mem_fixedPoints_iff_card_orbit_eq_one
code: @[to_additive mem_fixedPoints_iff_card_orbit_eq_one]
theorem mem_fixedPoints_iff_card_orbit_eq_one {a : α} [Fintype (orbit M a)] :
    a ∈ fixedPoints M α ↔ Fintype.card (orbit M a) = 1 
goal: a ∈ AddAction.fixedPoints M α ↔ Fintype.card ↑(AddAction.orbit M a) = 1

full_name: MulAction.stabilizerSubmonoid
code: /-- The stabilizer of a point `a` as a submonoid of `M`. -/
@[to_additive "The stabilizer of a point `a` as an additive submonoid of `M`."]
def stabilizerSubmonoid (a : α) : Submonoid M 
goal: Submonoid M

full_name: AddAction.stabilizerAddSubmonoid
code: /-- The stabilizer of a point `a` as a submonoid of `M`. -/
@[to_additive "The stabilizer of a point `a` as an additive submonoid of `M`."]
def stabilizerSubmonoid (a : α) : Submonoid M 
goal: AddSubmonoid M

full_name: AddAction.instDecidablePredMemAddSubmonoidStabilizerAddSubmonoidOfDecidableEq
code: @[to_additive]
instance [DecidableEq α] (a : α) : DecidablePred (· ∈ stabilizerSubmonoid M a) 
goal: DecidablePred fun x => x ∈ AddAction.stabilizerAddSubmonoid M a

full_name: MulAction.instDecidablePredMemSubmonoidStabilizerSubmonoidOfDecidableEq
code: @[to_additive]
instance [DecidableEq α] (a : α) : DecidablePred (· ∈ stabilizerSubmonoid M a) 
goal: DecidablePred fun x => x ∈ MulAction.stabilizerSubmonoid M a

full_name: MulAction.mem_stabilizerSubmonoid_iff
code: @[to_additive (attr := simp)]
theorem mem_stabilizerSubmonoid_iff {a : α} {m : M} : m ∈ stabilizerSubmonoid M a ↔ m • a = a 
goal: m ∈ MulAction.stabilizerSubmonoid M a ↔ m • a = a

full_name: AddAction.mem_stabilizerAddSubmonoid_iff
code: @[to_additive (attr := simp)]
theorem mem_stabilizerSubmonoid_iff {a : α} {m : M} : m ∈ stabilizerSubmonoid M a ↔ m • a = a 
goal: m ∈ AddAction.stabilizerAddSubmonoid M a ↔ m +ᵥ a = a

full_name: FixedPoints.submonoid
code: /-- The submonoid of elements fixed under the whole action. -/
def FixedPoints.submonoid : Submonoid α 
goal: Submonoid α

full_name: FixedPoints.mem_submonoid
code: @[simp]
lemma FixedPoints.mem_submonoid (a : α) : a ∈ submonoid M α ↔ ∀ m : M, m • a = a 
goal: a ∈ FixedPoints.submonoid M α ↔ ∀ (m : M), m • a = a

full_name: FixedPoints.subgroup
code: /-- The subgroup of elements fixed under the whole action. -/
def subgroup : Subgroup α 
goal: Subgroup α

full_name: FixedPoints.«_aux_Mathlib_GroupTheory_GroupAction_Basic___macroRules_FixedPoints_term_^*__1»
code: /-- The notation for `FixedPoints.subgroup`, chosen to resemble `αᴹ`. -/
scoped notation α "^*" M:51 => FixedPoints.subgroup M α
goal: Lean.Macro

full_name: FixedPoints._aux_Mathlib_GroupTheory_GroupAction_Basic___unexpand_FixedPoints_subgroup_1
code: /-- The notation for `FixedPoints.subgroup`, chosen to resemble `αᴹ`. -/
scoped notation α "^*" M:51 => FixedPoints.subgroup M α
goal: Lean.PrettyPrinter.Unexpander

full_name: FixedPoints.mem_subgroup
code: @[simp]
lemma mem_subgroup (a : α) : a ∈ α^*M ↔ ∀ m : M, m • a = a 
goal: a ∈ FixedPoints.subgroup M α ↔ ∀ (m : M), m • a = a

full_name: FixedPoints.subgroup_toSubmonoid
code: @[simp]
lemma subgroup_toSubmonoid : (α^*M).toSubmonoid = submonoid M α 
goal: (FixedPoints.subgroup M α).toSubmonoid = FixedPoints.submonoid M α

full_name: FixedPoints.addSubmonoid
code: /-- The additive submonoid of elements fixed under the whole action. -/
def FixedPoints.addSubmonoid : AddSubmonoid α 
goal: AddSubmonoid α

full_name: FixedPoints.mem_addSubmonoid
code: @[simp]
lemma FixedPoints.mem_addSubmonoid (a : α) : a ∈ addSubmonoid M α ↔ ∀ m : M, m • a = a 
goal: a ∈ FixedPoints.addSubmonoid M α ↔ ∀ (m : M), m • a = a

full_name: FixedPoints.addSubgroup
code: /-- The additive subgroup of elements fixed under the whole action. -/
def FixedPoints.addSubgroup : AddSubgroup α 
goal: AddSubgroup α

full_name: «_aux_Mathlib_GroupTheory_GroupAction_Basic___macroRules_term_^+__1»
code: /-- The notation for `FixedPoints.addSubgroup`, chosen to resemble `αᴹ`. -/
notation α "^+" M:51 => FixedPoints.addSubgroup M α
goal: Lean.Macro

full_name: _aux_Mathlib_GroupTheory_GroupAction_Basic___unexpand_FixedPoints_addSubgroup_1
code: /-- The notation for `FixedPoints.addSubgroup`, chosen to resemble `αᴹ`. -/
notation α "^+" M:51 => FixedPoints.addSubgroup M α
goal: Lean.PrettyPrinter.Unexpander

full_name: FixedPoints.mem_addSubgroup
code: @[simp]
lemma FixedPoints.mem_addSubgroup (a : α) : a ∈ α^+M ↔ ∀ m : M, m • a = a 
goal: a ∈ α^+M ↔ ∀ (m : M), m • a = a

full_name: FixedPoints.addSubgroup_toAddSubmonoid
code: @[simp]
lemma FixedPoints.addSubgroup_toAddSubmonoid : (α^+M).toAddSubmonoid = addSubmonoid M α 
goal: (α^+M).toAddSubmonoid = FixedPoints.addSubmonoid M α

full_name: smul_cancel_of_non_zero_divisor
code: /-- `smul` by a `k : M` over a ring is injective, if `k` is not a zero divisor.
The general theory of such `k` is elaborated by `IsSMulRegular`.
The typeclass that restricts all terms of `M` to have this property is `NoZeroSMulDivisors`. -/
theorem smul_cancel_of_non_zero_divisor {M R : Type*} [Monoid M] [NonUnitalNonAssocRing R]
    [DistribMulAction M R] (k : M) (h : ∀ x : R, k • x = 0 → x = 0) {a b : R} (h' : k • a = k • b) :
    a = b 
goal: a = b

full_name: MulAction.smul_orbit
code: @[to_additive (attr := simp)]
theorem smul_orbit (g : G) (a : α) : g • orbit G a = orbit G a 
goal: g • MulAction.orbit G a = MulAction.orbit G a

full_name: AddAction.vadd_orbit
code: @[to_additive (attr := simp)]
theorem smul_orbit (g : G) (a : α) : g • orbit G a = orbit G a 
goal: g +ᵥ AddAction.orbit G a = AddAction.orbit G a

full_name: AddAction.orbit_vadd
code: @[to_additive (attr := simp)]
theorem orbit_smul (g : G) (a : α) : orbit G (g • a) = orbit G a 
goal: AddAction.orbit G (g +ᵥ a) = AddAction.orbit G a

full_name: MulAction.orbit_smul
code: @[to_additive (attr := simp)]
theorem orbit_smul (g : G) (a : α) : orbit G (g • a) = orbit G a 
goal: MulAction.orbit G (g • a) = MulAction.orbit G a

full_name: AddAction.instIsPretransitiveElemOrbit
code: /-- The action of a group on an orbit is transitive. -/
@[to_additive "The action of an additive group on an orbit is transitive."]
instance (a : α) : IsPretransitive G (orbit G a) 
goal: AddAction.IsPretransitive G ↑(AddAction.orbit G a)

full_name: MulAction.instIsPretransitiveElemOrbit
code: /-- The action of a group on an orbit is transitive. -/
@[to_additive "The action of an additive group on an orbit is transitive."]
instance (a : α) : IsPretransitive G (orbit G a) 
goal: MulAction.IsPretransitive G ↑(MulAction.orbit G a)

full_name: AddAction.orbit_eq_iff
code: @[to_additive]
theorem orbit_eq_iff {a b : α} : orbit G a = orbit G b ↔ a ∈ orbit G b 
goal: AddAction.orbit G a = AddAction.orbit G b ↔ a ∈ AddAction.orbit G b

full_name: MulAction.orbit_eq_iff
code: @[to_additive]
theorem orbit_eq_iff {a b : α} : orbit G a = orbit G b ↔ a ∈ orbit G b 
goal: MulAction.orbit G a = MulAction.orbit G b ↔ a ∈ MulAction.orbit G b

full_name: AddAction.mem_orbit_vadd
code: @[to_additive]
theorem mem_orbit_smul (g : G) (a : α) : a ∈ orbit G (g • a) 
goal: a ∈ AddAction.orbit G (g +ᵥ a)

full_name: MulAction.mem_orbit_smul
code: @[to_additive]
theorem mem_orbit_smul (g : G) (a : α) : a ∈ orbit G (g • a) 
goal: a ∈ MulAction.orbit G (g • a)

full_name: MulAction.smul_mem_orbit_smul
code: @[to_additive]
theorem smul_mem_orbit_smul (g h : G) (a : α) : g • a ∈ orbit G (h • a) 
goal: g • a ∈ MulAction.orbit G (h • a)

full_name: AddAction.vadd_mem_orbit_vadd
code: @[to_additive]
theorem smul_mem_orbit_smul (g h : G) (a : α) : g • a ∈ orbit G (h • a) 
goal: g +ᵥ a ∈ AddAction.orbit G (h +ᵥ a)

full_name: AddAction.orbit_addSubgroup_subset
code: @[to_additive]
lemma orbit_subgroup_subset (H : Subgroup G) (a : α) : orbit H a ⊆ orbit G a 
goal: AddAction.orbit (↥H) a ⊆ AddAction.orbit G a

full_name: MulAction.orbit_subgroup_subset
code: @[to_additive]
lemma orbit_subgroup_subset (H : Subgroup G) (a : α) : orbit H a ⊆ orbit G a 
goal: MulAction.orbit (↥H) a ⊆ MulAction.orbit G a

full_name: AddAction.mem_orbit_of_mem_orbit_addSubgroup
code: @[to_additive]
lemma mem_orbit_of_mem_orbit_subgroup {H : Subgroup G} {a b : α} (h : a ∈ orbit H b) :
    a ∈ orbit G b 
goal: a ∈ AddAction.orbit G b

full_name: MulAction.mem_orbit_of_mem_orbit_subgroup
code: @[to_additive]
lemma mem_orbit_of_mem_orbit_subgroup {H : Subgroup G} {a b : α} (h : a ∈ orbit H b) :
    a ∈ orbit G b 
goal: a ∈ MulAction.orbit G b

full_name: MulAction.mem_orbit_symm
code: @[to_additive]
lemma mem_orbit_symm {a₁ a₂ : α} : a₁ ∈ orbit G a₂ ↔ a₂ ∈ orbit G a₁ 
goal: a₁ ∈ MulAction.orbit G a₂ ↔ a₂ ∈ MulAction.orbit G a₁

full_name: AddAction.mem_orbit_symm
code: @[to_additive]
lemma mem_orbit_symm {a₁ a₂ : α} : a₁ ∈ orbit G a₂ ↔ a₂ ∈ orbit G a₁ 
goal: a₁ ∈ AddAction.orbit G a₂ ↔ a₂ ∈ AddAction.orbit G a₁

full_name: AddAction.mem_addSubgroup_orbit_iff
code: @[to_additive]
lemma mem_subgroup_orbit_iff {H : Subgroup G} {x : α} {a b : orbit G x} :
    a ∈ MulAction.orbit H b ↔ (a : α) ∈ MulAction.orbit H (b : α) 
goal: a ∈ AddAction.orbit (↥H) b ↔ ↑a ∈ AddAction.orbit ↥H ↑b

full_name: MulAction.mem_subgroup_orbit_iff
code: @[to_additive]
lemma mem_subgroup_orbit_iff {H : Subgroup G} {x : α} {a b : orbit G x} :
    a ∈ MulAction.orbit H b ↔ (a : α) ∈ MulAction.orbit H (b : α) 
goal: a ∈ MulAction.orbit (↥H) b ↔ ↑a ∈ MulAction.orbit ↥H ↑b

full_name: AddAction.orbitRel
code: /-- The relation 'in the same orbit'. -/
@[to_additive "The relation 'in the same orbit'."]
def orbitRel : Setoid α 
goal: Setoid α

full_name: MulAction.orbitRel
code: /-- The relation 'in the same orbit'. -/
@[to_additive "The relation 'in the same orbit'."]
def orbitRel : Setoid α 
goal: Setoid α

full_name: AddAction.orbitRel_apply
code: @[to_additive]
theorem orbitRel_apply {a b : α} : (orbitRel G α).Rel a b ↔ a ∈ orbit G b 
goal: (AddAction.orbitRel G α).Rel a b ↔ a ∈ AddAction.orbit G b

full_name: MulAction.orbitRel_apply
code: @[to_additive]
theorem orbitRel_apply {a b : α} : (orbitRel G α).Rel a b ↔ a ∈ orbit G b 
goal: (MulAction.orbitRel G α).Rel a b ↔ a ∈ MulAction.orbit G b

full_name: MulAction.orbitRel_r_apply
code: @[to_additive]
lemma orbitRel_r_apply {a b : α} : (orbitRel G _).r a b ↔ a ∈ orbit G b 
goal: Setoid.r a b ↔ a ∈ MulAction.orbit G b

full_name: AddAction.orbitRel_r_apply
code: @[to_additive]
lemma orbitRel_r_apply {a b : α} : (orbitRel G _).r a b ↔ a ∈ orbit G b 
goal: Setoid.r a b ↔ a ∈ AddAction.orbit G b

full_name: MulAction.orbitRel_subgroup_le
code: @[to_additive]
lemma orbitRel_subgroup_le (H : Subgroup G) : orbitRel H α ≤ orbitRel G α 
goal: MulAction.orbitRel (↥H) α ≤ MulAction.orbitRel G α

full_name: AddAction.orbitRel_addSubgroup_le
code: @[to_additive]
lemma orbitRel_subgroup_le (H : Subgroup G) : orbitRel H α ≤ orbitRel G α 
goal: AddAction.orbitRel (↥H) α ≤ AddAction.orbitRel G α

full_name: AddAction.quotient_preimage_image_eq_union_add
code: /-- When you take a set `U` in `α`, push it down to the quotient, and pull back, you get the union
of the orbit of `U` under `G`. -/
@[to_additive
      "When you take a set `U` in `α`, push it down to the quotient, and pull back, you get the
      union of the orbit of `U` under `G`."]
theorem quotient_preimage_image_eq_union_mul (U : Set α) :
    letI := orbitRel G α
    Quotient.mk' ⁻¹' (Quotient.mk' '' U) = ⋃ g : G, (g • ·) '' U 
goal: Quotient.mk' ⁻¹' (Quotient.mk' '' U) = ⋃ g, (fun x => g +ᵥ x) '' U

full_name: MulAction.quotient_preimage_image_eq_union_mul
code: /-- When you take a set `U` in `α`, push it down to the quotient, and pull back, you get the union
of the orbit of `U` under `G`. -/
@[to_additive
      "When you take a set `U` in `α`, push it down to the quotient, and pull back, you get the
      union of the orbit of `U` under `G`."]
theorem quotient_preimage_image_eq_union_mul (U : Set α) :
    letI := orbitRel G α
    Quotient.mk' ⁻¹' (Quotient.mk' '' U) = ⋃ g : G, (g • ·) '' U 
goal: Quotient.mk' ⁻¹' (Quotient.mk' '' U) = ⋃ g, (fun x => g • x) '' U

full_name: MulAction.disjoint_image_image_iff
code: @[to_additive]
theorem disjoint_image_image_iff {U V : Set α} :
    letI := orbitRel G α
    Disjoint (Quotient.mk' '' U) (Quotient.mk' '' V) ↔ ∀ x ∈ U, ∀ g : G, g • x ∉ V 
goal: Disjoint (Quotient.mk' '' U) (Quotient.mk' '' V) ↔ ∀ x ∈ U, ∀ (g : G), g • x ∉ V

full_name: AddAction.disjoint_image_image_iff
code: @[to_additive]
theorem disjoint_image_image_iff {U V : Set α} :
    letI := orbitRel G α
    Disjoint (Quotient.mk' '' U) (Quotient.mk' '' V) ↔ ∀ x ∈ U, ∀ g : G, g • x ∉ V 
goal: Disjoint (Quotient.mk' '' U) (Quotient.mk' '' V) ↔ ∀ x ∈ U, ∀ (g : G), g +ᵥ x ∉ V

full_name: MulAction.image_inter_image_iff
code: @[to_additive]
theorem image_inter_image_iff (U V : Set α) :
    letI := orbitRel G α
    Quotient.mk' '' U ∩ Quotient.mk' '' V = ∅ ↔ ∀ x ∈ U, ∀ g : G, g • x ∉ V 
goal: Quotient.mk' '' U ∩ Quotient.mk' '' V = ∅ ↔ ∀ x ∈ U, ∀ (g : G), g • x ∉ V

full_name: AddAction.image_inter_image_iff
code: @[to_additive]
theorem image_inter_image_iff (U V : Set α) :
    letI := orbitRel G α
    Quotient.mk' '' U ∩ Quotient.mk' '' V = ∅ ↔ ∀ x ∈ U, ∀ g : G, g • x ∉ V 
goal: Quotient.mk' '' U ∩ Quotient.mk' '' V = ∅ ↔ ∀ x ∈ U, ∀ (g : G), g +ᵥ x ∉ V

full_name: AddAction.orbitRel.Quotient
code: /-- The quotient by `MulAction.orbitRel`, given a name to enable dot notation. -/
@[to_additive (attr := reducible)
    "The quotient by `AddAction.orbitRel`, given a name to enable dot notation."]
def orbitRel.Quotient : Type _ 
goal: Type u_2

full_name: MulAction.orbitRel.Quotient
code: /-- The quotient by `MulAction.orbitRel`, given a name to enable dot notation. -/
@[to_additive (attr := reducible)
    "The quotient by `AddAction.orbitRel`, given a name to enable dot notation."]
def orbitRel.Quotient : Type _ 
goal: Type u_2

full_name: AddAction.pretransitive_iff_subsingleton_quotient
code: /-- An action is pretransitive if and only if the quotient by `MulAction.orbitRel` is a
subsingleton. -/
@[to_additive "An additive action is pretransitive if and only if the quotient by
`AddAction.orbitRel` is a subsingleton."]
theorem pretransitive_iff_subsingleton_quotient :
    IsPretransitive G α ↔ Subsingleton (orbitRel.Quotient G α) 
goal: AddAction.IsPretransitive G α ↔ Subsingleton (AddAction.orbitRel.Quotient G α)

full_name: MulAction.pretransitive_iff_subsingleton_quotient
code: /-- An action is pretransitive if and only if the quotient by `MulAction.orbitRel` is a
subsingleton. -/
@[to_additive "An additive action is pretransitive if and only if the quotient by
`AddAction.orbitRel` is a subsingleton."]
theorem pretransitive_iff_subsingleton_quotient :
    IsPretransitive G α ↔ Subsingleton (orbitRel.Quotient G α) 
goal: MulAction.IsPretransitive G α ↔ Subsingleton (MulAction.orbitRel.Quotient G α)

full_name: MulAction.pretransitive_iff_unique_quotient_of_nonempty
code: /-- If `α` is non-empty, an action is pretransitive if and only if the quotient has exactly one
element. -/
@[to_additive "If `α` is non-empty, an additive action is pretransitive if and only if the
quotient has exactly one element."]
theorem pretransitive_iff_unique_quotient_of_nonempty [Nonempty α] :
    IsPretransitive G α ↔ Nonempty (Unique <| orbitRel.Quotient G α) 
goal: MulAction.IsPretransitive G α ↔ Nonempty (Unique (MulAction.orbitRel.Quotient G α))

full_name: AddAction.pretransitive_iff_unique_quotient_of_nonempty
code: /-- If `α` is non-empty, an action is pretransitive if and only if the quotient has exactly one
element. -/
@[to_additive "If `α` is non-empty, an additive action is pretransitive if and only if the
quotient has exactly one element."]
theorem pretransitive_iff_unique_quotient_of_nonempty [Nonempty α] :
    IsPretransitive G α ↔ Nonempty (Unique <| orbitRel.Quotient G α) 
goal: AddAction.IsPretransitive G α ↔ Nonempty (Unique (AddAction.orbitRel.Quotient G α))

full_name: MulAction.orbitRel.Quotient.orbit
code: /-- The orbit corresponding to an element of the quotient by `MulAction.orbitRel` -/
@[to_additive "The orbit corresponding to an element of the quotient by `AddAction.orbitRel`"]
nonrec def orbitRel.Quotient.orbit (x : orbitRel.Quotient G α) : Set α 
goal: Set α

full_name: AddAction.orbitRel.Quotient.orbit
code: /-- The orbit corresponding to an element of the quotient by `MulAction.orbitRel` -/
@[to_additive "The orbit corresponding to an element of the quotient by `AddAction.orbitRel`"]
nonrec def orbitRel.Quotient.orbit (x : orbitRel.Quotient G α) : Set α 
goal: Set α

full_name: MulAction.orbitRel.Quotient.orbit_mk
code: @[to_additive (attr := simp)]
theorem orbitRel.Quotient.orbit_mk (a : α) :
    orbitRel.Quotient.orbit (Quotient.mk'' a : orbitRel.Quotient G α) = MulAction.orbit G a 
goal: MulAction.orbitRel.Quotient.orbit (Quotient.mk'' a) = MulAction.orbit G a

full_name: AddAction.orbitRel.Quotient.orbit_mk
code: @[to_additive (attr := simp)]
theorem orbitRel.Quotient.orbit_mk (a : α) :
    orbitRel.Quotient.orbit (Quotient.mk'' a : orbitRel.Quotient G α) = MulAction.orbit G a 
goal: AddAction.orbitRel.Quotient.orbit (Quotient.mk'' a) = AddAction.orbit G a

full_name: MulAction.orbitRel.Quotient.mem_orbit
code: @[to_additive]
theorem orbitRel.Quotient.mem_orbit {a : α} {x : orbitRel.Quotient G α} :
    a ∈ x.orbit ↔ Quotient.mk'' a = x 
goal: a ∈ x.orbit ↔ Quotient.mk'' a = x

full_name: AddAction.orbitRel.Quotient.mem_orbit
code: @[to_additive]
theorem orbitRel.Quotient.mem_orbit {a : α} {x : orbitRel.Quotient G α} :
    a ∈ x.orbit ↔ Quotient.mk'' a = x 
goal: a ∈ x.orbit ↔ Quotient.mk'' a = x

full_name: MulAction.orbitRel.Quotient.orbit_eq_orbit_out
code: /-- Note that `hφ = Quotient.out_eq'` is a useful choice here. -/
@[to_additive "Note that `hφ = Quotient.out_eq'` is a useful choice here."]
theorem orbitRel.Quotient.orbit_eq_orbit_out (x : orbitRel.Quotient G α)
    {φ : orbitRel.Quotient G α → α} (hφ : letI := orbitRel G α; RightInverse φ Quotient.mk') :
    orbitRel.Quotient.orbit x = MulAction.orbit G (φ x) 
goal: x.orbit = MulAction.orbit G (φ x)

full_name: AddAction.orbitRel.Quotient.orbit_eq_orbit_out
code: /-- Note that `hφ = Quotient.out_eq'` is a useful choice here. -/
@[to_additive "Note that `hφ = Quotient.out_eq'` is a useful choice here."]
theorem orbitRel.Quotient.orbit_eq_orbit_out (x : orbitRel.Quotient G α)
    {φ : orbitRel.Quotient G α → α} (hφ : letI := orbitRel G α; RightInverse φ Quotient.mk') :
    orbitRel.Quotient.orbit x = MulAction.orbit G (φ x) 
goal: x.orbit = AddAction.orbit G (φ x)

full_name: AddAction.orbitRel.Quotient.orbit_injective
code: @[to_additive]
lemma orbitRel.Quotient.orbit_injective :
    Injective (orbitRel.Quotient.orbit : orbitRel.Quotient G α → Set α) 
goal: Function.Injective AddAction.orbitRel.Quotient.orbit

full_name: MulAction.orbitRel.Quotient.orbit_injective
code: @[to_additive]
lemma orbitRel.Quotient.orbit_injective :
    Injective (orbitRel.Quotient.orbit : orbitRel.Quotient G α → Set α) 
goal: Function.Injective MulAction.orbitRel.Quotient.orbit

full_name: AddAction.orbitRel.Quotient.orbit_inj
code: @[to_additive (attr := simp)]
lemma orbitRel.Quotient.orbit_inj {x y : orbitRel.Quotient G α} : x.orbit = y.orbit ↔ x = y 
goal: x.orbit = y.orbit ↔ x = y

full_name: MulAction.orbitRel.Quotient.orbit_inj
code: @[to_additive (attr := simp)]
lemma orbitRel.Quotient.orbit_inj {x y : orbitRel.Quotient G α} : x.orbit = y.orbit ↔ x = y 
goal: x.orbit = y.orbit ↔ x = y

full_name: AddAction.orbitRel.quotient_eq_of_quotient_addSubgroup_eq
code: @[to_additive]
lemma orbitRel.quotient_eq_of_quotient_subgroup_eq {H : Subgroup G} {a b : α}
    (h : (⟦a⟧ : orbitRel.Quotient H α) = ⟦b⟧) : (⟦a⟧ : orbitRel.Quotient G α) = ⟦b⟧ 
goal: ⟦a⟧ = ⟦b⟧

full_name: MulAction.orbitRel.quotient_eq_of_quotient_subgroup_eq
code: @[to_additive]
lemma orbitRel.quotient_eq_of_quotient_subgroup_eq {H : Subgroup G} {a b : α}
    (h : (⟦a⟧ : orbitRel.Quotient H α) = ⟦b⟧) : (⟦a⟧ : orbitRel.Quotient G α) = ⟦b⟧ 
goal: ⟦a⟧ = ⟦b⟧

full_name: MulAction.orbitRel.quotient_eq_of_quotient_subgroup_eq'
code: @[to_additive]
lemma orbitRel.quotient_eq_of_quotient_subgroup_eq' {H : Subgroup G} {a b : α}
    (h : (Quotient.mk'' a : orbitRel.Quotient H α) = Quotient.mk'' b) :
    (Quotient.mk'' a : orbitRel.Quotient G α) = Quotient.mk'' b 
goal: Quotient.mk'' a = Quotient.mk'' b

full_name: AddAction.orbitRel.quotient_eq_of_quotient_addSubgroup_eq'
code: @[to_additive]
lemma orbitRel.quotient_eq_of_quotient_subgroup_eq' {H : Subgroup G} {a b : α}
    (h : (Quotient.mk'' a : orbitRel.Quotient H α) = Quotient.mk'' b) :
    (Quotient.mk'' a : orbitRel.Quotient G α) = Quotient.mk'' b 
goal: Quotient.mk'' a = Quotient.mk'' b

full_name: AddAction.orbitRel.Quotient.orbit_nonempty
code: @[to_additive]
nonrec lemma orbitRel.Quotient.orbit_nonempty (x : orbitRel.Quotient G α) :
    Set.Nonempty x.orbit 
goal: x.orbit.Nonempty

full_name: MulAction.orbitRel.Quotient.orbit_nonempty
code: @[to_additive]
nonrec lemma orbitRel.Quotient.orbit_nonempty (x : orbitRel.Quotient G α) :
    Set.Nonempty x.orbit 
goal: x.orbit.Nonempty

full_name: MulAction.orbitRel.Quotient.mapsTo_smul_orbit
code: @[to_additive]
nonrec lemma orbitRel.Quotient.mapsTo_smul_orbit (g : G) (x : orbitRel.Quotient G α) :
    Set.MapsTo (g • ·) x.orbit x.orbit 
goal: Set.MapsTo (fun x => g • x) x.orbit x.orbit

full_name: AddAction.orbitRel.Quotient.mapsTo_vadd_orbit
code: @[to_additive]
nonrec lemma orbitRel.Quotient.mapsTo_smul_orbit (g : G) (x : orbitRel.Quotient G α) :
    Set.MapsTo (g • ·) x.orbit x.orbit 
goal: Set.MapsTo (fun x => g +ᵥ x) x.orbit x.orbit

full_name: AddAction.instElemOrbit_1
code: @[to_additive]
instance (x : orbitRel.Quotient G α) : MulAction G x.orbit 
goal: AddAction G ↑x.orbit

full_name: MulAction.instElemOrbit_1
code: @[to_additive]
instance (x : orbitRel.Quotient G α) : MulAction G x.orbit 
goal: MulAction G ↑x.orbit

full_name: MulAction.orbitRel.Quotient.orbit.coe_smul
code: @[to_additive (attr := simp)]
lemma orbitRel.Quotient.orbit.coe_smul {g : G} {x : orbitRel.Quotient G α} {a : x.orbit} :
    ↑(g • a) = g • (a : α) 
goal: ↑(g • a) = g • ↑a

full_name: AddAction.orbitRel.Quotient.orbit.coe_vadd
code: @[to_additive (attr := simp)]
lemma orbitRel.Quotient.orbit.coe_smul {g : G} {x : orbitRel.Quotient G α} {a : x.orbit} :
    ↑(g • a) = g • (a : α) 
goal: ↑(g +ᵥ a) = g +ᵥ ↑a

full_name: AddAction.instIsPretransitiveElemOrbit_1
code: @[to_additive]
instance (x : orbitRel.Quotient G α) : IsPretransitive G x.orbit 
goal: AddAction.IsPretransitive G ↑x.orbit

full_name: MulAction.instIsPretransitiveElemOrbit_1
code: @[to_additive]
instance (x : orbitRel.Quotient G α) : IsPretransitive G x.orbit 
goal: MulAction.IsPretransitive G ↑x.orbit

full_name: AddAction.orbitRel.Quotient.mem_addSubgroup_orbit_iff
code: @[to_additive (attr := norm_cast, simp)]
lemma orbitRel.Quotient.mem_subgroup_orbit_iff {H : Subgroup G} {x : orbitRel.Quotient G α}
    {a b : x.orbit} : (a : α) ∈ MulAction.orbit H (b : α) ↔ a ∈ MulAction.orbit H b 
goal: ↑a ∈ AddAction.orbit ↥H ↑b ↔ a ∈ AddAction.orbit (↥H) b

full_name: MulAction.orbitRel.Quotient.mem_subgroup_orbit_iff
code: @[to_additive (attr := norm_cast, simp)]
lemma orbitRel.Quotient.mem_subgroup_orbit_iff {H : Subgroup G} {x : orbitRel.Quotient G α}
    {a b : x.orbit} : (a : α) ∈ MulAction.orbit H (b : α) ↔ a ∈ MulAction.orbit H b 
goal: ↑a ∈ MulAction.orbit ↥H ↑b ↔ a ∈ MulAction.orbit (↥H) b

full_name: AddAction.orbitRel.Quotient.addSubgroup_quotient_eq_iff
code: @[to_additive]
lemma orbitRel.Quotient.subgroup_quotient_eq_iff {H : Subgroup G} {x : orbitRel.Quotient G α}
    {a b : x.orbit} : (⟦a⟧ : orbitRel.Quotient H x.orbit) = ⟦b⟧ ↔
      (⟦↑a⟧ : orbitRel.Quotient H α) = ⟦↑b⟧ 
goal: ⟦a⟧ = ⟦b⟧ ↔ ⟦↑a⟧ = ⟦↑b⟧

full_name: MulAction.orbitRel.Quotient.subgroup_quotient_eq_iff
code: @[to_additive]
lemma orbitRel.Quotient.subgroup_quotient_eq_iff {H : Subgroup G} {x : orbitRel.Quotient G α}
    {a b : x.orbit} : (⟦a⟧ : orbitRel.Quotient H x.orbit) = ⟦b⟧ ↔
      (⟦↑a⟧ : orbitRel.Quotient H α) = ⟦↑b⟧ 
goal: ⟦a⟧ = ⟦b⟧ ↔ ⟦↑a⟧ = ⟦↑b⟧

full_name: AddAction.orbitRel.Quotient.mem_addSubgroup_orbit_iff'
code: @[to_additive]
lemma orbitRel.Quotient.mem_subgroup_orbit_iff' {H : Subgroup G} {x : orbitRel.Quotient G α}
    {a b : x.orbit} {c : α} (h : (⟦a⟧ : orbitRel.Quotient H x.orbit) = ⟦b⟧) :
    (a : α) ∈ MulAction.orbit H c ↔ (b : α) ∈ MulAction.orbit H c 
goal: ↑a ∈ AddAction.orbit (↥H) c ↔ ↑b ∈ AddAction.orbit (↥H) c

full_name: MulAction.orbitRel.Quotient.mem_subgroup_orbit_iff'
code: @[to_additive]
lemma orbitRel.Quotient.mem_subgroup_orbit_iff' {H : Subgroup G} {x : orbitRel.Quotient G α}
    {a b : x.orbit} {c : α} (h : (⟦a⟧ : orbitRel.Quotient H x.orbit) = ⟦b⟧) :
    (a : α) ∈ MulAction.orbit H c ↔ (b : α) ∈ MulAction.orbit H c 
goal: ↑a ∈ MulAction.orbit (↥H) c ↔ ↑b ∈ MulAction.orbit (↥H) c

full_name: MulAction._aux_Mathlib_GroupTheory_GroupAction_Basic___macroRules_MulAction_termΩ_1
code: local notation "Ω" => orbitRel.Quotient G α
goal: Lean.Macro

full_name: MulAction._aux_Mathlib_GroupTheory_GroupAction_Basic___unexpand_MulAction_orbitRel_Quotient_1
code: local notation "Ω" => orbitRel.Quotient G α
goal: Lean.PrettyPrinter.Unexpander

full_name: MulAction.selfEquivSigmaOrbits'
code: /-- Decomposition of a type `X` as a disjoint union of its orbits under a group action.

This version is expressed in terms of `MulAction.orbitRel.Quotient.orbit` instead of
`MulAction.orbit`, to avoid mentioning `Quotient.out'`. -/
@[to_additive
      "Decomposition of a type `X` as a disjoint union of its orbits under an additive group action.

      This version is expressed in terms of `AddAction.orbitRel.Quotient.orbit` instead of
      `AddAction.orbit`, to avoid mentioning `Quotient.out'`. "]
def selfEquivSigmaOrbits' : α ≃ Σω : Ω, ω.orbit 
goal: α ≃ (ω : MulAction.orbitRel.Quotient G α) × ↑ω.orbit

full_name: AddAction.selfEquivSigmaOrbits'
code: /-- Decomposition of a type `X` as a disjoint union of its orbits under a group action.

This version is expressed in terms of `MulAction.orbitRel.Quotient.orbit` instead of
`MulAction.orbit`, to avoid mentioning `Quotient.out'`. -/
@[to_additive
      "Decomposition of a type `X` as a disjoint union of its orbits under an additive group action.

      This version is expressed in terms of `AddAction.orbitRel.Quotient.orbit` instead of
      `AddAction.orbit`, to avoid mentioning `Quotient.out'`. "]
def selfEquivSigmaOrbits' : α ≃ Σω : Ω, ω.orbit 
goal: α ≃ (ω : AddAction.orbitRel.Quotient G α) × ↑ω.orbit

full_name: AddAction.selfEquivSigmaOrbits
code: /-- Decomposition of a type `X` as a disjoint union of its orbits under a group action. -/
@[to_additive
      "Decomposition of a type `X` as a disjoint union of its orbits under an additive group
      action."]
def selfEquivSigmaOrbits : α ≃ Σω : Ω, orbit G ω.out' 
goal: α ≃ (ω : AddAction.orbitRel.Quotient G α) × ↑(AddAction.orbit G (Quotient.out' ω))

full_name: MulAction.selfEquivSigmaOrbits
code: /-- Decomposition of a type `X` as a disjoint union of its orbits under a group action. -/
@[to_additive
      "Decomposition of a type `X` as a disjoint union of its orbits under an additive group
      action."]
def selfEquivSigmaOrbits : α ≃ Σω : Ω, orbit G ω.out' 
goal: α ≃ (ω : MulAction.orbitRel.Quotient G α) × ↑(MulAction.orbit G (Quotient.out' ω))

full_name: MulAction.orbitRel_le_fst
code: @[to_additive]
lemma orbitRel_le_fst :
    orbitRel G (α × β) ≤ (orbitRel G α).comap Prod.fst 
goal: MulAction.orbitRel G (α × β) ≤ Setoid.comap Prod.fst (MulAction.orbitRel G α)

full_name: AddAction.orbitRel_le_fst
code: @[to_additive]
lemma orbitRel_le_fst :
    orbitRel G (α × β) ≤ (orbitRel G α).comap Prod.fst 
goal: AddAction.orbitRel G (α × β) ≤ Setoid.comap Prod.fst (AddAction.orbitRel G α)

full_name: MulAction.orbitRel_le_snd
code: @[to_additive]
lemma orbitRel_le_snd :
    orbitRel G (α × β) ≤ (orbitRel G β).comap Prod.snd 
goal: MulAction.orbitRel G (α × β) ≤ Setoid.comap Prod.snd (MulAction.orbitRel G β)

full_name: AddAction.orbitRel_le_snd
code: @[to_additive]
lemma orbitRel_le_snd :
    orbitRel G (α × β) ≤ (orbitRel G β).comap Prod.snd 
goal: AddAction.orbitRel G (α × β) ≤ Setoid.comap Prod.snd (AddAction.orbitRel G β)

full_name: MulAction.stabilizer
code: /-- The stabilizer of an element under an action, i.e. what sends the element to itself.
A subgroup. -/
@[to_additive
      "The stabilizer of an element under an action, i.e. what sends the element to itself.
      An additive subgroup."]
def stabilizer (a : α) : Subgroup G 
goal: Subgroup G

full_name: AddAction.stabilizer
code: /-- The stabilizer of an element under an action, i.e. what sends the element to itself.
A subgroup. -/
@[to_additive
      "The stabilizer of an element under an action, i.e. what sends the element to itself.
      An additive subgroup."]
def stabilizer (a : α) : Subgroup G 
goal: AddSubgroup G

full_name: AddAction.instDecidablePredMemAddSubgroupStabilizerOfDecidableEq
code: @[to_additive]
instance [DecidableEq α] (a : α) : DecidablePred (· ∈ stabilizer G a) 
goal: DecidablePred fun x => x ∈ AddAction.stabilizer G a

full_name: MulAction.instDecidablePredMemSubgroupStabilizerOfDecidableEq
code: @[to_additive]
instance [DecidableEq α] (a : α) : DecidablePred (· ∈ stabilizer G a) 
goal: DecidablePred fun x => x ∈ MulAction.stabilizer G a

full_name: MulAction.mem_stabilizer_iff
code: @[to_additive (attr := simp)]
theorem mem_stabilizer_iff {a : α} {g : G} : g ∈ stabilizer G a ↔ g • a = a 
goal: g ∈ MulAction.stabilizer G a ↔ g • a = a

full_name: AddAction.mem_stabilizer_iff
code: @[to_additive (attr := simp)]
theorem mem_stabilizer_iff {a : α} {g : G} : g ∈ stabilizer G a ↔ g • a = a 
goal: g ∈ AddAction.stabilizer G a ↔ g +ᵥ a = a

full_name: AddAction.le_stabilizer_vadd_left
code: @[to_additive]
lemma le_stabilizer_smul_left [SMul α β] [IsScalarTower G α β] (a : α) (b : β) :
    stabilizer G a ≤ stabilizer G (a • b) 
goal: AddAction.stabilizer G a ≤ AddAction.stabilizer G (a +ᵥ b)

full_name: MulAction.le_stabilizer_smul_left
code: @[to_additive]
lemma le_stabilizer_smul_left [SMul α β] [IsScalarTower G α β] (a : α) (b : β) :
    stabilizer G a ≤ stabilizer G (a • b) 
goal: MulAction.stabilizer G a ≤ MulAction.stabilizer G (a • b)

full_name: AddAction.le_stabilizer_vadd_right
code: @[to_additive]
lemma le_stabilizer_smul_right [SMul α β] [SMulCommClass G α β] (a : α) (b : β) :
    stabilizer G b ≤ stabilizer G (a • b) 
goal: AddAction.stabilizer G b ≤ AddAction.stabilizer G (a +ᵥ b)

full_name: MulAction.le_stabilizer_smul_right
code: @[to_additive]
lemma le_stabilizer_smul_right [SMul α β] [SMulCommClass G α β] (a : α) (b : β) :
    stabilizer G b ≤ stabilizer G (a • b) 
goal: MulAction.stabilizer G b ≤ MulAction.stabilizer G (a • b)

full_name: AddAction.stabilizer_vadd_eq_left
code: @[to_additive (attr := simp)]
lemma stabilizer_smul_eq_left [SMul α β] [IsScalarTower G α β] (a : α) (b : β)
    (h : Injective (· • b : α → β)) : stabilizer G (a • b) = stabilizer G a 
goal: AddAction.stabilizer G (a +ᵥ b) = AddAction.stabilizer G a

full_name: MulAction.stabilizer_smul_eq_left
code: @[to_additive (attr := simp)]
lemma stabilizer_smul_eq_left [SMul α β] [IsScalarTower G α β] (a : α) (b : β)
    (h : Injective (· • b : α → β)) : stabilizer G (a • b) = stabilizer G a 
goal: MulAction.stabilizer G (a • b) = MulAction.stabilizer G a

full_name: MulAction.stabilizer_smul_eq_right
code: @[to_additive (attr := simp)]
lemma stabilizer_smul_eq_right [Group α] [MulAction α β] [SMulCommClass G α β] (a : α) (b : β) :
    stabilizer G (a • b) = stabilizer G b 
goal: MulAction.stabilizer G (a • b) = MulAction.stabilizer G b

full_name: AddAction.stabilizer_vadd_eq_right
code: @[to_additive (attr := simp)]
lemma stabilizer_smul_eq_right [Group α] [MulAction α β] [SMulCommClass G α β] (a : α) (b : β) :
    stabilizer G (a • b) = stabilizer G b 
goal: AddAction.stabilizer G (a +ᵥ b) = AddAction.stabilizer G b

full_name: MulAction.stabilizer_mul_eq_left
code: @[to_additive (attr := simp)]
lemma stabilizer_mul_eq_left [Group α] [IsScalarTower G α α] (a b : α)  :
    stabilizer G (a * b) = stabilizer G a 
goal: MulAction.stabilizer G (a * b) = MulAction.stabilizer G a

full_name: AddAction.stabilizer_add_eq_left
code: @[to_additive (attr := simp)]
lemma stabilizer_mul_eq_left [Group α] [IsScalarTower G α α] (a b : α)  :
    stabilizer G (a * b) = stabilizer G a 
goal: AddAction.stabilizer G (a + b) = AddAction.stabilizer G a

full_name: MulAction.stabilizer_mul_eq_right
code: @[to_additive (attr := simp)]
lemma stabilizer_mul_eq_right [Group α] [SMulCommClass G α α] (a b : α) :
    stabilizer G (a * b) = stabilizer G b 
goal: MulAction.stabilizer G (a * b) = MulAction.stabilizer G b

full_name: AddAction.stabilizer_add_eq_right
code: @[to_additive (attr := simp)]
lemma stabilizer_mul_eq_right [Group α] [SMulCommClass G α α] (a b : α) :
    stabilizer G (a * b) = stabilizer G b 
goal: AddAction.stabilizer G (a + b) = AddAction.stabilizer G b

full_name: MulAction.stabilizer_smul_eq_stabilizer_map_conj
code: /-- If the stabilizer of `a` is `S`, then the stabilizer of `g • a` is `gSg⁻¹`. -/
theorem stabilizer_smul_eq_stabilizer_map_conj (g : G) (a : α) :
    stabilizer G (g • a) = (stabilizer G a).map (MulAut.conj g).toMonoidHom 
goal: MulAction.stabilizer G (g • a) = Subgroup.map (MulEquiv.toMonoidHom (MulAut.conj g)) (MulAction.stabilizer G a)

full_name: MulAction.stabilizerEquivStabilizerOfOrbitRel
code: /-- A bijection between the stabilizers of two elements in the same orbit. -/
noncomputable def stabilizerEquivStabilizerOfOrbitRel {a b : α} (h : (orbitRel G α).Rel a b) :
    stabilizer G a ≃* stabilizer G b 
goal: ↥(MulAction.stabilizer G a) ≃* ↥(MulAction.stabilizer G b)

full_name: AddAction.stabilizer_vadd_eq_stabilizer_map_conj
code: /-- If the stabilizer of `x` is `S`, then the stabilizer of `g +ᵥ x` is `g + S + (-g)`. -/
theorem stabilizer_vadd_eq_stabilizer_map_conj (g : G) (a : α) :
    stabilizer G (g +ᵥ a) = (stabilizer G a).map (AddAut.conj g).toAddMonoidHom 
goal: AddAction.stabilizer G (g +ᵥ a) = AddSubgroup.map (AddEquiv.toAddMonoidHom (AddAut.conj g)) (AddAction.stabilizer G a)

full_name: AddAction.stabilizerEquivStabilizerOfOrbitRel
code: /-- A bijection between the stabilizers of two elements in the same orbit. -/
noncomputable def stabilizerEquivStabilizerOfOrbitRel {a b : α} (h : (orbitRel G α).Rel a b) :
    stabilizer G a ≃+ stabilizer G b 
goal: ↥(AddAction.stabilizer G a) ≃+ ↥(AddAction.stabilizer G b)

full_name: Equiv.swap_mem_stabilizer
code: theorem Equiv.swap_mem_stabilizer {α : Type*} [DecidableEq α] {S : Set α} {a b : α} :
    Equiv.swap a b ∈ MulAction.stabilizer (Equiv.Perm α) S ↔ (a ∈ S ↔ b ∈ S) 
goal: Equiv.swap a b ∈ MulAction.stabilizer (Equiv.Perm α) S ↔ (a ∈ S ↔ b ∈ S)

full_name: MulAction.le_stabilizer_iff_smul_le
code: /-- To prove inclusion of a *subgroup* in a stabilizer, it is enough to prove inclusions.-/
theorem le_stabilizer_iff_smul_le (s : Set α) (H : Subgroup G) :
    H ≤ stabilizer G s ↔ ∀ g ∈ H, g • s ⊆ s 
goal: H ≤ MulAction.stabilizer G s ↔ ∀ g ∈ H, g • s ⊆ s

full_name: MulAction.mem_stabilizer_of_finite_iff_smul_le
code: /-- To prove membership to stabilizer of a *finite set*, it is enough to prove one inclusion. -/
theorem mem_stabilizer_of_finite_iff_smul_le (s : Set α) (hs : s.Finite) (g : G) :
    g ∈ stabilizer G s ↔ g • s ⊆ s 
goal: g ∈ MulAction.stabilizer G s ↔ g • s ⊆ s

full_name: MulAction.mem_stabilizer_of_finite_iff_le_smul
code: /-- To prove membership to stabilizer of a *finite set*, it is enough to prove one inclusion. -/
theorem mem_stabilizer_of_finite_iff_le_smul (s : Set α) (hs : s.Finite) (g : G) :
    g ∈ stabilizer G s ↔ s ⊆ g • s 
goal: g ∈ MulAction.stabilizer G s ↔ s ⊆ g • s