/-
Copyright (c) 2021 . All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Chris Hughes

! This file was ported from Lean 3 source module group_theory.group_action.conj_act
! leanprover-community/mathlib commit fac369018417f980cec5fcdafc766a69f88d8cfe
! Please do not edit these lines, except to modify the commit id
! if you have ported upstream changes.
-/
import Mathbin.GroupTheory.GroupAction.Basic
import Mathbin.GroupTheory.Subgroup.Zpowers
import Mathbin.Algebra.GroupRingAction.Basic

/-!
# Conjugation action of a group on itself

> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
> Any changes to this file require a corresponding PR to mathlib4.

This file defines the conjugation action of a group on itself. See also `mul_aut.conj` for
the definition of conjugation as a homomorphism into the automorphism group.

## Main definitions

A type alias `conj_act G` is introduced for a group `G`. The group `conj_act G` acts on `G`
by conjugation. The group `conj_act G` also acts on any normal subgroup of `G` by conjugation.

As a generalization, this also allows:
* `conj_act Mˣ` to act on `M`, when `M` is a `monoid`
* `conj_act G₀` to act on `G₀`, when `G₀` is a `group_with_zero`

## Implementation Notes

The scalar action in defined in this file can also be written using `mul_aut.conj g • h`. This
has the advantage of not using the type alias `conj_act`, but the downside of this approach
is that some theorems about the group actions will not apply when since this
`mul_aut.conj g • h` describes an action of `mul_aut G` on `G`, and not an action of `G`.

-/

variable (α M G G₀ R K : Type _)

#print ConjAct /-
/-- A type alias for a group `G`. `conj_act G` acts on `G` by conjugation -/
def ConjAct : Type _ :=
  G
#align conj_act ConjAct
-/

namespace ConjAct

open MulAction Subgroup

variable {M G G₀ R K}

instance : ∀ [Group G], Group (ConjAct G) :=
  id

instance : ∀ [DivInvMonoid G], DivInvMonoid (ConjAct G) :=
  id

instance : ∀ [GroupWithZero G], GroupWithZero (ConjAct G) :=
  id

instance : ∀ [Fintype G], Fintype (ConjAct G) :=
  id

#print ConjAct.card /-
@[simp]
theorem card [Fintype G] : Fintype.card (ConjAct G) = Fintype.card G :=
  rfl
#align conj_act.card ConjAct.card
-/

section DivInvMonoid

variable [DivInvMonoid G]

instance : Inhabited (ConjAct G) :=
  ⟨1⟩

/- warning: conj_act.of_conj_act -> ConjAct.ofConjAct is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G], MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G], MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))
Case conversion may be inaccurate. Consider using '#align conj_act.of_conj_act ConjAct.ofConjActₓ'. -/
/-- Reinterpret `g : conj_act G` as an element of `G`. -/
def ofConjAct : ConjAct G ≃* G :=
  ⟨id, id, fun _ => rfl, fun _ => rfl, fun _ _ => rfl⟩
#align conj_act.of_conj_act ConjAct.ofConjAct

/- warning: conj_act.to_conj_act -> ConjAct.toConjAct is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G], MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G], MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))
Case conversion may be inaccurate. Consider using '#align conj_act.to_conj_act ConjAct.toConjActₓ'. -/
/-- Reinterpret `g : G` as an element of `conj_act G`. -/
def toConjAct : G ≃* ConjAct G :=
  ofConjAct.symm
#align conj_act.to_conj_act ConjAct.toConjAct

/- warning: conj_act.rec -> ConjAct.rec is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] {C : (ConjAct.{u1} G) -> Sort.{u2}}, (forall (g : G), C (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) => G -> (ConjAct.{u1} G)) (MulEquiv.hasCoeToFun.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (ConjAct.toConjAct.{u1} G _inst_1) g)) -> (forall (g : ConjAct.{u1} G), C g)
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] {C : (ConjAct.{u1} G) -> Sort.{u2}}, (forall (g : G), C (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))))) (ConjAct.toConjAct.{u1} G _inst_1) g)) -> (forall (g : ConjAct.{u1} G), C g)
Case conversion may be inaccurate. Consider using '#align conj_act.rec ConjAct.recₓ'. -/
/-- A recursor for `conj_act`, for use as `induction x using conj_act.rec` when `x : conj_act G`. -/
protected def rec {C : ConjAct G → Sort _} (h : ∀ g, C (toConjAct g)) : ∀ g, C g :=
  h
#align conj_act.rec ConjAct.rec

/- warning: conj_act.forall -> ConjAct.forall is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (p : (ConjAct.{u1} G) -> Prop), Iff (forall (x : ConjAct.{u1} G), p x) (forall (x : G), p (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) => G -> (ConjAct.{u1} G)) (MulEquiv.hasCoeToFun.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (ConjAct.toConjAct.{u1} G _inst_1) x))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (p : (ConjAct.{u1} G) -> Prop), Iff (forall (x : ConjAct.{u1} G), p x) (forall (x : G), p (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))))) (ConjAct.toConjAct.{u1} G _inst_1) x))
Case conversion may be inaccurate. Consider using '#align conj_act.forall ConjAct.forallₓ'. -/
@[simp]
theorem forall (p : ConjAct G → Prop) : (∀ x : ConjAct G, p x) ↔ ∀ x : G, p (toConjAct x) :=
  Iff.rfl
#align conj_act.forall ConjAct.forall

/- warning: conj_act.of_mul_symm_eq -> ConjAct.of_mul_symm_eq is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G], Eq.{succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (MulEquiv.symm.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (ConjAct.ofConjAct.{u1} G _inst_1)) (ConjAct.toConjAct.{u1} G _inst_1)
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G], Eq.{succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) (MulEquiv.symm.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (ConjAct.ofConjAct.{u1} G _inst_1)) (ConjAct.toConjAct.{u1} G _inst_1)
Case conversion may be inaccurate. Consider using '#align conj_act.of_mul_symm_eq ConjAct.of_mul_symm_eqₓ'. -/
@[simp]
theorem of_mul_symm_eq : (@ofConjAct G _).symm = toConjAct :=
  rfl
#align conj_act.of_mul_symm_eq ConjAct.of_mul_symm_eq

/- warning: conj_act.to_mul_symm_eq -> ConjAct.to_mul_symm_eq is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G], Eq.{succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (MulEquiv.symm.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (ConjAct.toConjAct.{u1} G _inst_1)) (ConjAct.ofConjAct.{u1} G _inst_1)
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G], Eq.{succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (MulEquiv.symm.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (ConjAct.toConjAct.{u1} G _inst_1)) (ConjAct.ofConjAct.{u1} G _inst_1)
Case conversion may be inaccurate. Consider using '#align conj_act.to_mul_symm_eq ConjAct.to_mul_symm_eqₓ'. -/
@[simp]
theorem to_mul_symm_eq : (@toConjAct G _).symm = ofConjAct :=
  rfl
#align conj_act.to_mul_symm_eq ConjAct.to_mul_symm_eq

/- warning: conj_act.to_conj_act_of_conj_act -> ConjAct.toConjAct_ofConjAct is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (x : ConjAct.{u1} G), Eq.{succ u1} (ConjAct.{u1} G) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) => G -> (ConjAct.{u1} G)) (MulEquiv.hasCoeToFun.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (ConjAct.toConjAct.{u1} G _inst_1) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) => (ConjAct.{u1} G) -> G) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.ofConjAct.{u1} G _inst_1) x)) x
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (x : ConjAct.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) => ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) (fun (a : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))) (ConjAct.ofConjAct.{u1} G _inst_1) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (ConjAct.instDivInvMonoidConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1))))) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (fun (_x : (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) => ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (ConjAct.instDivInvMonoidConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1))))) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (ConjAct.instDivInvMonoidConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (ConjAct.instDivInvMonoidConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1))))) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (ConjAct.instDivInvMonoidConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (ConjAct.instDivInvMonoidConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1))))) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (ConjAct.instDivInvMonoidConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x)) (ConjAct.instDivInvMonoidConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1)))))))) (ConjAct.toConjAct.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) (fun (_x : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))) (ConjAct.ofConjAct.{u1} G _inst_1) x)) x
Case conversion may be inaccurate. Consider using '#align conj_act.to_conj_act_of_conj_act ConjAct.toConjAct_ofConjActₓ'. -/
@[simp]
theorem toConjAct_ofConjAct (x : ConjAct G) : toConjAct (ofConjAct x) = x :=
  rfl
#align conj_act.to_conj_act_of_conj_act ConjAct.toConjAct_ofConjAct

