File: Mathlib/Algebra/Group/Action/Basic.lean

full_name: MulAction.toPerm
code: /-- Given an action of a group `α` on `β`, each `g : α` defines a permutation of `β`. -/
@[to_additive (attr := simps)]
def MulAction.toPerm (a : α) : Equiv.Perm β 
goal: Equiv.Perm β

full_name: MulAction.toPerm_apply
code: /-- Given an action of a group `α` on `β`, each `g : α` defines a permutation of `β`. -/
@[to_additive (attr := simps)]
def MulAction.toPerm (a : α) : Equiv.Perm β 
goal: (MulAction.toPerm a) x = a • x

full_name: MulAction.toPerm_symm_apply
code: /-- Given an action of a group `α` on `β`, each `g : α` defines a permutation of `β`. -/
@[to_additive (attr := simps)]
def MulAction.toPerm (a : α) : Equiv.Perm β 
goal: (Equiv.symm (MulAction.toPerm a)) x = a⁻¹ • x

full_name: AddAction.toPerm
code: /-- Given an action of a group `α` on `β`, each `g : α` defines a permutation of `β`. -/
@[to_additive (attr := simps)]
def MulAction.toPerm (a : α) : Equiv.Perm β 
goal: Equiv.Perm β

full_name: AddAction.toPerm_apply
code: /-- Given an action of a group `α` on `β`, each `g : α` defines a permutation of `β`. -/
@[to_additive (attr := simps)]
def MulAction.toPerm (a : α) : Equiv.Perm β 
goal: (AddAction.toPerm a) x = a +ᵥ x

full_name: AddAction.toPerm_symm_apply
code: /-- Given an action of a group `α` on `β`, each `g : α` defines a permutation of `β`. -/
@[to_additive (attr := simps)]
def MulAction.toPerm (a : α) : Equiv.Perm β 
goal: (Equiv.symm (AddAction.toPerm a)) x = -a +ᵥ x

full_name: MulAction.toPerm_injective
code: /-- `MulAction.toPerm` is injective on faithful actions. -/
@[to_additive "`AddAction.toPerm` is injective on faithful actions."]
lemma MulAction.toPerm_injective [FaithfulSMul α β] :
    Function.Injective (MulAction.toPerm : α → Equiv.Perm β) 
goal: Function.Injective MulAction.toPerm

full_name: AddAction.toPerm_injective
code: /-- `MulAction.toPerm` is injective on faithful actions. -/
@[to_additive "`AddAction.toPerm` is injective on faithful actions."]
lemma MulAction.toPerm_injective [FaithfulSMul α β] :
    Function.Injective (MulAction.toPerm : α → Equiv.Perm β) 
goal: Function.Injective AddAction.toPerm

full_name: MulAction.toPermHom
code: /-- Given an action of a group `α` on a set `β`, each `g : α` defines a permutation of `β`. -/
@[simps]
def MulAction.toPermHom : α →* Equiv.Perm β 
goal: α →* Equiv.Perm β

full_name: MulAction.toPermHom_apply
code: /-- Given an action of a group `α` on a set `β`, each `g : α` defines a permutation of `β`. -/
@[simps]
def MulAction.toPermHom : α →* Equiv.Perm β 
goal: (MulAction.toPermHom α β) a = MulAction.toPerm a

full_name: AddAction.toPermHom
code: /-- Given an action of an additive group `α` on a set `β`, each `g : α` defines a permutation of
`β`. -/
@[simps!]
def AddAction.toPermHom (α : Type*) [AddGroup α] [AddAction α β] :
    α →+ Additive (Equiv.Perm β) 
goal: α →+ Additive (Equiv.Perm β)

full_name: AddAction.toPermHom_apply_symm_apply
code: /-- Given an action of an additive group `α` on a set `β`, each `g : α` defines a permutation of
`β`. -/
@[simps!]
def AddAction.toPermHom (α : Type*) [AddGroup α] [AddAction α β] :
    α →+ Additive (Equiv.Perm β) 
