l3lab/ntp-mathlib huggingface dataset:
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  

Proof state:
case refine'_2.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
a✝ : AddAut A
x✝ : A
⊢ (1 * a✝) x✝ = a✝ x✝

Next tactic:
try rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  try 

Proof state:
case refine'_2.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
a✝ : AddAut A
x✝ : A
⊢ (1 * a✝) x✝ = a✝ x✝

Next tactic:
rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  

Proof state:
case refine'_3.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
a✝ : AddAut A
x✝ : A
⊢ (a✝ * 1) x✝ = a✝ x✝

Next tactic:
try rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  try 

Proof state:
case refine'_3.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
a✝ : AddAut A
x✝ : A
⊢ (a✝ * 1) x✝ = a✝ x✝

Next tactic:
rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  

Proof state:
case refine'_4.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
x✝¹ : AddAut A
x✝ : A
⊢ (npowRec 0 x✝¹) x✝ = 1 x✝

Next tactic:
try rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  try 

Proof state:
case refine'_4.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
x✝¹ : AddAut A
x✝ : A
⊢ (npowRec 0 x✝¹) x✝ = 1 x✝

Next tactic:
rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  

Proof state:
case refine'_5.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
n✝ : ℕ
x✝¹ : AddAut A
x✝ : A
⊢ (npowRec (n✝ + 1) x✝¹) x✝ = (x✝¹ * npowRec n✝ x✝¹) x✝

Next tactic:
try rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  try 

Proof state:
case refine'_5.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
n✝ : ℕ
x✝¹ : AddAut A
x✝ : A
⊢ (npowRec (n✝ + 1) x✝¹) x✝ = (x✝¹ * npowRec n✝ x✝¹) x✝

Next tactic:
rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  

Proof state:
case refine'_6.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
a✝ b✝ : AddAut A
x✝ : A
⊢ (a✝ / b✝) x✝ = (a✝ * b✝⁻¹) x✝

Next tactic:
try rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  try 

Proof state:
case refine'_6.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
a✝ b✝ : AddAut A
x✝ : A
⊢ (a✝ / b✝) x✝ = (a✝ * b✝⁻¹) x✝

Next tactic:
rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  

Proof state:
case refine'_7.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
a✝ : AddAut A
x✝ : A
⊢ (zpowRec 0 a✝) x✝ = 1 x✝

Next tactic:
try rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  try 

Proof state:
case refine'_7.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
a✝ : AddAut A
x✝ : A
⊢ (zpowRec 0 a✝) x✝ = 1 x✝

Next tactic:
rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  

Proof state:
case refine'_8.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
n✝ : ℕ
a✝ : AddAut A
x✝ : A
⊢ (zpowRec (Int.ofNat (Nat.succ n✝)) a✝) x✝ = (a✝ * zpowRec (Int.ofNat n✝) a✝) x✝

Next tactic:
try rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  try 

Proof state:
case refine'_8.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
n✝ : ℕ
a✝ : AddAut A
x✝ : A
⊢ (zpowRec (Int.ofNat (Nat.succ n✝)) a✝) x✝ = (a✝ * zpowRec (Int.ofNat n✝) a✝) x✝

Next tactic:
rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  

Proof state:
case refine'_9.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
n✝ : ℕ
a✝ : AddAut A
x✝ : A
⊢ (zpowRec (Int.negSucc n✝) a✝) x✝ = (zpowRec (↑(Nat.succ n✝)) a✝)⁻¹ x✝

Next tactic:
try rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  try 

Proof state:
case refine'_9.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
n✝ : ℕ
a✝ : AddAut A
x✝ : A
⊢ (zpowRec (Int.negSucc n✝) a✝) x✝ = (zpowRec (↑(Nat.succ n✝)) a✝)⁻¹ x✝

Next tactic:
rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  

Proof state:
case refine'_10.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
a✝ : AddAut A
x✝ : A
⊢ (a✝⁻¹ * a✝) x✝ = 1 x✝

Next tactic:
try rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  try 

Proof state:
case refine'_10.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
a✝ : AddAut A
x✝ : A
⊢ (a✝⁻¹ * a✝) x✝ = 1 x✝