/- warning: conj_act.of_conj_act_to_conj_act -> ConjAct.ofConjAct_toConjAct is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (x : G), Eq.{succ u1} G (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) => (ConjAct.{u1} G) -> G) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.ofConjAct.{u1} G _inst_1) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) => G -> (ConjAct.{u1} G)) (MulEquiv.hasCoeToFun.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (ConjAct.toConjAct.{u1} G _inst_1) x)) x
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (x : G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (fun (a : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))))) (ConjAct.toConjAct.{u1} G _inst_1) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) (fun (_x : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))) (ConjAct.ofConjAct.{u1} G _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))))) (ConjAct.toConjAct.{u1} G _inst_1) x)) x
Case conversion may be inaccurate. Consider using '#align conj_act.of_conj_act_to_conj_act ConjAct.ofConjAct_toConjActₓ'. -/
@[simp]
theorem ofConjAct_toConjAct (x : G) : ofConjAct (toConjAct x) = x :=
  rfl
#align conj_act.of_conj_act_to_conj_act ConjAct.ofConjAct_toConjAct

/- warning: conj_act.of_conj_act_one -> ConjAct.ofConjAct_one is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G], Eq.{succ u1} G (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) => (ConjAct.{u1} G) -> G) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.ofConjAct.{u1} G _inst_1) (OfNat.ofNat.{u1} (ConjAct.{u1} G) 1 (OfNat.mk.{u1} (ConjAct.{u1} G) 1 (One.one.{u1} (ConjAct.{u1} G) (MulOneClass.toHasOne.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))))))) (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G], Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) (OfNat.ofNat.{u1} (ConjAct.{u1} G) 1 (One.toOfNat1.{u1} (ConjAct.{u1} G) (Monoid.toOne.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) (fun (_x : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))) (ConjAct.ofConjAct.{u1} G _inst_1) (OfNat.ofNat.{u1} (ConjAct.{u1} G) 1 (One.toOfNat1.{u1} (ConjAct.{u1} G) (Monoid.toOne.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) (OfNat.ofNat.{u1} (ConjAct.{u1} G) 1 (One.toOfNat1.{u1} (ConjAct.{u1} G) (Monoid.toOne.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) (OfNat.ofNat.{u1} (ConjAct.{u1} G) 1 (One.toOfNat1.{u1} (ConjAct.{u1} G) (Monoid.toOne.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) (OfNat.ofNat.{u1} (ConjAct.{u1} G) 1 (One.toOfNat1.{u1} (ConjAct.{u1} G) (Monoid.toOne.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) (OfNat.ofNat.{u1} (ConjAct.{u1} G) 1 (One.toOfNat1.{u1} (ConjAct.{u1} G) (Monoid.toOne.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))) _inst_1))))
Case conversion may be inaccurate. Consider using '#align conj_act.of_conj_act_one ConjAct.ofConjAct_oneₓ'. -/
@[simp]
theorem ofConjAct_one : ofConjAct (1 : ConjAct G) = 1 :=
  rfl
#align conj_act.of_conj_act_one ConjAct.ofConjAct_one

/- warning: conj_act.to_conj_act_one -> ConjAct.toConjAct_one is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G], Eq.{succ u1} (ConjAct.{u1} G) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) => G -> (ConjAct.{u1} G)) (MulEquiv.hasCoeToFun.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (ConjAct.toConjAct.{u1} G _inst_1) (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))) (OfNat.ofNat.{u1} (ConjAct.{u1} G) 1 (OfNat.mk.{u1} (ConjAct.{u1} G) 1 (One.one.{u1} (ConjAct.{u1} G) (MulOneClass.toHasOne.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))))))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G], Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (Monoid.toOne.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))))) (ConjAct.toConjAct.{u1} G _inst_1) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (Monoid.toOne.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (Monoid.toOne.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (Monoid.toOne.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (Monoid.toOne.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (Monoid.toOne.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))
Case conversion may be inaccurate. Consider using '#align conj_act.to_conj_act_one ConjAct.toConjAct_oneₓ'. -/
@[simp]
theorem toConjAct_one : toConjAct (1 : G) = 1 :=
  rfl
#align conj_act.to_conj_act_one ConjAct.toConjAct_one

/- warning: conj_act.of_conj_act_inv -> ConjAct.ofConjAct_inv is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (x : ConjAct.{u1} G), Eq.{succ u1} G (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) => (ConjAct.{u1} G) -> G) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.ofConjAct.{u1} G _inst_1) (Inv.inv.{u1} (ConjAct.{u1} G) (DivInvMonoid.toHasInv.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)) x)) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G _inst_1) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) => (ConjAct.{u1} G) -> G) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.ofConjAct.{u1} G _inst_1) x))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (x : ConjAct.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) (Inv.inv.{u1} (ConjAct.{u1} G) (DivInvMonoid.toInv.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) (fun (_x : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))) (ConjAct.ofConjAct.{u1} G _inst_1) (Inv.inv.{u1} (ConjAct.{u1} G) (DivInvMonoid.toInv.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)) x)) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (DivInvMonoid.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) (fun (_x : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))) (ConjAct.ofConjAct.{u1} G _inst_1) x))
Case conversion may be inaccurate. Consider using '#align conj_act.of_conj_act_inv ConjAct.ofConjAct_invₓ'. -/
@[simp]
theorem ofConjAct_inv (x : ConjAct G) : ofConjAct x⁻¹ = (ofConjAct x)⁻¹ :=
  rfl
#align conj_act.of_conj_act_inv ConjAct.ofConjAct_inv

/- warning: conj_act.to_conj_act_inv -> ConjAct.toConjAct_inv is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (x : G), Eq.{succ u1} (ConjAct.{u1} G) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) => G -> (ConjAct.{u1} G)) (MulEquiv.hasCoeToFun.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (ConjAct.toConjAct.{u1} G _inst_1) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G _inst_1) x)) (Inv.inv.{u1} (ConjAct.{u1} G) (DivInvMonoid.toHasInv.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) => G -> (ConjAct.{u1} G)) (MulEquiv.hasCoeToFun.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (ConjAct.toConjAct.{u1} G _inst_1) x))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (x : G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) (Inv.inv.{u1} G (DivInvMonoid.toInv.{u1} G _inst_1) x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))))) (ConjAct.toConjAct.{u1} G _inst_1) (Inv.inv.{u1} G (DivInvMonoid.toInv.{u1} G _inst_1) x)) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) x) (DivInvMonoid.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) x) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))))) (ConjAct.toConjAct.{u1} G _inst_1) x))
Case conversion may be inaccurate. Consider using '#align conj_act.to_conj_act_inv ConjAct.toConjAct_invₓ'. -/
@[simp]
theorem toConjAct_inv (x : G) : toConjAct x⁻¹ = (toConjAct x)⁻¹ :=
  rfl
#align conj_act.to_conj_act_inv ConjAct.toConjAct_inv

/- warning: conj_act.of_conj_act_mul -> ConjAct.ofConjAct_mul is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (x : ConjAct.{u1} G) (y : ConjAct.{u1} G), Eq.{succ u1} G (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) => (ConjAct.{u1} G) -> G) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.ofConjAct.{u1} G _inst_1) (HMul.hMul.{u1, u1, u1} (ConjAct.{u1} G) (ConjAct.{u1} G) (ConjAct.{u1} G) (instHMul.{u1} (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) x y)) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) => (ConjAct.{u1} G) -> G) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.ofConjAct.{u1} G _inst_1) x) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) => (ConjAct.{u1} G) -> G) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.ofConjAct.{u1} G _inst_1) y))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (x : ConjAct.{u1} G) (y : ConjAct.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) (HMul.hMul.{u1, u1, u1} (ConjAct.{u1} G) (ConjAct.{u1} G) (ConjAct.{u1} G) (instHMul.{u1} (ConjAct.{u1} G) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) x y)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) (fun (_x : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))) (ConjAct.ofConjAct.{u1} G _inst_1) (HMul.hMul.{u1, u1, u1} (ConjAct.{u1} G) (ConjAct.{u1} G) (ConjAct.{u1} G) (instHMul.{u1} (ConjAct.{u1} G) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) x y)) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) y) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) x) _inst_1)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) (fun (_x : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))) (ConjAct.ofConjAct.{u1} G _inst_1) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) (fun (_x : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))) (ConjAct.ofConjAct.{u1} G _inst_1) y))
Case conversion may be inaccurate. Consider using '#align conj_act.of_conj_act_mul ConjAct.ofConjAct_mulₓ'. -/
@[simp]
theorem ofConjAct_mul (x y : ConjAct G) : ofConjAct (x * y) = ofConjAct x * ofConjAct y :=
  rfl
#align conj_act.of_conj_act_mul ConjAct.ofConjAct_mul