goal: (Equiv.symm ((AddAction.toPermHom β α) a)) x = (Multiplicative.ofAdd a)⁻¹ • x

full_name: AddAction.toPermHom_apply_apply
code: /-- Given an action of an additive group `α` on a set `β`, each `g : α` defines a permutation of
`β`. -/
@[simps!]
def AddAction.toPermHom (α : Type*) [AddGroup α] [AddAction α β] :
    α →+ Additive (Equiv.Perm β) 
goal: ((AddAction.toPermHom β α) a) x = a +ᵥ x

full_name: Equiv.Perm.applyMulAction
code: /-- The tautological action by `Equiv.Perm α` on `α`.

This generalizes `Function.End.applyMulAction`. -/
instance Equiv.Perm.applyMulAction (α : Type*) : MulAction (Equiv.Perm α) α 
goal: MulAction (Equiv.Perm α) α

full_name: Equiv.Perm.smul_def
code: @[simp]
protected lemma Equiv.Perm.smul_def {α : Type*} (f : Equiv.Perm α) (a : α) : f • a = f a 
goal: f • a = f a

full_name: Equiv.Perm.applyFaithfulSMul
code: /-- `Equiv.Perm.applyMulAction` is faithful. -/
instance Equiv.Perm.applyFaithfulSMul (α : Type*) : FaithfulSMul (Equiv.Perm α) α 
goal: FaithfulSMul (Equiv.Perm α) α

full_name: MulAction.bijective
code: @[to_additive]
protected lemma MulAction.bijective (g : α) : Function.Bijective (g • · : β → β) 
goal: Function.Bijective fun x => g • x

full_name: AddAction.bijective
code: @[to_additive]
protected lemma MulAction.bijective (g : α) : Function.Bijective (g • · : β → β) 
goal: Function.Bijective fun x => g +ᵥ x

full_name: AddAction.injective
code: @[to_additive]
protected lemma MulAction.injective (g : α) : Function.Injective (g • · : β → β) 
goal: Function.Injective fun x => g +ᵥ x

full_name: MulAction.injective
code: @[to_additive]
protected lemma MulAction.injective (g : α) : Function.Injective (g • · : β → β) 
goal: Function.Injective fun x => g • x

full_name: MulAction.surjective
code: @[to_additive]
protected lemma MulAction.surjective (g : α) : Function.Surjective (g • · : β → β) 
goal: Function.Surjective fun x => g • x

full_name: AddAction.surjective
code: @[to_additive]
protected lemma MulAction.surjective (g : α) : Function.Surjective (g • · : β → β) 
goal: Function.Surjective fun x => g +ᵥ x

full_name: vadd_left_cancel
code: @[to_additive]
lemma smul_left_cancel (g : α) {x y : β} (h : g • x = g • y) : x = y 
goal: x = y

full_name: smul_left_cancel
code: @[to_additive]
lemma smul_left_cancel (g : α) {x y : β} (h : g • x = g • y) : x = y 
goal: x = y

full_name: smul_left_cancel_iff
code: @[to_additive (attr := simp)]
lemma smul_left_cancel_iff (g : α) {x y : β} : g • x = g • y ↔ x = y 
goal: g • x = g • y ↔ x = y

full_name: vadd_left_cancel_iff
code: @[to_additive (attr := simp)]
lemma smul_left_cancel_iff (g : α) {x y : β} : g • x = g • y ↔ x = y 
goal: g +ᵥ x = g +ᵥ y ↔ x = y

full_name: vadd_eq_iff_eq_neg_vadd
code: @[to_additive]
lemma smul_eq_iff_eq_inv_smul (g : α) {x y : β} : g • x = y ↔ x = g⁻¹ • y 
goal: g +ᵥ x = y ↔ x = -g +ᵥ y

