File: Mathlib/Algebra/Group/Aut.lean

full_name: AddAut
code: /-- The group of multiplicative automorphisms. -/
@[reducible, to_additive "The group of additive automorphisms."]
def MulAut (M : Type*) [Mul M] 
goal: Type u_4

full_name: MulAut
code: /-- The group of multiplicative automorphisms. -/
@[reducible, to_additive "The group of additive automorphisms."]
def MulAut (M : Type*) [Mul M] 
goal: Type u_4

full_name: MulAut.instGroup
code: /-- The group operation on multiplicative automorphisms is defined by `g h => MulEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance : Group (MulAut M) 
goal: Group (MulAut M)

full_name: MulAut.instInhabited
code: instance : Inhabited (MulAut M) 
goal: Inhabited (MulAut M)

full_name: MulAut.coe_mul
code: @[simp]
theorem coe_mul (e₁ e₂ : MulAut M) : ⇑(e₁ * e₂) = e₁ ∘ e₂ 
goal: ⇑(e₁ * e₂) = ⇑e₁ ∘ ⇑e₂

full_name: MulAut.coe_one
code: @[simp]
theorem coe_one : ⇑(1 : MulAut M) = id 
goal: ⇑1 = id

full_name: MulAut.mul_def
code: theorem mul_def (e₁ e₂ : MulAut M) : e₁ * e₂ = e₂.trans e₁ 
goal: e₁ * e₂ = MulEquiv.trans e₂ e₁

full_name: MulAut.one_def
code: theorem one_def : (1 : MulAut M) = MulEquiv.refl _ 
goal: 1 = MulEquiv.refl M

full_name: MulAut.inv_def
code: theorem inv_def (e₁ : MulAut M) : e₁⁻¹ = e₁.symm 
goal: e₁⁻¹ = MulEquiv.symm e₁

full_name: MulAut.mul_apply
code: @[simp]
theorem mul_apply (e₁ e₂ : MulAut M) (m : M) : (e₁ * e₂) m = e₁ (e₂ m) 
goal: (e₁ * e₂) m = e₁ (e₂ m)

full_name: MulAut.one_apply
code: @[simp]
theorem one_apply (m : M) : (1 : MulAut M) m = m 
goal: 1 m = m

full_name: MulAut.apply_inv_self
code: @[simp]
theorem apply_inv_self (e : MulAut M) (m : M) : e (e⁻¹ m) = m 
goal: e (e⁻¹ m) = m

full_name: MulAut.inv_apply_self
code: @[simp]
theorem inv_apply_self (e : MulAut M) (m : M) : e⁻¹ (e m) = m 
goal: e⁻¹ (e m) = m

full_name: MulAut.toPerm
code: /-- Monoid hom from the group of multiplicative automorphisms to the group of permutations. -/
def toPerm : MulAut M →* Equiv.Perm M 
goal: MulAut M →* Equiv.Perm M

full_name: MulAut.applyMulDistribMulAction
code: /-- The tautological action by `MulAut M` on `M`.

This generalizes `Function.End.applyMulAction`. -/
instance applyMulDistribMulAction {M} [Monoid M] : MulDistribMulAction (MulAut M) M 
goal: MulDistribMulAction (MulAut M) M

full_name: MulAut.smul_def
code: @[simp]
protected theorem smul_def {M} [Monoid M] (f : MulAut M) (a : M) : f • a = f a 
goal: f • a = f a

full_name: MulAut.apply_faithfulSMul
code: /-- `MulAut.applyDistribMulAction` is faithful. -/
instance apply_faithfulSMul {M} [Monoid M] : FaithfulSMul (MulAut M) M 
goal: FaithfulSMul (MulAut M) M

full_name: MulAut.conj
code: /-- Group conjugation, `MulAut.conj g h = g * h * g⁻¹`, as a monoid homomorphism
mapping multiplication in `G` into multiplication in the automorphism group `MulAut G`.
See also the type `ConjAct G` for any group `G`, which has a `MulAction (ConjAct G) G` instance
where `conj G` acts on `G` by conjugation. -/
def conj [Group G] : G →* MulAut G 
goal: G →* MulAut G

full_name: MulAut.conj_apply
code: @[simp]
theorem conj_apply [Group G] (g h : G) : conj g h = g * h * g⁻¹ 
goal: (MulAut.conj g) h = g * h * g⁻¹

full_name: MulAut.conj_symm_apply
code: @[simp]
theorem conj_symm_apply [Group G] (g h : G) : (conj g).symm h = g⁻¹ * h * g 
goal: (MulEquiv.symm (MulAut.conj g)) h = g⁻¹ * h * g

full_name: MulAut.conj_inv_apply
code: @[simp]
theorem conj_inv_apply [Group G] (g h : G) : (conj g)⁻¹ h = g⁻¹ * h * g 
goal: (MulAut.conj g)⁻¹ h = g⁻¹ * h * g

full_name: AddAut.group
code: /-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) 
goal: Group (AddAut A)

full_name: AddAut.instInhabited
code: instance : Inhabited (AddAut A) 
goal: Inhabited (AddAut A)

full_name: AddAut.coe_mul
code: @[simp]
theorem coe_mul (e₁ e₂ : AddAut A) : ⇑(e₁ * e₂) = e₁ ∘ e₂ 
goal: ⇑(e₁ * e₂) = ⇑e₁ ∘ ⇑e₂

full_name: AddAut.coe_one
code: @[simp]
theorem coe_one : ⇑(1 : AddAut A) = id 
goal: ⇑1 = id

full_name: AddAut.mul_def
code: theorem mul_def (e₁ e₂ : AddAut A) : e₁ * e₂ = e₂.trans e₁ 
goal: e₁ * e₂ = AddEquiv.trans e₂ e₁

full_name: AddAut.one_def
code: theorem one_def : (1 : AddAut A) = AddEquiv.refl _ 
goal: 1 = AddEquiv.refl A

full_name: AddAut.inv_def
code: theorem inv_def (e₁ : AddAut A) : e₁⁻¹ = e₁.symm 
goal: e₁⁻¹ = AddEquiv.symm e₁

full_name: AddAut.mul_apply
code: @[simp]
theorem mul_apply (e₁ e₂ : AddAut A) (a : A) : (e₁ * e₂) a = e₁ (e₂ a) 
goal: (e₁ * e₂) a = e₁ (e₂ a)

full_name: AddAut.one_apply
code: @[simp]
theorem one_apply (a : A) : (1 : AddAut A) a = a 
goal: 1 a = a

full_name: AddAut.apply_inv_self
code: @[simp]
theorem apply_inv_self (e : AddAut A) (a : A) : e⁻¹ (e a) = a 
goal: e⁻¹ (e a) = a

full_name: AddAut.inv_apply_self
code: @[simp]
theorem inv_apply_self (e : AddAut A) (a : A) : e (e⁻¹ a) = a 
goal: e (e⁻¹ a) = a

full_name: AddAut.toPerm
code: /-- Monoid hom from the group of multiplicative automorphisms to the group of permutations. -/
def toPerm : AddAut A →* Equiv.Perm A 
goal: AddAut A →* Equiv.Perm A

full_name: AddAut.applyDistribMulAction
code: /-- The tautological action by `AddAut A` on `A`.

This generalizes `Function.End.applyMulAction`. -/
instance applyDistribMulAction {A} [AddMonoid A] : DistribMulAction (AddAut A) A 
goal: DistribMulAction (AddAut A) A

full_name: AddAut.smul_def
code: @[simp]
protected theorem smul_def {A} [AddMonoid A] (f : AddAut A) (a : A) : f • a = f a 
goal: f • a = f a

full_name: AddAut.apply_faithfulSMul
code: /-- `AddAut.applyDistribMulAction` is faithful. -/
instance apply_faithfulSMul {A} [AddMonoid A] : FaithfulSMul (AddAut A) A 
goal: FaithfulSMul (AddAut A) A

full_name: AddAut.conj
code: /-- Additive group conjugation, `AddAut.conj g h = g + h - g`, as an additive monoid
homomorphism mapping addition in `G` into multiplication in the automorphism group `AddAut G`
(written additively in order to define the map). -/
def conj [AddGroup G] : G →+ Additive (AddAut G) 
goal: G →+ Additive (AddAut G)

full_name: AddAut.conj_apply
code: @[simp]
theorem conj_apply [AddGroup G] (g h : G) : conj g h = g + h + -g 
goal: (Additive.toMul (AddAut.conj g)) h = g + h + -g

full_name: AddAut.conj_symm_apply
code: @[simp]
theorem conj_symm_apply [AddGroup G] (g h : G) : (conj g).symm h = -g + h + g 
goal: (AddEquiv.symm (AddAut.conj g)) h = -g + h + g

full_name: AddAut.conj_inv_apply
code: @[simp]
theorem conj_inv_apply [AddGroup G] (g h : G) : (Additive.toMul (conj g))⁻¹ h = -g + h + g 
goal: (Additive.toMul (AddAut.conj g))⁻¹ h = -g + h + g