/- warning: conj_act.to_conj_act_mul -> ConjAct.toConjAct_mul is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (x : G) (y : G), Eq.{succ u1} (ConjAct.{u1} G) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) => G -> (ConjAct.{u1} G)) (MulEquiv.hasCoeToFun.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (ConjAct.toConjAct.{u1} G _inst_1) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) x y)) (HMul.hMul.{u1, u1, u1} (ConjAct.{u1} G) (ConjAct.{u1} G) (ConjAct.{u1} G) (instHMul.{u1} (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) => G -> (ConjAct.{u1} G)) (MulEquiv.hasCoeToFun.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (ConjAct.toConjAct.{u1} G _inst_1) x) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) => G -> (ConjAct.{u1} G)) (MulEquiv.hasCoeToFun.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1))))) (ConjAct.toConjAct.{u1} G _inst_1) y))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (x : G) (y : G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) x y)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))))) (ConjAct.toConjAct.{u1} G _inst_1) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) x y)) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) y) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) x) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) x) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))))) (ConjAct.toConjAct.{u1} G _inst_1) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => ConjAct.{u1} G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))))) G (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} G (ConjAct.{u1} G) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))))))) (ConjAct.toConjAct.{u1} G _inst_1) y))
Case conversion may be inaccurate. Consider using '#align conj_act.to_conj_act_mul ConjAct.toConjAct_mulₓ'. -/
@[simp]
theorem toConjAct_mul (x y : G) : toConjAct (x * y) = toConjAct x * toConjAct y :=
  rfl
#align conj_act.to_conj_act_mul ConjAct.toConjAct_mul

instance : SMul (ConjAct G) G where smul g h := ofConjAct g * h * (ofConjAct g)⁻¹

/- warning: conj_act.smul_def -> ConjAct.smul_def is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (g : ConjAct.{u1} G) (h : G), Eq.{succ u1} G (SMul.smul.{u1, u1} (ConjAct.{u1} G) G (ConjAct.hasSmul.{u1} G _inst_1) g h) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) => (ConjAct.{u1} G) -> G) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.ofConjAct.{u1} G _inst_1) g) h) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G _inst_1) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) => (ConjAct.{u1} G) -> G) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.ofConjAct.{u1} G _inst_1) g)))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} G] (g : ConjAct.{u1} G) (h : G), Eq.{succ u1} G (HSMul.hSMul.{u1, u1, u1} (ConjAct.{u1} G) G G (instHSMul.{u1, u1} (ConjAct.{u1} G) G (ConjAct.instSMulConjAct.{u1} G _inst_1)) g h) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1)))) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) G ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) (fun (_x : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))) (ConjAct.ofConjAct.{u1} G _inst_1) g) h) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) (fun (_x : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1)) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G _inst_1))))))) (ConjAct.ofConjAct.{u1} G _inst_1) g)))
Case conversion may be inaccurate. Consider using '#align conj_act.smul_def ConjAct.smul_defₓ'. -/
theorem smul_def (g : ConjAct G) (h : G) : g • h = ofConjAct g * h * (ofConjAct g)⁻¹ :=
  rfl
#align conj_act.smul_def ConjAct.smul_def

end DivInvMonoid

section Units

section Monoid

variable [Monoid M]

#print ConjAct.unitsScalar /-
instance unitsScalar : SMul (ConjAct Mˣ) M where smul g h := ofConjAct g * h * ↑(ofConjAct g)⁻¹
#align conj_act.has_units_scalar ConjAct.unitsScalar
-/

/- warning: conj_act.units_smul_def -> ConjAct.units_smul_def is a dubious translation:
lean 3 declaration is
  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (g : ConjAct.{u1} (Units.{u1} M _inst_1)) (h : M), Eq.{succ u1} M (SMul.smul.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) M (ConjAct.unitsScalar.{u1} M _inst_1) g h) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.divInvMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))))) (MulOneClass.toHasMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.divInvMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))))) (MulOneClass.toHasMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))))) => (ConjAct.{u1} (Units.{u1} M _inst_1)) -> (Units.{u1} M _inst_1)) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.divInvMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))))) (MulOneClass.toHasMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))))) (ConjAct.ofConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1))) g)) h) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.divInvMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))))) (MulOneClass.toHasMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.divInvMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))))) (MulOneClass.toHasMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))))) => (ConjAct.{u1} (Units.{u1} M _inst_1)) -> (Units.{u1} M _inst_1)) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.divInvMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))))) (MulOneClass.toHasMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))))) (ConjAct.ofConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1))) g))))
but is expected to have type
  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (g : ConjAct.{u1} (Units.{u1} M _inst_1)) (h : M), Eq.{succ u1} M (HSMul.hSMul.{u1, u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) M M (instHSMul.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) M (ConjAct.unitsScalar.{u1} M _inst_1)) g h) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Units.val.{u1} M _inst_1 (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (ConjAct.{u1} (Units.{u1} M _inst_1)) (fun (_x : ConjAct.{u1} (Units.{u1} M _inst_1)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} (Units.{u1} M _inst_1)) => Units.{u1} M _inst_1) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1))))) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1))))) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1))))))))) (ConjAct.ofConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1))) g)) h) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} (Units.{u1} M _inst_1)) => Units.{u1} M _inst_1) g) (Units.instInvUnits.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (ConjAct.{u1} (Units.{u1} M _inst_1)) (fun (_x : ConjAct.{u1} (Units.{u1} M _inst_1)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} (Units.{u1} M _inst_1)) => Units.{u1} M _inst_1) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1))))) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1))))) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Units.{u1} M _inst_1) (MulOneClass.toMul.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1))))))))) (ConjAct.ofConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1))) g))))
Case conversion may be inaccurate. Consider using '#align conj_act.units_smul_def ConjAct.units_smul_defₓ'. -/
theorem units_smul_def (g : ConjAct Mˣ) (h : M) : g • h = ofConjAct g * h * ↑(ofConjAct g)⁻¹ :=
  rfl
#align conj_act.units_smul_def ConjAct.units_smul_def

/- warning: conj_act.units_mul_distrib_mul_action -> ConjAct.unitsMulDistribMulAction is a dubious translation:
lean 3 declaration is
  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], MulDistribMulAction.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) M (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.divInvMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1)))) _inst_1
but is expected to have type
  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], MulDistribMulAction.{u1, u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) M (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} M _inst_1)) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1)))) _inst_1
Case conversion may be inaccurate. Consider using '#align conj_act.units_mul_distrib_mul_action ConjAct.unitsMulDistribMulActionₓ'. -/
instance unitsMulDistribMulAction : MulDistribMulAction (ConjAct Mˣ) M
    where
  smul := (· • ·)
  one_smul := by simp [units_smul_def]
  mul_smul := by simp [units_smul_def, mul_assoc, mul_inv_rev]
  smul_mul := by simp [units_smul_def, mul_assoc]
  smul_one := by simp [units_smul_def]
#align conj_act.units_mul_distrib_mul_action ConjAct.unitsMulDistribMulAction

/- warning: conj_act.units_smul_comm_class -> ConjAct.unitsSMulCommClass is a dubious translation:
lean 3 declaration is
  forall (α : Type.{u1}) {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_2 : SMul.{u1, u2} α M] [_inst_3 : SMulCommClass.{u1, u2, u2} α M M _inst_2 (Mul.toSMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))] [_inst_4 : IsScalarTower.{u1, u2, u2} α M M _inst_2 (Mul.toSMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) _inst_2], SMulCommClass.{u1, u2, u2} α (ConjAct.{u2} (Units.{u2} M _inst_1)) M _inst_2 (ConjAct.unitsScalar.{u2} M _inst_1)
but is expected to have type
  forall (α : Type.{u1}) {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_2 : SMul.{u1, u2} α M] [_inst_3 : SMulCommClass.{u1, u2, u2} α M M _inst_2 (MulAction.toSMul.{u2, u2} M M _inst_1 (Monoid.toMulAction.{u2} M _inst_1))] [_inst_4 : IsScalarTower.{u1, u2, u2} α M M _inst_2 (MulAction.toSMul.{u2, u2} M M _inst_1 (Monoid.toMulAction.{u2} M _inst_1)) _inst_2], SMulCommClass.{u1, u2, u2} α (ConjAct.{u2} (Units.{u2} M _inst_1)) M _inst_2 (ConjAct.unitsScalar.{u2} M _inst_1)
Case conversion may be inaccurate. Consider using '#align conj_act.units_smul_comm_class ConjAct.unitsSMulCommClassₓ'. -/
instance unitsSMulCommClass [SMul α M] [SMulCommClass α M M] [IsScalarTower α M M] :
    SMulCommClass α (ConjAct Mˣ) M
    where smul_comm a um m := by rw [units_smul_def, units_smul_def, mul_smul_comm, smul_mul_assoc]