full_name: smul_eq_iff_eq_inv_smul
code: @[to_additive]
lemma smul_eq_iff_eq_inv_smul (g : α) {x y : β} : g • x = y ↔ x = g⁻¹ • y 
goal: g • x = y ↔ x = g⁻¹ • y

full_name: invOf_smul_smul
code: @[simp] lemma invOf_smul_smul : ⅟c • c • x = x 
goal: ⅟c • c • x = x

full_name: smul_invOf_smul
code: @[simp] lemma smul_invOf_smul : c • (⅟ c • x) = x 
goal: c • ⅟c • x = x

full_name: invOf_smul_eq_iff
code: lemma invOf_smul_eq_iff : ⅟c • x = y ↔ x = c • y 
goal: ⅟c • x = y ↔ x = c • y

full_name: smul_eq_iff_eq_invOf_smul
code: lemma smul_eq_iff_eq_invOf_smul : c • x = y ↔ x = ⅟c • y 
goal: c • x = y ↔ x = ⅟c • y

full_name: arrowAddAction_vadd
code: /-- If `G` acts on `A`, then it acts also on `A → B`, by `(g • F) a = F (g⁻¹ • a)`. -/
@[to_additive (attr := simps) arrowAddAction
      "If `G` acts on `A`, then it acts also on `A → B`, by `(g +ᵥ F) a = F (g⁻¹ +ᵥ a)`"]
def arrowAction {G A B : Type*} [DivisionMonoid G] [MulAction G A] : MulAction G (A → B) 
goal: VAdd.vadd g F a = F (-g +ᵥ a)

full_name: arrowAddAction
code: /-- If `G` acts on `A`, then it acts also on `A → B`, by `(g • F) a = F (g⁻¹ • a)`. -/
@[to_additive (attr := simps) arrowAddAction
      "If `G` acts on `A`, then it acts also on `A → B`, by `(g +ᵥ F) a = F (g⁻¹ +ᵥ a)`"]
def arrowAction {G A B : Type*} [DivisionMonoid G] [MulAction G A] : MulAction G (A → B) 
goal: AddAction G (A → B)

full_name: arrowAction
code: /-- If `G` acts on `A`, then it acts also on `A → B`, by `(g • F) a = F (g⁻¹ • a)`. -/
@[to_additive (attr := simps) arrowAddAction
      "If `G` acts on `A`, then it acts also on `A → B`, by `(g +ᵥ F) a = F (g⁻¹ +ᵥ a)`"]
def arrowAction {G A B : Type*} [DivisionMonoid G] [MulAction G A] : MulAction G (A → B) 
goal: MulAction G (A → B)

full_name: arrowAction_smul
code: /-- If `G` acts on `A`, then it acts also on `A → B`, by `(g • F) a = F (g⁻¹ • a)`. -/
@[to_additive (attr := simps) arrowAddAction
      "If `G` acts on `A`, then it acts also on `A → B`, by `(g +ᵥ F) a = F (g⁻¹ +ᵥ a)`"]
def arrowAction {G A B : Type*} [DivisionMonoid G] [MulAction G A] : MulAction G (A → B) 
goal: SMul.smul g F a = F (g⁻¹ • a)

full_name: IsAddUnit.vadd_left_cancel
code: @[to_additive]
lemma smul_left_cancel {a : α} (ha : IsUnit a) {x y : β} : a • x = a • y ↔ x = y 
goal: a +ᵥ x = a +ᵥ y ↔ x = y

full_name: IsUnit.smul_left_cancel
code: @[to_additive]
lemma smul_left_cancel {a : α} (ha : IsUnit a) {x y : β} : a • x = a • y ↔ x = y 
goal: a • x = a • y ↔ x = y

full_name: isUnit_smul_iff
code: @[simp] lemma isUnit_smul_iff (g : α) (m : β) : IsUnit (g • m) ↔ IsUnit m 
goal: IsUnit (g • m) ↔ IsUnit m