Next tactic:
rfl
/-- The group operation on additive automorphisms is defined by `g h => AddEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`.
-/
instance group : Group (AddAut A) := by
  refine'
  { mul := fun g h => AddEquiv.trans h g
    one := AddEquiv.refl A
    inv := AddEquiv.symm
    div := fun g h => AddEquiv.trans h.symm g
    npow := @npowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩
    zpow := @zpowRec _ ⟨AddEquiv.refl A⟩ ⟨fun g h => AddEquiv.trans h g⟩ ⟨AddEquiv.symm⟩
    .. } <;>
  intros <;>
  ext <;>
  try rfl
  

Proof state:
case refine'_10.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
a✝ : AddAut A
x✝ : A
⊢ (a✝⁻¹ * a✝) x✝ = 1 x✝

Next tactic:
apply Equiv.left_inv
/-- Monoid hom from the group of multiplicative automorphisms to the group of permutations. -/
def toPerm : AddAut A →* Equiv.Perm A := by
  

Proof state:
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
⊢ AddAut A →* Equiv.Perm A

Next tactic:
refine' { toFun := AddEquiv.toEquiv, .. }
/-- Monoid hom from the group of multiplicative automorphisms to the group of permutations. -/
def toPerm : AddAut A →* Equiv.Perm A := by
  refine' { toFun := AddEquiv.toEquiv, .. } <;> 

Proof state:
case refine'_1
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
⊢ 1.toEquiv = 1

Next tactic:
intros
/-- Monoid hom from the group of multiplicative automorphisms to the group of permutations. -/
def toPerm : AddAut A →* Equiv.Perm A := by
  refine' { toFun := AddEquiv.toEquiv, .. } <;> 

Proof state:
case refine'_2
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
⊢ ∀ (x y : AddAut A),
    OneHom.toFun { toFun := AddEquiv.toEquiv, map_one' := ?refine'_1 } (x * y) =
      OneHom.toFun { toFun := AddEquiv.toEquiv, map_one' := ?refine'_1 } x *
        OneHom.toFun { toFun := AddEquiv.toEquiv, map_one' := ?refine'_1 } y

Next tactic:
intros
/-- Monoid hom from the group of multiplicative automorphisms to the group of permutations. -/
def toPerm : AddAut A →* Equiv.Perm A := by
  refine' { toFun := AddEquiv.toEquiv, .. } <;> intros <;> 

Proof state:
case refine'_1
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
⊢ 1.toEquiv = 1

Next tactic:
rfl
/-- Monoid hom from the group of multiplicative automorphisms to the group of permutations. -/
def toPerm : AddAut A →* Equiv.Perm A := by
  refine' { toFun := AddEquiv.toEquiv, .. } <;> intros <;> 