#align conj_act.units_smul_comm_class ConjAct.unitsSMulCommClass

/- warning: conj_act.units_smul_comm_class' -> ConjAct.unitsSMulCommClass' is a dubious translation:
lean 3 declaration is
  forall (α : Type.{u1}) {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_2 : SMul.{u1, u2} α M] [_inst_3 : SMulCommClass.{u2, u1, u2} M α M (Mul.toSMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) _inst_2] [_inst_4 : IsScalarTower.{u1, u2, u2} α M M _inst_2 (Mul.toSMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) _inst_2], SMulCommClass.{u2, u1, u2} (ConjAct.{u2} (Units.{u2} M _inst_1)) α M (ConjAct.unitsScalar.{u2} M _inst_1) _inst_2
but is expected to have type
  forall (α : Type.{u1}) {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_2 : SMul.{u1, u2} α M] [_inst_3 : SMulCommClass.{u2, u1, u2} M α M (MulAction.toSMul.{u2, u2} M M _inst_1 (Monoid.toMulAction.{u2} M _inst_1)) _inst_2] [_inst_4 : IsScalarTower.{u1, u2, u2} α M M _inst_2 (MulAction.toSMul.{u2, u2} M M _inst_1 (Monoid.toMulAction.{u2} M _inst_1)) _inst_2], SMulCommClass.{u2, u1, u2} (ConjAct.{u2} (Units.{u2} M _inst_1)) α M (ConjAct.unitsScalar.{u2} M _inst_1) _inst_2
Case conversion may be inaccurate. Consider using '#align conj_act.units_smul_comm_class' ConjAct.unitsSMulCommClass'ₓ'. -/
instance unitsSMulCommClass' [SMul α M] [SMulCommClass M α M] [IsScalarTower α M M] :
    SMulCommClass (ConjAct Mˣ) α M :=
  haveI : SMulCommClass α M M := SMulCommClass.symm _ _ _
  SMulCommClass.symm _ _ _
#align conj_act.units_smul_comm_class' ConjAct.unitsSMulCommClass'

end Monoid

section Semiring

variable [Semiring R]

/- warning: conj_act.units_mul_semiring_action -> ConjAct.unitsMulSemiringAction is a dubious translation:
lean 3 declaration is
  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R], MulSemiringAction.{u1, u1} (ConjAct.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) (ConjAct.divInvMonoid.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Group.toDivInvMonoid.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Units.group.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))))) _inst_1
but is expected to have type
  forall {R : Type.{u1}} [_inst_1 : Semiring.{u1} R], MulSemiringAction.{u1, u1} (ConjAct.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) R (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))) (ConjAct.instDivInvMonoidConjAct.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Group.toDivInvMonoid.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1))) (Units.instGroupUnits.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R _inst_1)))))) _inst_1
Case conversion may be inaccurate. Consider using '#align conj_act.units_mul_semiring_action ConjAct.unitsMulSemiringActionₓ'. -/
instance unitsMulSemiringAction : MulSemiringAction (ConjAct Rˣ) R :=
  { ConjAct.unitsMulDistribMulAction with
    smul := (· • ·)
    smul_zero := by simp [units_smul_def]
    smul_add := by simp [units_smul_def, mul_add, add_mul] }
#align conj_act.units_mul_semiring_action ConjAct.unitsMulSemiringAction

end Semiring

end Units

section GroupWithZero

variable [GroupWithZero G₀]

/- warning: conj_act.of_conj_act_zero -> ConjAct.ofConjAct_zero is a dubious translation:
lean 3 declaration is
  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀], Eq.{succ u1} G₀ (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G₀) G₀ (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.divInvMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (MulOneClass.toHasMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} G₀) G₀ (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.divInvMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (MulOneClass.toHasMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) => (ConjAct.{u1} G₀) -> G₀) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} G₀) G₀ (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.divInvMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (MulOneClass.toHasMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (ConjAct.ofConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)) (OfNat.ofNat.{u1} (ConjAct.{u1} G₀) 0 (OfNat.mk.{u1} (ConjAct.{u1} G₀) 0 (Zero.zero.{u1} (ConjAct.{u1} G₀) (MulZeroClass.toHasZero.{u1} (ConjAct.{u1} G₀) (MulZeroOneClass.toMulZeroClass.{u1} (ConjAct.{u1} G₀) (MonoidWithZero.toMulZeroOneClass.{u1} (ConjAct.{u1} G₀) (GroupWithZero.toMonoidWithZero.{u1} (ConjAct.{u1} G₀) (ConjAct.groupWithZero.{u1} G₀ _inst_1))))))))) (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))))))
but is expected to have type
  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀], Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G₀) => G₀) (OfNat.ofNat.{u1} (ConjAct.{u1} G₀) 0 (Zero.toOfNat0.{u1} (ConjAct.{u1} G₀) (MonoidWithZero.toZero.{u1} (ConjAct.{u1} G₀) (GroupWithZero.toMonoidWithZero.{u1} (ConjAct.{u1} G₀) (ConjAct.instGroupWithZeroConjAct.{u1} G₀ _inst_1)))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G₀) G₀ (MulOneClass.toMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (MulOneClass.toMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (ConjAct.{u1} G₀) (fun (_x : ConjAct.{u1} G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G₀) => G₀) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G₀) G₀ (MulOneClass.toMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (MulOneClass.toMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (ConjAct.{u1} G₀) G₀ (MulOneClass.toMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (MulOneClass.toMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G₀) G₀ (MulOneClass.toMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (MulOneClass.toMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (ConjAct.{u1} G₀) G₀ (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G₀) G₀ (MulOneClass.toMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (MulOneClass.toMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (ConjAct.{u1} G₀) G₀ (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G₀) G₀ (MulOneClass.toMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (MulOneClass.toMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))))))) (ConjAct.ofConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)) (OfNat.ofNat.{u1} (ConjAct.{u1} G₀) 0 (Zero.toOfNat0.{u1} (ConjAct.{u1} G₀) (MonoidWithZero.toZero.{u1} (ConjAct.{u1} G₀) (GroupWithZero.toMonoidWithZero.{u1} (ConjAct.{u1} G₀) (ConjAct.instGroupWithZeroConjAct.{u1} G₀ _inst_1)))))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G₀) => G₀) (OfNat.ofNat.{u1} (ConjAct.{u1} G₀) 0 (Zero.toOfNat0.{u1} (ConjAct.{u1} G₀) (MonoidWithZero.toZero.{u1} (ConjAct.{u1} G₀) (GroupWithZero.toMonoidWithZero.{u1} (ConjAct.{u1} G₀) (ConjAct.instGroupWithZeroConjAct.{u1} G₀ _inst_1)))))) 0 (Zero.toOfNat0.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G₀) => G₀) (OfNat.ofNat.{u1} (ConjAct.{u1} G₀) 0 (Zero.toOfNat0.{u1} (ConjAct.{u1} G₀) (MonoidWithZero.toZero.{u1} (ConjAct.{u1} G₀) (GroupWithZero.toMonoidWithZero.{u1} (ConjAct.{u1} G₀) (ConjAct.instGroupWithZeroConjAct.{u1} G₀ _inst_1)))))) (MonoidWithZero.toZero.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G₀) => G₀) (OfNat.ofNat.{u1} (ConjAct.{u1} G₀) 0 (Zero.toOfNat0.{u1} (ConjAct.{u1} G₀) (MonoidWithZero.toZero.{u1} (ConjAct.{u1} G₀) (GroupWithZero.toMonoidWithZero.{u1} (ConjAct.{u1} G₀) (ConjAct.instGroupWithZeroConjAct.{u1} G₀ _inst_1)))))) (GroupWithZero.toMonoidWithZero.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G₀) => G₀) (OfNat.ofNat.{u1} (ConjAct.{u1} G₀) 0 (Zero.toOfNat0.{u1} (ConjAct.{u1} G₀) (MonoidWithZero.toZero.{u1} (ConjAct.{u1} G₀) (GroupWithZero.toMonoidWithZero.{u1} (ConjAct.{u1} G₀) (ConjAct.instGroupWithZeroConjAct.{u1} G₀ _inst_1)))))) _inst_1))))
Case conversion may be inaccurate. Consider using '#align conj_act.of_conj_act_zero ConjAct.ofConjAct_zeroₓ'. -/
@[simp]
theorem ofConjAct_zero : ofConjAct (0 : ConjAct G₀) = 0 :=
  rfl
#align conj_act.of_conj_act_zero ConjAct.ofConjAct_zero

/- warning: conj_act.to_conj_act_zero -> ConjAct.toConjAct_zero is a dubious translation:
lean 3 declaration is
  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀], Eq.{succ u1} (ConjAct.{u1} G₀) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} G₀ (ConjAct.{u1} G₀) (MulOneClass.toHasMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.divInvMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))))) (fun (_x : MulEquiv.{u1, u1} G₀ (ConjAct.{u1} G₀) (MulOneClass.toHasMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.divInvMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))))) => G₀ -> (ConjAct.{u1} G₀)) (MulEquiv.hasCoeToFun.{u1, u1} G₀ (ConjAct.{u1} G₀) (MulOneClass.toHasMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.divInvMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))))) (ConjAct.toConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)) (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))))))) (OfNat.ofNat.{u1} (ConjAct.{u1} G₀) 0 (OfNat.mk.{u1} (ConjAct.{u1} G₀) 0 (Zero.zero.{u1} (ConjAct.{u1} G₀) (MulZeroClass.toHasZero.{u1} (ConjAct.{u1} G₀) (MulZeroOneClass.toMulZeroClass.{u1} (ConjAct.{u1} G₀) (MonoidWithZero.toMulZeroOneClass.{u1} (ConjAct.{u1} G₀) (GroupWithZero.toMonoidWithZero.{u1} (ConjAct.{u1} G₀) (ConjAct.groupWithZero.{u1} G₀ _inst_1))))))))
but is expected to have type
  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀], Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => ConjAct.{u1} G₀) (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G₀ (ConjAct.{u1} G₀) (MulOneClass.toMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))))) G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => ConjAct.{u1} G₀) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} G₀ (ConjAct.{u1} G₀) (MulOneClass.toMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))))) G₀ (ConjAct.{u1} G₀) (MulOneClass.toMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G₀ (ConjAct.{u1} G₀) (MulOneClass.toMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))))) G₀ (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} G₀ (ConjAct.{u1} G₀) (MulOneClass.toMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))))) G₀ (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} G₀ (ConjAct.{u1} G₀) (MulOneClass.toMul.{u1} G₀ (Monoid.toMulOneClass.{u1} G₀ (DivInvMonoid.toMonoid.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)))) (MulOneClass.toMul.{u1} (ConjAct.{u1} G₀) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G₀) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G₀) (ConjAct.instDivInvMonoidConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))))))))) (ConjAct.toConjAct.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)) (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1))))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => ConjAct.{u1} G₀) (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1))))) 0 (Zero.toOfNat0.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => ConjAct.{u1} G₀) (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1))))) (MonoidWithZero.toZero.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => ConjAct.{u1} G₀) (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1))))) (GroupWithZero.toMonoidWithZero.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => ConjAct.{u1} G₀) (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1))))) (ConjAct.instGroupWithZeroConjAct.{u1} G₀ _inst_1)))))
Case conversion may be inaccurate. Consider using '#align conj_act.to_conj_act_zero ConjAct.toConjAct_zeroₓ'. -/
@[simp]
theorem toConjAct_zero : toConjAct (0 : G₀) = 0 :=
  rfl
#align conj_act.to_conj_act_zero ConjAct.toConjAct_zero

#print ConjAct.mulAction₀ /-
instance mulAction₀ : MulAction (ConjAct G₀) G₀
    where
  smul := (· • ·)
  one_smul := by simp [smul_def]
  mul_smul := by simp [smul_def, mul_assoc, mul_inv_rev]
#align conj_act.mul_action₀ ConjAct.mulAction₀
-/

/- warning: conj_act.smul_comm_class₀ -> ConjAct.smulCommClass₀ is a dubious translation:
lean 3 declaration is
  forall (α : Type.{u1}) {G₀ : Type.{u2}} [_inst_1 : GroupWithZero.{u2} G₀] [_inst_2 : SMul.{u1, u2} α G₀] [_inst_3 : SMulCommClass.{u1, u2, u2} α G₀ G₀ _inst_2 (Mul.toSMul.{u2} G₀ (MulZeroClass.toHasMul.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)))))] [_inst_4 : IsScalarTower.{u1, u2, u2} α G₀ G₀ _inst_2 (Mul.toSMul.{u2} G₀ (MulZeroClass.toHasMul.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1))))) _inst_2], SMulCommClass.{u1, u2, u2} α (ConjAct.{u2} G₀) G₀ _inst_2 (ConjAct.hasSmul.{u2} G₀ (GroupWithZero.toDivInvMonoid.{u2} G₀ _inst_1))
but is expected to have type
  forall (α : Type.{u1}) {G₀ : Type.{u2}} [_inst_1 : GroupWithZero.{u2} G₀] [_inst_2 : SMul.{u1, u2} α G₀] [_inst_3 : SMulCommClass.{u1, u2, u2} α G₀ G₀ _inst_2 (SMulZeroClass.toSMul.{u2, u2} G₀ G₀ (MonoidWithZero.toZero.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)) (SMulWithZero.toSMulZeroClass.{u2, u2} G₀ G₀ (MonoidWithZero.toZero.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)) (MonoidWithZero.toZero.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)) (MulZeroClass.toSMulWithZero.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1))))))] [_inst_4 : IsScalarTower.{u1, u2, u2} α G₀ G₀ _inst_2 (SMulZeroClass.toSMul.{u2, u2} G₀ G₀ (MonoidWithZero.toZero.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)) (SMulWithZero.toSMulZeroClass.{u2, u2} G₀ G₀ (MonoidWithZero.toZero.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)) (MonoidWithZero.toZero.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)) (MulZeroClass.toSMulWithZero.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)))))) _inst_2], SMulCommClass.{u1, u2, u2} α (ConjAct.{u2} G₀) G₀ _inst_2 (ConjAct.instSMulConjAct.{u2} G₀ (GroupWithZero.toDivInvMonoid.{u2} G₀ _inst_1))
Case conversion may be inaccurate. Consider using '#align conj_act.smul_comm_class₀ ConjAct.smulCommClass₀ₓ'. -/
instance smulCommClass₀ [SMul α G₀] [SMulCommClass α G₀ G₀] [IsScalarTower α G₀ G₀] :
    SMulCommClass α (ConjAct G₀) G₀
    where smul_comm a ug g := by rw [smul_def, smul_def, mul_smul_comm, smul_mul_assoc]
#align conj_act.smul_comm_class₀ ConjAct.smulCommClass₀

/- warning: conj_act.smul_comm_class₀' -> ConjAct.smulCommClass₀' is a dubious translation:
lean 3 declaration is
  forall (α : Type.{u1}) {G₀ : Type.{u2}} [_inst_1 : GroupWithZero.{u2} G₀] [_inst_2 : SMul.{u1, u2} α G₀] [_inst_3 : SMulCommClass.{u2, u1, u2} G₀ α G₀ (Mul.toSMul.{u2} G₀ (MulZeroClass.toHasMul.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1))))) _inst_2] [_inst_4 : IsScalarTower.{u1, u2, u2} α G₀ G₀ _inst_2 (Mul.toSMul.{u2} G₀ (MulZeroClass.toHasMul.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1))))) _inst_2], SMulCommClass.{u2, u1, u2} (ConjAct.{u2} G₀) α G₀ (ConjAct.hasSmul.{u2} G₀ (GroupWithZero.toDivInvMonoid.{u2} G₀ _inst_1)) _inst_2
but is expected to have type
  forall (α : Type.{u1}) {G₀ : Type.{u2}} [_inst_1 : GroupWithZero.{u2} G₀] [_inst_2 : SMul.{u1, u2} α G₀] [_inst_3 : SMulCommClass.{u2, u1, u2} G₀ α G₀ (SMulZeroClass.toSMul.{u2, u2} G₀ G₀ (MonoidWithZero.toZero.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)) (SMulWithZero.toSMulZeroClass.{u2, u2} G₀ G₀ (MonoidWithZero.toZero.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)) (MonoidWithZero.toZero.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)) (MulZeroClass.toSMulWithZero.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)))))) _inst_2] [_inst_4 : IsScalarTower.{u1, u2, u2} α G₀ G₀ _inst_2 (SMulZeroClass.toSMul.{u2, u2} G₀ G₀ (MonoidWithZero.toZero.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)) (SMulWithZero.toSMulZeroClass.{u2, u2} G₀ G₀ (MonoidWithZero.toZero.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)) (MonoidWithZero.toZero.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)) (MulZeroClass.toSMulWithZero.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_1)))))) _inst_2], SMulCommClass.{u2, u1, u2} (ConjAct.{u2} G₀) α G₀ (ConjAct.instSMulConjAct.{u2} G₀ (GroupWithZero.toDivInvMonoid.{u2} G₀ _inst_1)) _inst_2