Proof state:
case refine'_2
A : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Add A
x✝ y✝ : AddAut A
⊢ OneHom.toFun { toFun := AddEquiv.toEquiv, map_one' := (_ : 1.toEquiv = 1.toEquiv) } (x✝ * y✝) =
    OneHom.toFun { toFun := AddEquiv.toEquiv, map_one' := (_ : 1.toEquiv = 1.toEquiv) } x✝ *
      OneHom.toFun { toFun := AddEquiv.toEquiv, map_one' := (_ : 1.toEquiv = 1.toEquiv) } y✝

Next tactic:
rfl
/-- Additive group conjugation, `AddAut.conj g h = g + h - g`, as an additive monoid
homomorphism mapping addition in `G` into multiplication in the automorphism group `AddAut G`
(written additively in order to define the map). -/
def conj [AddGroup G] : G →+ Additive (AddAut G) where
  toFun g :=
    @Additive.ofMul (AddAut G)
      { toFun := fun h => g + h + -g
        -- this definition is chosen to match `MulAut.conj`
        invFun := fun h => -g + h + g
        left_inv := fun _ => by 

Proof state:
A : Type u_1
M : Type u_2
G : Type u_3
inst✝¹ : Add A
inst✝ : AddGroup G
g x✝ : G
⊢ (fun h => -g + h + g) ((fun h => g + h + -g) x✝) = x✝

Next tactic:
simp only [add_assoc, neg_add_cancel_left, add_left_neg, add_zero]
/-- Additive group conjugation, `AddAut.conj g h = g + h - g`, as an additive monoid
homomorphism mapping addition in `G` into multiplication in the automorphism group `AddAut G`
(written additively in order to define the map). -/
def conj [AddGroup G] : G →+ Additive (AddAut G) where
  toFun g :=
    @Additive.ofMul (AddAut G)
      { toFun := fun h => g + h + -g
        -- this definition is chosen to match `MulAut.conj`
        invFun := fun h => -g + h + g
        left_inv := fun _ => by simp only [add_assoc, neg_add_cancel_left, add_left_neg, add_zero]
        right_inv := fun _ => by 

Proof state:
A : Type u_1
M : Type u_2
G : Type u_3
inst✝¹ : Add A
inst✝ : AddGroup G
g x✝ : G
⊢ (fun h => g + h + -g) ((fun h => -g + h + g) x✝) = x✝

Next tactic:
simp only [add_assoc, add_neg_cancel_left, add_right_neg, add_zero]
/-- Additive group conjugation, `AddAut.conj g h = g + h - g`, as an additive monoid
homomorphism mapping addition in `G` into multiplication in the automorphism group `AddAut G`
(written additively in order to define the map). -/
def conj [AddGroup G] : G →+ Additive (AddAut G) where
  toFun g :=
    @Additive.ofMul (AddAut G)
      { toFun := fun h => g + h + -g
        -- this definition is chosen to match `MulAut.conj`
        invFun := fun h => -g + h + g
        left_inv := fun _ => by simp only [add_assoc, neg_add_cancel_left, add_left_neg, add_zero]
        right_inv := fun _ => by simp only [add_assoc, add_neg_cancel_left, add_right_neg, add_zero]
        map_add' := by 

Proof state:
A : Type u_1
M : Type u_2
G : Type u_3
inst✝¹ : Add A
inst✝ : AddGroup G
g : G
⊢ ∀ (x y : G),
    Equiv.toFun
        { toFun := fun h => g + h + -g, invFun := fun h => -g + h + g,
          left_inv := (_ : ∀ (x : G), -g + (g + x + -g) + g = x),
          right_inv := (_ : ∀ (x : G), g + (-g + x + g) + -g = x) }
        (x + y) =
      Equiv.toFun
          { toFun := fun h => g + h + -g, invFun := fun h => -g + h + g,
            left_inv := (_ : ∀ (x : G), -g + (g + x + -g) + g = x),
            right_inv := (_ : ∀ (x : G), g + (-g + x + g) + -g = x) }
          x +
        Equiv.toFun
          { toFun := fun h => g + h + -g, invFun := fun h => -g + h + g,
            left_inv := (_ : ∀ (x : G), -g + (g + x + -g) + g = x),
            right_inv := (_ : ∀ (x : G), g + (-g + x + g) + -g = x) }
          y

Next tactic:
simp only [add_assoc, neg_add_cancel_left, forall_const]
/-- Additive group conjugation, `AddAut.conj g h = g + h - g`, as an additive monoid
homomorphism mapping addition in `G` into multiplication in the automorphism group `AddAut G`
(written additively in order to define the map). -/
def conj [AddGroup G] : G →+ Additive (AddAut G) where
  toFun g :=
    @Additive.ofMul (AddAut G)
      { toFun := fun h => g + h + -g
        -- this definition is chosen to match `MulAut.conj`
        invFun := fun h => -g + h + g
        left_inv := fun _ => by simp only [add_assoc, neg_add_cancel_left, add_left_neg, add_zero]
        right_inv := fun _ => by simp only [add_assoc, add_neg_cancel_left, add_right_neg, add_zero]
        map_add' := by simp only [add_assoc, neg_add_cancel_left, forall_const] }
  map_add' g₁ g₂ := by
    apply Additive.toMul.injective; ext h
    show g₁ + g₂ + h + -(g₁ + g₂) = g₁ + (g₂ + h + -g₂) + -g₁
    simp only [add_assoc, neg_add_rev]
  map_zero' := by
    

Proof state:
A : Type u_1
M : Type u_2
G : Type u_3
inst✝¹ : Add A
inst✝ : AddGroup G
⊢ (fun g =>
        Additive.ofMul
          {
            toEquiv :=
              { toFun := fun h => g + h + -g, invFun := fun h => -g + h + g,
                left_inv := (_ : ∀ (x : G), -g + (g + x + -g) + g = x),
                right_inv := (_ : ∀ (x : G), g + (-g + x + g) + -g = x) },
            map_add' := (_ : ∀ (a a_1 : G), g + (a + a_1) + -g = g + a + -g + (g + a_1 + -g)) })
      0 =
    0

Next tactic:
apply Additive.toMul.injective
/-- Additive group conjugation, `AddAut.conj g h = g + h - g`, as an additive monoid
homomorphism mapping addition in `G` into multiplication in the automorphism group `AddAut G`
(written additively in order to define the map). -/
def conj [AddGroup G] : G →+ Additive (AddAut G) where
  toFun g :=
    @Additive.ofMul (AddAut G)
      { toFun := fun h => g + h + -g
        -- this definition is chosen to match `MulAut.conj`
        invFun := fun h => -g + h + g
        left_inv := fun _ => by simp only [add_assoc, neg_add_cancel_left, add_left_neg, add_zero]
        right_inv := fun _ => by simp only [add_assoc, add_neg_cancel_left, add_right_neg, add_zero]
        map_add' := by simp only [add_assoc, neg_add_cancel_left, forall_const] }
  map_add' g₁ g₂ := by
    apply Additive.toMul.injective; ext h
    show g₁ + g₂ + h + -(g₁ + g₂) = g₁ + (g₂ + h + -g₂) + -g₁
    simp only [add_assoc, neg_add_rev]
  map_zero' := by
    apply Additive.toMul.injective; 

Proof state:
case a
A : Type u_1
M : Type u_2
G : Type u_3
inst✝¹ : Add A
inst✝ : AddGroup G
⊢ Additive.toMul
      ((fun g =>
          Additive.ofMul
            {
              toEquiv :=
                { toFun := fun h => g + h + -g, invFun := fun h => -g + h + g,
                  left_inv := (_ : ∀ (x : G), -g + (g + x + -g) + g = x),
                  right_inv := (_ : ∀ (x : G), g + (-g + x + g) + -g = x) },
              map_add' := (_ : ∀ (a a_1 : G), g + (a + a_1) + -g = g + a + -g + (g + a_1 + -g)) })
        0) =
    Additive.toMul 0

Next tactic:
ext
/-- Additive group conjugation, `AddAut.conj g h = g + h - g`, as an additive monoid
homomorphism mapping addition in `G` into multiplication in the automorphism group `AddAut G`
(written additively in order to define the map). -/
def conj [AddGroup G] : G →+ Additive (AddAut G) where
  toFun g :=
    @Additive.ofMul (AddAut G)
      { toFun := fun h => g + h + -g
        -- this definition is chosen to match `MulAut.conj`
        invFun := fun h => -g + h + g
        left_inv := fun _ => by simp only [add_assoc, neg_add_cancel_left, add_left_neg, add_zero]
        right_inv := fun _ => by simp only [add_assoc, add_neg_cancel_left, add_right_neg, add_zero]
        map_add' := by simp only [add_assoc, neg_add_cancel_left, forall_const] }
  map_add' g₁ g₂ := by
    apply Additive.toMul.injective; ext h
    show g₁ + g₂ + h + -(g₁ + g₂) = g₁ + (g₂ + h + -g₂) + -g₁
    simp only [add_assoc, neg_add_rev]
  map_zero' := by
    apply Additive.toMul.injective; ext
    

Proof state:
case a.h
A : Type u_1
M : Type u_2
G : Type u_3
inst✝¹ : Add A
inst✝ : AddGroup G
x✝ : G
⊢ (Additive.toMul
        ((fun g =>
            Additive.ofMul
              {
                toEquiv :=
                  { toFun := fun h => g + h + -g, invFun := fun h => -g + h + g,
                    left_inv := (_ : ∀ (x : G), -g + (g + x + -g) + g = x),
                    right_inv := (_ : ∀ (x : G), g + (-g + x + g) + -g = x) },
                map_add' := (_ : ∀ (a a_1 : G), g + (a + a_1) + -g = g + a + -g + (g + a_1 + -g)) })
          0))
      x✝ =
    (Additive.toMul 0) x✝

Next tactic:
simp only [zero_add, neg_zero, add_zero, toMul_ofMul, toMul_zero, one_apply]