Case conversion may be inaccurate. Consider using '#align conj_act.smul_comm_class₀' ConjAct.smulCommClass₀'ₓ'. -/
instance smulCommClass₀' [SMul α G₀] [SMulCommClass G₀ α G₀] [IsScalarTower α G₀ G₀] :
    SMulCommClass (ConjAct G₀) α G₀ :=
  haveI := SMulCommClass.symm G₀ α G₀
  SMulCommClass.symm _ _ _
#align conj_act.smul_comm_class₀' ConjAct.smulCommClass₀'

end GroupWithZero

section DivisionRing

variable [DivisionRing K]

/- warning: conj_act.distrib_mul_action₀ -> ConjAct.distribMulAction₀ is a dubious translation:
lean 3 declaration is
  forall {K : Type.{u1}} [_inst_1 : DivisionRing.{u1} K], DistribMulAction.{u1, u1} (ConjAct.{u1} K) K (MonoidWithZero.toMonoid.{u1} (ConjAct.{u1} K) (GroupWithZero.toMonoidWithZero.{u1} (ConjAct.{u1} K) (ConjAct.groupWithZero.{u1} K (DivisionSemiring.toGroupWithZero.{u1} K (DivisionRing.toDivisionSemiring.{u1} K _inst_1))))) (AddMonoidWithOne.toAddMonoid.{u1} K (AddGroupWithOne.toAddMonoidWithOne.{u1} K (AddCommGroupWithOne.toAddGroupWithOne.{u1} K (Ring.toAddCommGroupWithOne.{u1} K (DivisionRing.toRing.{u1} K _inst_1)))))
but is expected to have type
  forall {K : Type.{u1}} [_inst_1 : DivisionRing.{u1} K], DistribMulAction.{u1, u1} (ConjAct.{u1} K) K (MonoidWithZero.toMonoid.{u1} (ConjAct.{u1} K) (GroupWithZero.toMonoidWithZero.{u1} (ConjAct.{u1} K) (ConjAct.instGroupWithZeroConjAct.{u1} K (DivisionSemiring.toGroupWithZero.{u1} K (DivisionRing.toDivisionSemiring.{u1} K _inst_1))))) (AddMonoidWithOne.toAddMonoid.{u1} K (AddGroupWithOne.toAddMonoidWithOne.{u1} K (Ring.toAddGroupWithOne.{u1} K (DivisionRing.toRing.{u1} K _inst_1))))
Case conversion may be inaccurate. Consider using '#align conj_act.distrib_mul_action₀ ConjAct.distribMulAction₀ₓ'. -/
instance distribMulAction₀ : DistribMulAction (ConjAct K) K :=
  { ConjAct.mulAction₀ with
    smul := (· • ·)
    smul_zero := by simp [smul_def]
    smul_add := by simp [smul_def, mul_add, add_mul] }
#align conj_act.distrib_mul_action₀ ConjAct.distribMulAction₀

end DivisionRing

variable [Group G]

instance : MulDistribMulAction (ConjAct G) G
    where
  smul := (· • ·)
  smul_mul := by simp [smul_def, mul_assoc]
  smul_one := by simp [smul_def]
  one_smul := by simp [smul_def]
  mul_smul := by simp [smul_def, mul_assoc]

/- warning: conj_act.smul_comm_class -> ConjAct.smulCommClass is a dubious translation:
lean 3 declaration is
  forall (α : Type.{u1}) {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : SMul.{u1, u2} α G] [_inst_3 : SMulCommClass.{u1, u2, u2} α G G _inst_2 (Mul.toSMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))))] [_inst_4 : IsScalarTower.{u1, u2, u2} α G G _inst_2 (Mul.toSMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) _inst_2], SMulCommClass.{u1, u2, u2} α (ConjAct.{u2} G) G _inst_2 (ConjAct.hasSmul.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))
but is expected to have type
  forall (α : Type.{u1}) {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : SMul.{u1, u2} α G] [_inst_3 : SMulCommClass.{u1, u2, u2} α G G _inst_2 (MulAction.toSMul.{u2, u2} G G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) (Monoid.toMulAction.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))] [_inst_4 : IsScalarTower.{u1, u2, u2} α G G _inst_2 (MulAction.toSMul.{u2, u2} G G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) (Monoid.toMulAction.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) _inst_2], SMulCommClass.{u1, u2, u2} α (ConjAct.{u2} G) G _inst_2 (ConjAct.instSMulConjAct.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))
Case conversion may be inaccurate. Consider using '#align conj_act.smul_comm_class ConjAct.smulCommClassₓ'. -/
instance smulCommClass [SMul α G] [SMulCommClass α G G] [IsScalarTower α G G] :
    SMulCommClass α (ConjAct G) G
    where smul_comm a ug g := by rw [smul_def, smul_def, mul_smul_comm, smul_mul_assoc]
#align conj_act.smul_comm_class ConjAct.smulCommClass

/- warning: conj_act.smul_comm_class' -> ConjAct.smulCommClass' is a dubious translation:
lean 3 declaration is
  forall (α : Type.{u1}) {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : SMul.{u1, u2} α G] [_inst_3 : SMulCommClass.{u2, u1, u2} G α G (Mul.toSMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) _inst_2] [_inst_4 : IsScalarTower.{u1, u2, u2} α G G _inst_2 (Mul.toSMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) _inst_2], SMulCommClass.{u2, u1, u2} (ConjAct.{u2} G) α G (ConjAct.hasSmul.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) _inst_2
but is expected to have type
  forall (α : Type.{u1}) {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : SMul.{u1, u2} α G] [_inst_3 : SMulCommClass.{u2, u1, u2} G α G (MulAction.toSMul.{u2, u2} G G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) (Monoid.toMulAction.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) _inst_2] [_inst_4 : IsScalarTower.{u1, u2, u2} α G G _inst_2 (MulAction.toSMul.{u2, u2} G G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) (Monoid.toMulAction.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) _inst_2], SMulCommClass.{u2, u1, u2} (ConjAct.{u2} G) α G (ConjAct.instSMulConjAct.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) _inst_2
Case conversion may be inaccurate. Consider using '#align conj_act.smul_comm_class' ConjAct.smulCommClass'ₓ'. -/
instance smulCommClass' [SMul α G] [SMulCommClass G α G] [IsScalarTower α G G] :
    SMulCommClass (ConjAct G) α G :=
  haveI := SMulCommClass.symm G α G
  SMulCommClass.symm _ _ _
#align conj_act.smul_comm_class' ConjAct.smulCommClass'

/- warning: conj_act.smul_eq_mul_aut_conj -> ConjAct.smul_eq_mulAut_conj is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : ConjAct.{u1} G) (h : G), Eq.{succ u1} G (SMul.smul.{u1, u1} (ConjAct.{u1} G) G (ConjAct.hasSmul.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) g h) (coeFn.{succ u1, succ u1} (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} G G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) => G -> G) (MulEquiv.hasCoeToFun.{u1, u1} G G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} G (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulAut.group.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))))) (fun (_x : MonoidHom.{u1, u1} G (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulAut.group.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))))) => G -> (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (MonoidHom.hasCoeToFun.{u1, u1} G (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulAut.group.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))))) (MulAut.conj.{u1} G _inst_1) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) => (ConjAct.{u1} G) -> G) (MulEquiv.hasCoeToFun.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toHasMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.ofConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) g)) h)
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : ConjAct.{u1} G) (h : G), Eq.{succ u1} G (HSMul.hSMul.{u1, u1, u1} (ConjAct.{u1} G) G G (instHSMul.{u1, u1} (ConjAct.{u1} G) G (ConjAct.instSMulConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) g h) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) (fun (a : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (ConjAct.ofConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) g)) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _x) (MulHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) (fun (a : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (ConjAct.ofConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) g)) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1)))) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) (fun (a : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (ConjAct.ofConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) g)) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) (fun (a : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (ConjAct.ofConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) g)) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1)))) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (MulAut.instGroupMulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))))))) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (fun (_x : (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) => MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (MulAut.instGroupMulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))))))) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1)))) (MulOneClass.toMul.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (MulAut.instGroupMulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (MulAut.instGroupMulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))))))) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (MulAut.instGroupMulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1)))))))) (MonoidHom.monoidHomClass.{u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))) (MulAut.instGroupMulAut.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (DivInvMonoid.toMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1))))))))))) (MulAut.conj.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) g) _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) (fun (_x : ConjAct.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : ConjAct.{u1} G) => G) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulEquivClass.instMonoidHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (ConjAct.{u1} G) G (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (ConjAct.{u1} G) G (MulOneClass.toMul.{u1} (ConjAct.{u1} G) (Monoid.toMulOneClass.{u1} (ConjAct.{u1} G) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (ConjAct.ofConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) g)) h)
Case conversion may be inaccurate. Consider using '#align conj_act.smul_eq_mul_aut_conj ConjAct.smul_eq_mulAut_conjₓ'. -/
theorem smul_eq_mulAut_conj (g : ConjAct G) (h : G) : g • h = MulAut.conj (ofConjAct g) h :=
  rfl
#align conj_act.smul_eq_mul_aut_conj ConjAct.smul_eq_mulAut_conj

/- warning: conj_act.fixed_points_eq_center -> ConjAct.fixedPoints_eq_center is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G], Eq.{succ u1} (Set.{u1} G) (MulAction.fixedPoints.{u1, u1} (ConjAct.{u1} G) G (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulDistribMulAction.toMulAction.{u1, u1} (ConjAct.{u1} G) G (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) (ConjAct.mulDistribMulAction.{u1} G _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} G _inst_1) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} G _inst_1) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} G _inst_1) (Set.{u1} G) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.center.{u1} G _inst_1))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G], Eq.{succ u1} (Set.{u1} G) (MulAction.fixedPoints.{u1, u1} (ConjAct.{u1} G) G (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (ConjAct.instMulActionConjActToMonoidInstDivInvMonoidConjActToDivInvMonoid.{u1} G _inst_1)) (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1))
Case conversion may be inaccurate. Consider using '#align conj_act.fixed_points_eq_center ConjAct.fixedPoints_eq_centerₓ'. -/
/-- The set of fixed points of the conjugation action of `G` on itself is the center of `G`. -/
theorem fixedPoints_eq_center : fixedPoints (ConjAct G) G = center G :=
  by
  ext x
  simp [mem_center_iff, smul_def, mul_inv_eq_iff_eq_mul]
#align conj_act.fixed_points_eq_center ConjAct.fixedPoints_eq_center

/- warning: conj_act.stabilizer_eq_centralizer -> ConjAct.stabilizer_eq_centralizer is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G), Eq.{succ u1} (Subgroup.{u1} (ConjAct.{u1} G) (ConjAct.group.{u1} G _inst_1)) (MulAction.stabilizer.{u1, u1} (ConjAct.{u1} G) G (ConjAct.group.{u1} G _inst_1) (MulDistribMulAction.toMulAction.{u1, u1} (ConjAct.{u1} G) G (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (Group.toDivInvMonoid.{u1} (ConjAct.{u1} G) (ConjAct.group.{u1} G _inst_1))) (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) (ConjAct.mulDistribMulAction.{u1} G _inst_1)) g) (Subgroup.centralizer.{u1} G (ConjAct.group.{u1} G _inst_1) (Subgroup.zpowers.{u1} G (ConjAct.group.{u1} G _inst_1) g))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G), Eq.{succ u1} (Subgroup.{u1} (ConjAct.{u1} G) (ConjAct.instGroupConjAct.{u1} G _inst_1)) (MulAction.stabilizer.{u1, u1} (ConjAct.{u1} G) G (ConjAct.instGroupConjAct.{u1} G _inst_1) (ConjAct.instMulActionConjActToMonoidInstDivInvMonoidConjActToDivInvMonoid.{u1} G (ConjAct.instGroupConjAct.{u1} G _inst_1)) g) (Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 g))
Case conversion may be inaccurate. Consider using '#align conj_act.stabilizer_eq_centralizer ConjAct.stabilizer_eq_centralizerₓ'. -/
theorem stabilizer_eq_centralizer (g : G) : stabilizer (ConjAct G) g = (zpowers g).centralizer :=
  le_antisymm (le_centralizer_iff.mp (zpowers_le.mpr fun x => mul_inv_eq_iff_eq_mul.mp)) fun x h =>
    mul_inv_eq_of_eq_mul (h g (mem_zpowers g)).symm
#align conj_act.stabilizer_eq_centralizer ConjAct.stabilizer_eq_centralizer

/- warning: conj_act.subgroup.conj_action -> ConjAct.Subgroup.conjAction is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [hH : Subgroup.Normal.{u1} G _inst_1 H], SMul.{u1, u1} (ConjAct.{u1} G) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H)
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [hH : Subgroup.Normal.{u1} G _inst_1 H], SMul.{u1, u1} (ConjAct.{u1} G) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H))
Case conversion may be inaccurate. Consider using '#align conj_act.subgroup.conj_action ConjAct.Subgroup.conjActionₓ'. -/
/-- As normal subgroups are closed under conjugation, they inherit the conjugation action
  of the underlying group. -/
instance Subgroup.conjAction {H : Subgroup G} [hH : H.Normal] : SMul (ConjAct G) H :=
  ⟨fun g h => ⟨g • h, hH.conj_mem h.1 h.2 (ofConjAct g)⟩⟩
#align conj_act.subgroup.conj_action ConjAct.Subgroup.conjAction

/- warning: conj_act.subgroup.coe_conj_smul -> ConjAct.Subgroup.val_conj_smul is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [hH : Subgroup.Normal.{u1} G _inst_1 H] (g : ConjAct.{u1} G) (h : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H), Eq.{succ u1} G ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x H))))) (SMul.smul.{u1, u1} (ConjAct.{u1} G) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (ConjAct.Subgroup.conjAction.{u1} G _inst_1 H hH) g h)) (SMul.smul.{u1, u1} (ConjAct.{u1} G) G (ConjAct.hasSmul.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x H))))) h))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [hH : Subgroup.Normal.{u1} G _inst_1 H] (g : ConjAct.{u1} G) (h : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)), Eq.{succ u1} G (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) H)) (HSMul.hSMul.{u1, u1, u1} (ConjAct.{u1} G) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (instHSMul.{u1, u1} (ConjAct.{u1} G) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (ConjAct.Subgroup.conjAction.{u1} G _inst_1 H hH)) g h)) (HSMul.hSMul.{u1, u1, u1} (ConjAct.{u1} G) G G (instHSMul.{u1, u1} (ConjAct.{u1} G) G (ConjAct.instSMulConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) g (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) H)) h))
Case conversion may be inaccurate. Consider using '#align conj_act.subgroup.coe_conj_smul ConjAct.Subgroup.val_conj_smulₓ'. -/
theorem Subgroup.val_conj_smul {H : Subgroup G} [hH : H.Normal] (g : ConjAct G) (h : H) :
    ↑(g • h) = g • (h : G) :=
  rfl
#align conj_act.subgroup.coe_conj_smul ConjAct.Subgroup.val_conj_smul

/- warning: conj_act.subgroup.conj_mul_distrib_mul_action -> ConjAct.Subgroup.conjMulDistribMulAction is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [hH : Subgroup.Normal.{u1} G _inst_1 H], MulDistribMulAction.{u1, u1} (ConjAct.{u1} G) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.divInvMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [hH : Subgroup.Normal.{u1} G _inst_1 H], MulDistribMulAction.{u1, u1} (ConjAct.{u1} G) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (ConjAct.{u1} G) (ConjAct.instDivInvMonoidConjAct.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Submonoid.toMonoid.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) (Subgroup.toSubmonoid.{u1} G _inst_1 H))
Case conversion may be inaccurate. Consider using '#align conj_act.subgroup.conj_mul_distrib_mul_action ConjAct.Subgroup.conjMulDistribMulActionₓ'. -/
instance Subgroup.conjMulDistribMulAction {H : Subgroup G} [hH : H.Normal] :
    MulDistribMulAction (ConjAct G) H :=
  Subtype.coe_injective.MulDistribMulAction H.Subtype Subgroup.val_conj_smul
#align conj_act.subgroup.conj_mul_distrib_mul_action ConjAct.Subgroup.conjMulDistribMulAction

/- warning: mul_aut.conj_normal -> MulAut.conjNormal is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [hH : Subgroup.Normal.{u1} G _inst_1 H], MonoidHom.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [hH : Subgroup.Normal.{u1} G _inst_1 H], MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))
Case conversion may be inaccurate. Consider using '#align mul_aut.conj_normal MulAut.conjNormalₓ'. -/
/-- Group conjugation on a normal subgroup. Analogous to `mul_aut.conj`. -/
def MulAut.conjNormal {H : Subgroup G} [hH : H.Normal] : G →* MulAut H :=
  (MulDistribMulAction.toMulAut (ConjAct G) H).comp toConjAct.toMonoidHom
#align mul_aut.conj_normal MulAut.conjNormal

/- warning: mul_aut.conj_normal_apply -> MulAut.conjNormal_apply is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [_inst_2 : Subgroup.Normal.{u1} G _inst_1 H] (g : G) (h : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H), Eq.{succ u1} G ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x H))))) (coeFn.{succ u1, succ u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (fun (_x : MulEquiv.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)) => (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) -> (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H)) (MulEquiv.hasCoeToFun.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))) (fun (_x : MonoidHom.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))) => G -> (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H))) (MonoidHom.hasCoeToFun.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))) (MulAut.conjNormal.{u1} G _inst_1 H _inst_2) g) h)) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x H))))) h)) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) g))
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [_inst_2 : Subgroup.Normal.{u1} G _inst_1 H] (g : G) (h : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)), Eq.{succ u1} G (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) H)) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) g) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (fun (_x : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) => Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) _x) (MulHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) g) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H) (MulEquivClass.instMulHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) g) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H))))) (MonoidHom.monoidHomClass.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))))) (MulAut.conjNormal.{u1} G _inst_1 H _inst_2) g) h)) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) g (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) H)) h)) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) g))
Case conversion may be inaccurate. Consider using '#align mul_aut.conj_normal_apply MulAut.conjNormal_applyₓ'. -/
@[simp]
theorem MulAut.conjNormal_apply {H : Subgroup G} [H.Normal] (g : G) (h : H) :
    ↑(MulAut.conjNormal g h) = g * h * g⁻¹ :=
  rfl
#align mul_aut.conj_normal_apply MulAut.conjNormal_apply

/- warning: mul_aut.conj_normal_symm_apply -> MulAut.conjNormal_symm_apply is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [_inst_2 : Subgroup.Normal.{u1} G _inst_1 H] (g : G) (h : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H), Eq.{succ u1} G ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x H))))) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)) (fun (_x : MulEquiv.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)) => (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) -> (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H)) (MulEquiv.hasCoeToFun.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)) (MulEquiv.symm.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))) (fun (_x : MonoidHom.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))) => G -> (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H))) (MonoidHom.hasCoeToFun.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))) (MulAut.conjNormal.{u1} G _inst_1 H _inst_2) g)) h)) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) g) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x H))))) h)) g)
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [_inst_2 : Subgroup.Normal.{u1} G _inst_1 H] (g : G) (h : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)), Eq.{succ u1} G (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) H)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (fun (_x : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) => Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulEquiv.{u1, u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H) (MulEquivClass.instMulHomClass.{u1, u1, u1} (MulEquiv.{u1, u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)))) (MulEquiv.symm.{u1, u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H))))) (MonoidHom.monoidHomClass.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))))) (MulAut.conjNormal.{u1} G _inst_1 H _inst_2) g)) h)) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) g) (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) H)) h)) g)
Case conversion may be inaccurate. Consider using '#align mul_aut.conj_normal_symm_apply MulAut.conjNormal_symm_applyₓ'. -/
@[simp]
theorem MulAut.conjNormal_symm_apply {H : Subgroup G} [H.Normal] (g : G) (h : H) :
    ↑((MulAut.conjNormal g).symm h) = g⁻¹ * h * g :=
  by
  change _ * _⁻¹⁻¹ = _
  rw [inv_inv]
  rfl
#align mul_aut.conj_normal_symm_apply MulAut.conjNormal_symm_apply

/- warning: mul_aut.conj_normal_inv_apply -> MulAut.conjNormal_inv_apply is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [_inst_2 : Subgroup.Normal.{u1} G _inst_1 H] (g : G) (h : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H), Eq.{succ u1} G ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x H))))) (coeFn.{succ u1, succ u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (fun (_x : MulEquiv.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)) => (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) -> (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H)) (MulEquiv.hasCoeToFun.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)) (Inv.inv.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toHasInv.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))) (fun (_x : MonoidHom.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))) => G -> (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H))) (MonoidHom.hasCoeToFun.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))) (MulAut.conjNormal.{u1} G _inst_1 H _inst_2) g)) h)) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) g) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x H))))) h)) g)
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [_inst_2 : Subgroup.Normal.{u1} G _inst_1 H] (g : G) (h : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)), Eq.{succ u1} G (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) H)) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) g) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (fun (_x : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) => Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) _x) (MulHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) g) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H) (MulEquivClass.instMulHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) g) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H) (Subgroup.mul.{u1} G _inst_1 H)))) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) g) (InvOneClass.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) g) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) g) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) g) (Group.toDivisionMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) g) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H))))) (MonoidHom.monoidHomClass.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))))) (MulAut.conjNormal.{u1} G _inst_1 H _inst_2) g)) h)) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) g) (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) H)) h)) g)
Case conversion may be inaccurate. Consider using '#align mul_aut.conj_normal_inv_apply MulAut.conjNormal_inv_applyₓ'. -/
@[simp]
theorem MulAut.conjNormal_inv_apply {H : Subgroup G} [H.Normal] (g : G) (h : H) :
    ↑((MulAut.conjNormal g)⁻¹ h) = g⁻¹ * h * g :=
  MulAut.conjNormal_symm_apply g h
#align mul_aut.conj_normal_inv_apply MulAut.conjNormal_inv_apply

/- warning: mul_aut.conj_normal_coe -> MulAut.conjNormal_val is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [_inst_2 : Subgroup.Normal.{u1} G _inst_1 H] {h : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H}, Eq.{succ u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))) (fun (_x : MonoidHom.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))) => G -> (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H))) (MonoidHom.hasCoeToFun.{u1, u1} G (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.mul.{u1} G _inst_1 H)))))) (MulAut.conjNormal.{u1} G _inst_1 H _inst_2) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x H))))) h)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))))))) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))))))) => (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) -> (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H))))))) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (MulAut.group.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (MulOneClass.toHasMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)))))))))) (MulAut.conj.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)) h)
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [_inst_2 : Subgroup.Normal.{u1} G _inst_1 H] {h : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) H)) h)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))) G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H))))) (MonoidHom.monoidHomClass.{u1, u1} G (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.mul.{u1} G _inst_1 H)))))))) (MulAut.conjNormal.{u1} G _inst_1 H _inst_2) (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) H)) h)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))))))) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (fun (_x : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) => MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))))))) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H))))) (MulOneClass.toMul.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))))))) (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H))))))))) (MonoidHom.monoidHomClass.{u1, u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))) (Monoid.toMulOneClass.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (DivInvMonoid.toMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (Group.toDivInvMonoid.{u1} (MulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))) (MulAut.instGroupMulAut.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (MulOneClass.toMul.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Monoid.toMulOneClass.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (DivInvMonoid.toMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Group.toDivInvMonoid.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)))))))))))) (MulAut.conj.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)) h)
Case conversion may be inaccurate. Consider using '#align mul_aut.conj_normal_coe MulAut.conjNormal_valₓ'. -/
theorem MulAut.conjNormal_val {H : Subgroup G} [H.Normal] {h : H} :
    MulAut.conjNormal ↑h = MulAut.conj h :=
  MulEquiv.ext fun x => rfl
#align mul_aut.conj_normal_coe MulAut.conjNormal_val

/- warning: conj_act.normal_of_characteristic_of_normal -> ConjAct.normal_of_characteristic_of_normal is a dubious translation:
lean 3 declaration is
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [hH : Subgroup.Normal.{u1} G _inst_1 H] {K : Subgroup.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H)} [h : Subgroup.Characteristic.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H) K], Subgroup.Normal.{u1} G _inst_1 (Subgroup.map.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) H) (Subgroup.toGroup.{u1} G _inst_1 H) G _inst_1 (Subgroup.subtype.{u1} G _inst_1 H) K)
but is expected to have type
  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {H : Subgroup.{u1} G _inst_1} [hH : Subgroup.Normal.{u1} G _inst_1 H] {K : Subgroup.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H)} [h : Subgroup.Characteristic.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H) K], Subgroup.Normal.{u1} G _inst_1 (Subgroup.map.{u1, u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x H)) (Subgroup.toGroup.{u1} G _inst_1 H) G _inst_1 (Subgroup.subtype.{u1} G _inst_1 H) K)
Case conversion may be inaccurate. Consider using '#align conj_act.normal_of_characteristic_of_normal ConjAct.normal_of_characteristic_of_normalₓ'. -/
instance normal_of_characteristic_of_normal {H : Subgroup G} [hH : H.Normal] {K : Subgroup H}
    [h : K.Characteristic] : (K.map H.Subtype).Normal :=
  ⟨fun a ha b => by
    obtain ⟨a, ha, rfl⟩ := ha
    exact
      K.apply_coe_mem_map H.subtype
        ⟨_, (set_like.ext_iff.mp (h.fixed (MulAut.conjNormal b)) a).mpr ha⟩⟩
#align conj_act.normal_of_characteristic_of_normal ConjAct.normal_of_characteristic_of_normal

end ConjAct