group_theory.free_abelian_group | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

dc6c365e

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

10bf4f82

bump to nightly-2024-04-06-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

e34029c9

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2018 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
 -/
-import Algebra.Group.Pi
-import GroupTheory.FreeGroup
+import Algebra.Group.Pi.Lemmas
+import GroupTheory.FreeGroup.Basic
 import GroupTheory.Abelianization
 import Algebra.Module.Basic

10bf4f82

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2018 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
 -/
-import Mathbin.Algebra.Group.Pi
-import Mathbin.GroupTheory.FreeGroup
-import Mathbin.GroupTheory.Abelianization
-import Mathbin.Algebra.Module.Basic
+import Algebra.Group.Pi
+import GroupTheory.FreeGroup
+import GroupTheory.Abelianization
+import Algebra.Module.Basic
 
 #align_import group_theory.free_abelian_group from "leanprover-community/mathlib"@"10bf4f825ad729c5653adc039dafa3622e7f93c9"

10bf4f82

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2018 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
-
-! This file was ported from Lean 3 source module group_theory.free_abelian_group
-! leanprover-community/mathlib commit 10bf4f825ad729c5653adc039dafa3622e7f93c9
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Group.Pi
 import Mathbin.GroupTheory.FreeGroup
 import Mathbin.GroupTheory.Abelianization
 import Mathbin.Algebra.Module.Basic
 
+#align_import group_theory.free_abelian_group from "leanprover-community/mathlib"@"10bf4f825ad729c5653adc039dafa3622e7f93c9"
+
 /-!
 # Free abelian groups

10bf4f82

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -116,24 +116,31 @@ variable {β : Type v} [AddCommGroup β] (f : α → β)
 
 open FreeAbelianGroup
 
+#print FreeAbelianGroup.lift.of /-
 @[simp]
 protected theorem of (x : α) : lift f (of x) = f x :=
   by
   convert @Abelianization.lift.of (FreeGroup α) _ (Multiplicative β) _ _ _
   convert free_group.lift.of.symm
 #align free_abelian_group.lift.of FreeAbelianGroup.lift.of
+-/
 
+#print FreeAbelianGroup.lift.unique /-
 protected theorem unique (g : FreeAbelianGroup α →+ β) (hg : ∀ x, g (of x) = f x) {x} :
     g x = lift f x :=
   AddMonoidHom.congr_fun (lift.symm_apply_eq.mp (funext hg : g ∘ of = f)) _
 #align free_abelian_group.lift.unique FreeAbelianGroup.lift.unique
+-/
 
+#print FreeAbelianGroup.lift.ext /-
 /-- See note [partially-applied ext lemmas]. -/
 @[ext]
 protected theorem ext (g h : FreeAbelianGroup α →+ β) (H : ∀ x, g (of x) = h (of x)) : g = h :=
   lift.symm.Injective <| funext H
 #align free_abelian_group.lift.ext FreeAbelianGroup.lift.ext
+-/
 
+#print FreeAbelianGroup.lift.map_hom /-
 theorem map_hom {α β γ} [AddCommGroup β] [AddCommGroup γ] (a : FreeAbelianGroup α) (f : α → β)
     (g : β →+ γ) : g (lift f a) = lift (g ∘ f) a :=
   by
@@ -144,6 +151,7 @@ theorem map_hom {α β γ} [AddCommGroup β] [AddCommGroup γ] (a : FreeAbelianG
   show g ((lift f) (of a)) = g (f a)
   simp only [(· ∘ ·), lift.of]
 #align free_abelian_group.lift.map_hom FreeAbelianGroup.lift.map_hom
+-/
 
 end lift
 
@@ -166,6 +174,7 @@ end
 
 attribute [local instance] QuotientGroup.leftRel
 
+#print FreeAbelianGroup.induction_on /-
 @[elab_as_elim]
 protected theorem induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α) (C0 : C 0)
     (C1 : ∀ x, C <| of x) (Cn : ∀ x, C (of x) → C (-of x)) (Cp : ∀ x y, C x → C y → C (x + y)) :
@@ -174,7 +183,9 @@ protected theorem induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbeli
     Quot.inductionOn x fun L =>
       List.recOn L C0 fun ⟨x, b⟩ tl ih => Bool.recOn b (Cp _ _ (Cn _ (C1 x)) ih) (Cp _ _ (C1 x) ih)
 #align free_abelian_group.induction_on FreeAbelianGroup.induction_on
+-/
 
+#print FreeAbelianGroup.lift.add' /-
 theorem lift.add' {α β} [AddCommGroup β] (a : FreeAbelianGroup α) (f g : α → β) :
     lift (f + g) a = lift f a + lift g a :=
   by
@@ -187,6 +198,7 @@ theorem lift.add' {α β} [AddCommGroup β] (a : FreeAbelianGroup α) (f g : α
   · intro x y hx hy
     simp only [(lift _).map_add, hx, hy, add_add_add_comm]
 #align free_abelian_group.lift.add' FreeAbelianGroup.lift.add'
+-/
 
 #print FreeAbelianGroup.liftAddGroupHom /-
 /-- If `g : free_abelian_group X` and `A` is an abelian group then `lift_add_group_hom g`
@@ -198,9 +210,11 @@ def liftAddGroupHom {α} (β) [AddCommGroup β] (a : FreeAbelianGroup α) : (α
 #align free_abelian_group.lift_add_group_hom FreeAbelianGroup.liftAddGroupHom
 -/
 
+#print FreeAbelianGroup.lift_neg' /-
 theorem lift_neg' {β} [AddCommGroup β] (f : α → β) : lift (-f) = -lift f :=
   AddMonoidHom.ext fun _ => (liftAddGroupHom _ _ : (α → β) →+ β).map_neg _
 #align free_abelian_group.lift_neg' FreeAbelianGroup.lift_neg'
+-/
 
 section Monad
 
@@ -210,98 +224,132 @@ instance : Monad FreeAbelianGroup.{u} where
   pure α := of
   bind α β x f := lift f x
 
+#print FreeAbelianGroup.induction_on' /-
 @[elab_as_elim]
 protected theorem induction_on' {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α) (C0 : C 0)
     (C1 : ∀ x, C <| pure x) (Cn : ∀ x, C (pure x) → C (-pure x))
     (Cp : ∀ x y, C x → C y → C (x + y)) : C z :=
   FreeAbelianGroup.induction_on z C0 C1 Cn Cp
 #align free_abelian_group.induction_on' FreeAbelianGroup.induction_on'
+-/
 
+#print FreeAbelianGroup.map_pure /-
 @[simp]
 theorem map_pure (f : α → β) (x : α) : f <$> (pure x : FreeAbelianGroup α) = pure (f x) :=
   rfl
 #align free_abelian_group.map_pure FreeAbelianGroup.map_pure
+-/
 
+#print FreeAbelianGroup.map_zero /-
 @[simp]
 protected theorem map_zero (f : α → β) : f <$> (0 : FreeAbelianGroup α) = 0 :=
   (lift (of ∘ f)).map_zero
 #align free_abelian_group.map_zero FreeAbelianGroup.map_zero
+-/
 
+#print FreeAbelianGroup.map_add /-
 @[simp]
 protected theorem map_add (f : α → β) (x y : FreeAbelianGroup α) :
     f <$> (x + y) = f <$> x + f <$> y :=
   (lift _).map_add _ _
 #align free_abelian_group.map_add FreeAbelianGroup.map_add
+-/
 
+#print FreeAbelianGroup.map_neg /-
 @[simp]
 protected theorem map_neg (f : α → β) (x : FreeAbelianGroup α) : f <$> (-x) = -f <$> x :=
   map_neg (lift <| of ∘ f) _
 #align free_abelian_group.map_neg FreeAbelianGroup.map_neg
+-/
 
+#print FreeAbelianGroup.map_sub /-
 @[simp]
 protected theorem map_sub (f : α → β) (x y : FreeAbelianGroup α) :
     f <$> (x - y) = f <$> x - f <$> y :=
   map_sub (lift <| of ∘ f) _ _
 #align free_abelian_group.map_sub FreeAbelianGroup.map_sub
+-/
 
+#print FreeAbelianGroup.map_of /-
 @[simp]
 theorem map_of (f : α → β) (y : α) : f <$> of y = of (f y) :=
   rfl
 #align free_abelian_group.map_of FreeAbelianGroup.map_of
+-/
 
+#print FreeAbelianGroup.pure_bind /-
 @[simp]
 theorem pure_bind (f : α → FreeAbelianGroup β) (x) : pure x >>= f = f x :=
   lift.of _ _
 #align free_abelian_group.pure_bind FreeAbelianGroup.pure_bind
+-/
 
+#print FreeAbelianGroup.zero_bind /-
 @[simp]
 theorem zero_bind (f : α → FreeAbelianGroup β) : 0 >>= f = 0 :=
   (lift f).map_zero
 #align free_abelian_group.zero_bind FreeAbelianGroup.zero_bind
+-/
 
+#print FreeAbelianGroup.add_bind /-
 @[simp]
 theorem add_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
     x + y >>= f = (x >>= f) + (y >>= f) :=
   (lift _).map_add _ _
 #align free_abelian_group.add_bind FreeAbelianGroup.add_bind
+-/
 
+#print FreeAbelianGroup.neg_bind /-
 @[simp]
 theorem neg_bind (f : α → FreeAbelianGroup β) (x : FreeAbelianGroup α) : -x >>= f = -(x >>= f) :=
   map_neg (lift f) _
 #align free_abelian_group.neg_bind FreeAbelianGroup.neg_bind
+-/
 
+#print FreeAbelianGroup.sub_bind /-
 @[simp]
 theorem sub_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
     x - y >>= f = (x >>= f) - (y >>= f) :=
   map_sub (lift f) _ _
 #align free_abelian_group.sub_bind FreeAbelianGroup.sub_bind
+-/
 
+#print FreeAbelianGroup.pure_seq /-
 @[simp]
 theorem pure_seq (f : α → β) (x : FreeAbelianGroup α) : pure f <*> x = f <$> x :=
   pure_bind _ _
 #align free_abelian_group.pure_seq FreeAbelianGroup.pure_seq
+-/
 
+#print FreeAbelianGroup.zero_seq /-
 @[simp]
 theorem zero_seq (x : FreeAbelianGroup α) : (0 : FreeAbelianGroup (α → β)) <*> x = 0 :=
   zero_bind _
 #align free_abelian_group.zero_seq FreeAbelianGroup.zero_seq
+-/
 
+#print FreeAbelianGroup.add_seq /-
 @[simp]
 theorem add_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
     f + g <*> x = (f <*> x) + (g <*> x) :=
   add_bind _ _ _
 #align free_abelian_group.add_seq FreeAbelianGroup.add_seq
+-/
 
+#print FreeAbelianGroup.neg_seq /-
 @[simp]
 theorem neg_seq (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : -f <*> x = -(f <*> x) :=
   neg_bind _ _
 #align free_abelian_group.neg_seq FreeAbelianGroup.neg_seq
+-/
 
+#print FreeAbelianGroup.sub_seq /-
 @[simp]
 theorem sub_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
     f - g <*> x = (f <*> x) - (g <*> x) :=
   sub_bind _ _ _
 #align free_abelian_group.sub_seq FreeAbelianGroup.sub_seq
+-/
 
 #print FreeAbelianGroup.seqAddGroupHom /-
 /-- If `f : free_abelian_group (α → β)`, then `f <*>` is an additive morphism
@@ -312,27 +360,35 @@ def seqAddGroupHom (f : FreeAbelianGroup (α → β)) : FreeAbelianGroup α →+
 #align free_abelian_group.seq_add_group_hom FreeAbelianGroup.seqAddGroupHom
 -/
 
+#print FreeAbelianGroup.seq_zero /-
 @[simp]
 theorem seq_zero (f : FreeAbelianGroup (α → β)) : f <*> 0 = 0 :=
   (seqAddGroupHom f).map_zero
 #align free_abelian_group.seq_zero FreeAbelianGroup.seq_zero
+-/
 
+#print FreeAbelianGroup.seq_add /-
 @[simp]
 theorem seq_add (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
     f <*> x + y = (f <*> x) + (f <*> y) :=
   (seqAddGroupHom f).map_add x y
 #align free_abelian_group.seq_add FreeAbelianGroup.seq_add
+-/
 
+#print FreeAbelianGroup.seq_neg /-
 @[simp]
 theorem seq_neg (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : f <*> -x = -(f <*> x) :=
   (seqAddGroupHom f).map_neg x
 #align free_abelian_group.seq_neg FreeAbelianGroup.seq_neg
+-/
 
+#print FreeAbelianGroup.seq_sub /-
 @[simp]
 theorem seq_sub (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
     f <*> x - y = (f <*> x) - (f <*> y) :=
   (seqAddGroupHom f).map_sub x y
 #align free_abelian_group.seq_sub FreeAbelianGroup.seq_sub
+-/
 
 instance : LawfulMonad FreeAbelianGroup.{u}
     where
@@ -375,6 +431,7 @@ def map (f : α → β) : FreeAbelianGroup α →+ FreeAbelianGroup β :=
 #align free_abelian_group.map FreeAbelianGroup.map
 -/
 
+#print FreeAbelianGroup.lift_comp /-
 theorem lift_comp {α} {β} {γ} [AddCommGroup γ] (f : α → β) (g : β → γ) (x : FreeAbelianGroup α) :
     lift (g ∘ f) x = lift g (map f x) :=
   by
@@ -384,6 +441,7 @@ theorem lift_comp {α} {β} {γ} [AddCommGroup γ] (f : α → β) (g : β → 
   · intro x h; simp only [h, AddMonoidHom.map_neg]
   · intro x y h₁ h₂; simp only [h₁, h₂, AddMonoidHom.map_add]
 #align free_abelian_group.lift_comp FreeAbelianGroup.lift_comp
+-/
 
 #print FreeAbelianGroup.map_id /-
 theorem map_id : map id = AddMonoidHom.id (FreeAbelianGroup α) :=
@@ -392,8 +450,10 @@ theorem map_id : map id = AddMonoidHom.id (FreeAbelianGroup α) :=
 #align free_abelian_group.map_id FreeAbelianGroup.map_id
 -/
 
+#print FreeAbelianGroup.map_id_apply /-
 theorem map_id_apply (x : FreeAbelianGroup α) : map id x = x := by rw [map_id]; rfl
 #align free_abelian_group.map_id_apply FreeAbelianGroup.map_id_apply
+-/
 
 #print FreeAbelianGroup.map_comp /-
 theorem map_comp {f : α → β} {g : β → γ} : map (g ∘ f) = (map g).comp (map f) :=
@@ -401,15 +461,19 @@ theorem map_comp {f : α → β} {g : β → γ} : map (g ∘ f) = (map g).comp
 #align free_abelian_group.map_comp FreeAbelianGroup.map_comp
 -/
 
+#print FreeAbelianGroup.map_comp_apply /-
 theorem map_comp_apply {f : α → β} {g : β → γ} (x : FreeAbelianGroup α) :
     map (g ∘ f) x = (map g) ((map f) x) := by rw [map_comp]; rfl
 #align free_abelian_group.map_comp_apply FreeAbelianGroup.map_comp_apply
+-/
 
+#print FreeAbelianGroup.map_of_apply /-
 -- version of map_of which uses `map`
 @[simp]
 theorem map_of_apply {f : α → β} (a : α) : map f (of a) = of (f a) :=
   rfl
 #align free_abelian_group.map_of_apply FreeAbelianGroup.map_of_apply
+-/
 
 variable (α)
 
@@ -422,19 +486,25 @@ instance : Mul (FreeAbelianGroup α) :=
 
 variable {α}
 
+#print FreeAbelianGroup.mul_def /-
 theorem mul_def (x y : FreeAbelianGroup α) :
     x * y = lift (fun x₂ => lift (fun x₁ => of (x₁ * x₂)) x) y :=
   rfl
 #align free_abelian_group.mul_def FreeAbelianGroup.mul_def
+-/
 
+#print FreeAbelianGroup.of_mul_of /-
 @[simp]
 theorem of_mul_of (x y : α) : of x * of y = of (x * y) :=
   rfl
 #align free_abelian_group.of_mul_of FreeAbelianGroup.of_mul_of
+-/
 
+#print FreeAbelianGroup.of_mul /-
 theorem of_mul (x y : α) : of (x * y) = of x * of y :=
   rfl
 #align free_abelian_group.of_mul FreeAbelianGroup.of_mul
+-/
 
 instance : Distrib (FreeAbelianGroup α) :=
   { FreeAbelianGroup.hasMul _ with
@@ -511,10 +581,12 @@ def ofMulHom : α →* FreeAbelianGroup α where
 #align free_abelian_group.of_mul_hom FreeAbelianGroup.ofMulHom
 -/
 
+#print FreeAbelianGroup.ofMulHom_coe /-
 @[simp]
 theorem ofMulHom_coe : (ofMulHom : α → FreeAbelianGroup α) = of :=
   rfl
 #align free_abelian_group.of_mul_hom_coe FreeAbelianGroup.ofMulHom_coe
+-/
 
 #print FreeAbelianGroup.liftMonoid /-
 /-- If `f` preserves multiplication, then so does `lift f`. -/
@@ -548,28 +620,38 @@ def liftMonoid : (α →* R) ≃ (FreeAbelianGroup α →+* R)
 #align free_abelian_group.lift_monoid FreeAbelianGroup.liftMonoid
 -/
 
+#print FreeAbelianGroup.liftMonoid_coe_addMonoidHom /-
 @[simp]
 theorem liftMonoid_coe_addMonoidHom (f : α →* R) : ↑(liftMonoid f) = lift f :=
   rfl
 #align free_abelian_group.lift_monoid_coe_add_monoid_hom FreeAbelianGroup.liftMonoid_coe_addMonoidHom
+-/
 
+#print FreeAbelianGroup.liftMonoid_coe /-
 @[simp]
 theorem liftMonoid_coe (f : α →* R) : ⇑(liftMonoid f) = lift f :=
   rfl
 #align free_abelian_group.lift_monoid_coe FreeAbelianGroup.liftMonoid_coe
+-/
 
+#print FreeAbelianGroup.liftMonoid_symm_coe /-
 @[simp]
 theorem liftMonoid_symm_coe (f : FreeAbelianGroup α →+* R) : ⇑(liftMonoid.symm f) = lift.symm ↑f :=
   rfl
 #align free_abelian_group.lift_monoid_symm_coe FreeAbelianGroup.liftMonoid_symm_coe
+-/
 
+#print FreeAbelianGroup.one_def /-
 theorem one_def : (1 : FreeAbelianGroup α) = of 1 :=
   rfl
 #align free_abelian_group.one_def FreeAbelianGroup.one_def
+-/
 
+#print FreeAbelianGroup.of_one /-
 theorem of_one : (of 1 : FreeAbelianGroup α) = 1 :=
   rfl
 #align free_abelian_group.of_one FreeAbelianGroup.of_one
+-/
 
 end Monoid
 
@@ -596,6 +678,7 @@ instance pemptyUnique : Unique (FreeAbelianGroup PEmpty)
 #align free_abelian_group.pempty_unique FreeAbelianGroup.pemptyUnique
 -/
 
+#print FreeAbelianGroup.punitEquiv /-
 /-- The free abelian group on a type with one term is isomorphic to `ℤ`. -/
 def punitEquiv (T : Type _) [Unique T] : FreeAbelianGroup T ≃+ ℤ
     where
@@ -610,7 +693,9 @@ def punitEquiv (T : Type _) [Unique T] : FreeAbelianGroup T ≃+ ℤ
     exact zsmul_int_one n
   map_add' := AddMonoidHom.map_add _
 #align free_abelian_group.punit_equiv FreeAbelianGroup.punitEquiv
+-/
 
+#print FreeAbelianGroup.equivOfEquiv /-
 /-- Isomorphic types have isomorphic free abelian groups. -/
 def equivOfEquiv {α β : Type _} (f : α ≃ β) : FreeAbelianGroup α ≃+ FreeAbelianGroup β
     where
@@ -626,6 +711,7 @@ def equivOfEquiv {α β : Type _} (f : α ≃ β) : FreeAbelianGroup α ≃+ Fre
     rfl
   map_add' := AddMonoidHom.map_add _
 #align free_abelian_group.equiv_of_equiv FreeAbelianGroup.equivOfEquiv
+-/
 
 end FreeAbelianGroup

10bf4f82

bump to nightly-2023-06-04-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

3fb4268b

Diff

@@ -119,7 +119,7 @@ open FreeAbelianGroup
 @[simp]
 protected theorem of (x : α) : lift f (of x) = f x :=
   by
-  convert@Abelianization.lift.of (FreeGroup α) _ (Multiplicative β) _ _ _
+  convert @Abelianization.lift.of (FreeGroup α) _ (Multiplicative β) _ _ _
   convert free_group.lift.of.symm
 #align free_abelian_group.lift.of FreeAbelianGroup.lift.of

10bf4f82

bump to nightly-2023-05-28-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

8d353152

Diff

@@ -149,7 +149,7 @@ end lift
 
 section
 
-open Classical
+open scoped Classical
 
 #print FreeAbelianGroup.of_injective /-
 theorem of_injective : Function.Injective (of : α → FreeAbelianGroup α) := fun x y hoxy =>

10bf4f82

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -116,12 +116,6 @@ variable {β : Type v} [AddCommGroup β] (f : α → β)
 
 open FreeAbelianGroup
 
-/- warning: free_abelian_group.lift.of -> FreeAbelianGroup.lift.of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) (FreeAbelianGroup.of.{u1} α x)) (f x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) (FreeAbelianGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) (FreeAbelianGroup.of.{u1} α x)) (f x)
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.of FreeAbelianGroup.lift.ofₓ'. -/
 @[simp]
 protected theorem of (x : α) : lift f (of x) = f x :=
   by
@@ -129,26 +123,17 @@ protected theorem of (x : α) : lift f (of x) = f x :=
   convert free_group.lift.of.symm
 #align free_abelian_group.lift.of FreeAbelianGroup.lift.of
 
-/- warning: free_abelian_group.lift.unique -> FreeAbelianGroup.lift.unique is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.unique FreeAbelianGroup.lift.uniqueₓ'. -/
 protected theorem unique (g : FreeAbelianGroup α →+ β) (hg : ∀ x, g (of x) = f x) {x} :
     g x = lift f x :=
   AddMonoidHom.congr_fun (lift.symm_apply_eq.mp (funext hg : g ∘ of = f)) _
 #align free_abelian_group.lift.unique FreeAbelianGroup.lift.unique
 
-/- warning: free_abelian_group.lift.ext -> FreeAbelianGroup.lift.ext is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.ext FreeAbelianGroup.lift.extₓ'. -/
 /-- See note [partially-applied ext lemmas]. -/
 @[ext]
 protected theorem ext (g h : FreeAbelianGroup α →+ β) (H : ∀ x, g (of x) = h (of x)) : g = h :=
   lift.symm.Injective <| funext H
 #align free_abelian_group.lift.ext FreeAbelianGroup.lift.ext
 
-/- warning: free_abelian_group.lift.map_hom -> FreeAbelianGroup.lift.map_hom is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.map_hom FreeAbelianGroup.lift.map_homₓ'. -/
 theorem map_hom {α β γ} [AddCommGroup β] [AddCommGroup γ] (a : FreeAbelianGroup α) (f : α → β)
     (g : β →+ γ) : g (lift f a) = lift (g ∘ f) a :=
   by
@@ -181,12 +166,6 @@ end
 
 attribute [local instance] QuotientGroup.leftRel
 
-/- warning: free_abelian_group.induction_on -> FreeAbelianGroup.induction_on is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {C : (FreeAbelianGroup.{u1} α) -> Prop} (z : FreeAbelianGroup.{u1} α), (C (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))))) -> (forall (x : α), C (FreeAbelianGroup.of.{u1} α x)) -> (forall (x : α), (C (FreeAbelianGroup.of.{u1} α x)) -> (C (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) (FreeAbelianGroup.of.{u1} α x)))) -> (forall (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y))) -> (C z)
-but is expected to have type
-  forall {α : Type.{u1}} {C : (FreeAbelianGroup.{u1} α) -> Prop} (z : FreeAbelianGroup.{u1} α), (C (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) -> (forall (x : α), C (FreeAbelianGroup.of.{u1} α x)) -> (forall (x : α), (C (FreeAbelianGroup.of.{u1} α x)) -> (C (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.of.{u1} α x)))) -> (forall (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y))) -> (C z)
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.induction_on FreeAbelianGroup.induction_onₓ'. -/
 @[elab_as_elim]
 protected theorem induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α) (C0 : C 0)
     (C1 : ∀ x, C <| of x) (Cn : ∀ x, C (of x) → C (-of x)) (Cp : ∀ x y, C x → C y → C (x + y)) :
@@ -196,9 +175,6 @@ protected theorem induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbeli
       List.recOn L C0 fun ⟨x, b⟩ tl ih => Bool.recOn b (Cp _ _ (Cn _ (C1 x)) ih) (Cp _ _ (C1 x) ih)
 #align free_abelian_group.induction_on FreeAbelianGroup.induction_on
 
-/- warning: free_abelian_group.lift.add' -> FreeAbelianGroup.lift.add' is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.add' FreeAbelianGroup.lift.add'ₓ'. -/
 theorem lift.add' {α β} [AddCommGroup β] (a : FreeAbelianGroup α) (f g : α → β) :
     lift (f + g) a = lift f a + lift g a :=
   by
@@ -222,9 +198,6 @@ def liftAddGroupHom {α} (β) [AddCommGroup β] (a : FreeAbelianGroup α) : (α
 #align free_abelian_group.lift_add_group_hom FreeAbelianGroup.liftAddGroupHom
 -/
 
-/- warning: free_abelian_group.lift_neg' -> FreeAbelianGroup.lift_neg' is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_neg' FreeAbelianGroup.lift_neg'ₓ'. -/
 theorem lift_neg' {β} [AddCommGroup β] (f : α → β) : lift (-f) = -lift f :=
   AddMonoidHom.ext fun _ => (liftAddGroupHom _ _ : (α → β) →+ β).map_neg _
 #align free_abelian_group.lift_neg' FreeAbelianGroup.lift_neg'
@@ -237,12 +210,6 @@ instance : Monad FreeAbelianGroup.{u} where
   pure α := of
   bind α β x f := lift f x
 
-/- warning: free_abelian_group.induction_on' -> FreeAbelianGroup.induction_on' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {C : (FreeAbelianGroup.{u1} α) -> Prop} (z : FreeAbelianGroup.{u1} α), (C (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))))) -> (forall (x : α), C (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α x)) -> (forall (x : α), (C (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α x)) -> (C (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α x)))) -> (forall (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y))) -> (C z)
-but is expected to have type
-  forall {α : Type.{u1}} {C : (FreeAbelianGroup.{u1} α) -> Prop} (z : FreeAbelianGroup.{u1} α), (C (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) -> (forall (x : α), C (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α x)) -> (forall (x : α), (C (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α x)) -> (C (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α x)))) -> (forall (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y))) -> (C z)
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.induction_on' FreeAbelianGroup.induction_on'ₓ'. -/
 @[elab_as_elim]
 protected theorem induction_on' {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α) (C0 : C 0)
     (C1 : ∀ x, C <| pure x) (Cn : ∀ x, C (pure x) → C (-pure x))
@@ -250,182 +217,86 @@ protected theorem induction_on' {C : FreeAbelianGroup α → Prop} (z : FreeAbel
   FreeAbelianGroup.induction_on z C0 C1 Cn Cp
 #align free_abelian_group.induction_on' FreeAbelianGroup.induction_on'
 
-/- warning: free_abelian_group.map_pure -> FreeAbelianGroup.map_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β f (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α x)) (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) β (f x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α x)) (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) β (f x))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_pure FreeAbelianGroup.map_pureₓ'. -/
 @[simp]
 theorem map_pure (f : α → β) (x : α) : f <$> (pure x : FreeAbelianGroup α) = pure (f x) :=
   rfl
 #align free_abelian_group.map_pure FreeAbelianGroup.map_pure
 
-/- warning: free_abelian_group.map_zero -> FreeAbelianGroup.map_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β f (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_zero FreeAbelianGroup.map_zeroₓ'. -/
 @[simp]
 protected theorem map_zero (f : α → β) : f <$> (0 : FreeAbelianGroup α) = 0 :=
   (lift (of ∘ f)).map_zero
 #align free_abelian_group.map_zero FreeAbelianGroup.map_zero
 
-/- warning: free_abelian_group.map_add -> FreeAbelianGroup.map_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β f (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f y))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_add FreeAbelianGroup.map_addₓ'. -/
 @[simp]
 protected theorem map_add (f : α → β) (x y : FreeAbelianGroup α) :
     f <$> (x + y) = f <$> x + f <$> y :=
   (lift _).map_add _ _
 #align free_abelian_group.map_add FreeAbelianGroup.map_add
 
-/- warning: free_abelian_group.map_neg -> FreeAbelianGroup.map_neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β f (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_neg FreeAbelianGroup.map_negₓ'. -/
 @[simp]
 protected theorem map_neg (f : α → β) (x : FreeAbelianGroup α) : f <$> (-x) = -f <$> x :=
   map_neg (lift <| of ∘ f) _
 #align free_abelian_group.map_neg FreeAbelianGroup.map_neg
 
-/- warning: free_abelian_group.map_sub -> FreeAbelianGroup.map_sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β f (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f y))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_sub FreeAbelianGroup.map_subₓ'. -/
 @[simp]
 protected theorem map_sub (f : α → β) (x y : FreeAbelianGroup α) :
     f <$> (x - y) = f <$> x - f <$> y :=
   map_sub (lift <| of ∘ f) _ _
 #align free_abelian_group.map_sub FreeAbelianGroup.map_sub
 
-/- warning: free_abelian_group.map_of -> FreeAbelianGroup.map_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (y : α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (FreeAbelianGroup.of.{u1} α y)) (FreeAbelianGroup.of.{u1} β (f y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (y : α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (FreeAbelianGroup.of.{u1} α y)) (FreeAbelianGroup.of.{u1} β (f y))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_of FreeAbelianGroup.map_ofₓ'. -/
 @[simp]
 theorem map_of (f : α → β) (y : α) : f <$> of y = of (f y) :=
   rfl
 #align free_abelian_group.map_of FreeAbelianGroup.map_of
 
-/- warning: free_abelian_group.pure_bind -> FreeAbelianGroup.pure_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α x) f) (f x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α x) f) (f x)
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.pure_bind FreeAbelianGroup.pure_bindₓ'. -/
 @[simp]
 theorem pure_bind (f : α → FreeAbelianGroup β) (x) : pure x >>= f = f x :=
   lift.of _ _
 #align free_abelian_group.pure_bind FreeAbelianGroup.pure_bind
 
-/- warning: free_abelian_group.zero_bind -> FreeAbelianGroup.zero_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) f) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) f) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.zero_bind FreeAbelianGroup.zero_bindₓ'. -/
 @[simp]
 theorem zero_bind (f : α → FreeAbelianGroup β) : 0 >>= f = 0 :=
   (lift f).map_zero
 #align free_abelian_group.zero_bind FreeAbelianGroup.zero_bind
 
-/- warning: free_abelian_group.add_bind -> FreeAbelianGroup.add_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y) f) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β x f) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β y f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y) f) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β x f) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β y f))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.add_bind FreeAbelianGroup.add_bindₓ'. -/
 @[simp]
 theorem add_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
     x + y >>= f = (x >>= f) + (y >>= f) :=
   (lift _).map_add _ _
 #align free_abelian_group.add_bind FreeAbelianGroup.add_bind
 
-/- warning: free_abelian_group.neg_bind -> FreeAbelianGroup.neg_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) x) f) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β x f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) x) f) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β x f))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.neg_bind FreeAbelianGroup.neg_bindₓ'. -/
 @[simp]
 theorem neg_bind (f : α → FreeAbelianGroup β) (x : FreeAbelianGroup α) : -x >>= f = -(x >>= f) :=
   map_neg (lift f) _
 #align free_abelian_group.neg_bind FreeAbelianGroup.neg_bind
 
-/- warning: free_abelian_group.sub_bind -> FreeAbelianGroup.sub_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y) f) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β x f) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β y f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y) f) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β x f) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β y f))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.sub_bind FreeAbelianGroup.sub_bindₓ'. -/
 @[simp]
 theorem sub_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
     x - y >>= f = (x >>= f) - (y >>= f) :=
   map_sub (lift f) _ _
 #align free_abelian_group.sub_bind FreeAbelianGroup.sub_bind
 
-/- warning: free_abelian_group.pure_seq -> FreeAbelianGroup.pure_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toHasSeq.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toHasPure.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) (α -> β) f) x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1637 : Unit) => x)) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x)
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.pure_seq FreeAbelianGroup.pure_seqₓ'. -/
 @[simp]
 theorem pure_seq (f : α → β) (x : FreeAbelianGroup α) : pure f <*> x = f <$> x :=
   pure_bind _ _
 #align free_abelian_group.pure_seq FreeAbelianGroup.pure_seq
 
-/- warning: free_abelian_group.zero_seq -> FreeAbelianGroup.zero_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))))) x) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))))) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1671 : Unit) => x)) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.zero_seq FreeAbelianGroup.zero_seqₓ'. -/
 @[simp]
 theorem zero_seq (x : FreeAbelianGroup α) : (0 : FreeAbelianGroup (α → β)) <*> x = 0 :=
   zero_bind _
 #align free_abelian_group.zero_seq FreeAbelianGroup.zero_seq
 
-/- warning: free_abelian_group.add_seq -> FreeAbelianGroup.add_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) x) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β g x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1709 : Unit) => x)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1720 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1730 : Unit) => x)))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.add_seq FreeAbelianGroup.add_seqₓ'. -/
 @[simp]
 theorem add_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
     f + g <*> x = (f <*> x) + (g <*> x) :=
   add_bind _ _ _
 #align free_abelian_group.add_seq FreeAbelianGroup.add_seq
 
-/- warning: free_abelian_group.neg_seq -> FreeAbelianGroup.neg_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))) f) x) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1762 : Unit) => x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1773 : Unit) => x)))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.neg_seq FreeAbelianGroup.neg_seqₓ'. -/
 @[simp]
 theorem neg_seq (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : -f <*> x = -(f <*> x) :=
   neg_bind _ _
 #align free_abelian_group.neg_seq FreeAbelianGroup.neg_seq
 
-/- warning: free_abelian_group.sub_seq -> FreeAbelianGroup.sub_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) x) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β g x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1811 : Unit) => x)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1822 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1832 : Unit) => x)))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.sub_seq FreeAbelianGroup.sub_seqₓ'. -/
 @[simp]
 theorem sub_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
     f - g <*> x = (f <*> x) - (g <*> x) :=
@@ -441,46 +312,22 @@ def seqAddGroupHom (f : FreeAbelianGroup (α → β)) : FreeAbelianGroup α →+
 #align free_abelian_group.seq_add_group_hom FreeAbelianGroup.seqAddGroupHom
 -/
 
-/- warning: free_abelian_group.seq_zero -> FreeAbelianGroup.seq_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1981 : Unit) => OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_zero FreeAbelianGroup.seq_zeroₓ'. -/
 @[simp]
 theorem seq_zero (f : FreeAbelianGroup (α → β)) : f <*> 0 = 0 :=
   (seqAddGroupHom f).map_zero
 #align free_abelian_group.seq_zero FreeAbelianGroup.seq_zero
 
-/- warning: free_abelian_group.seq_add -> FreeAbelianGroup.seq_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2014 : Unit) => HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2029 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2039 : Unit) => y)))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_add FreeAbelianGroup.seq_addₓ'. -/
 @[simp]
 theorem seq_add (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
     f <*> x + y = (f <*> x) + (f <*> y) :=
   (seqAddGroupHom f).map_add x y
 #align free_abelian_group.seq_add FreeAbelianGroup.seq_add
 
-/- warning: free_abelian_group.seq_neg -> FreeAbelianGroup.seq_neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2071 : Unit) => Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2085 : Unit) => x)))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_neg FreeAbelianGroup.seq_negₓ'. -/
 @[simp]
 theorem seq_neg (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : f <*> -x = -(f <*> x) :=
   (seqAddGroupHom f).map_neg x
 #align free_abelian_group.seq_neg FreeAbelianGroup.seq_neg
 
-/- warning: free_abelian_group.seq_sub -> FreeAbelianGroup.seq_sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2118 : Unit) => HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2133 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2143 : Unit) => y)))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_sub FreeAbelianGroup.seq_subₓ'. -/
 @[simp]
 theorem seq_sub (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
     f <*> x - y = (f <*> x) - (f <*> y) :=
@@ -528,9 +375,6 @@ def map (f : α → β) : FreeAbelianGroup α →+ FreeAbelianGroup β :=
 #align free_abelian_group.map FreeAbelianGroup.map
 -/
 
-/- warning: free_abelian_group.lift_comp -> FreeAbelianGroup.lift_comp is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_comp FreeAbelianGroup.lift_compₓ'. -/
 theorem lift_comp {α} {β} {γ} [AddCommGroup γ] (f : α → β) (g : β → γ) (x : FreeAbelianGroup α) :
     lift (g ∘ f) x = lift g (map f x) :=
   by
@@ -548,12 +392,6 @@ theorem map_id : map id = AddMonoidHom.id (FreeAbelianGroup α) :=
 #align free_abelian_group.map_id FreeAbelianGroup.map_id
 -/
 
-/- warning: free_abelian_group.map_id_apply -> FreeAbelianGroup.map_id_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (coeFn.{succ u1, succ u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (_x : AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.hasCoeToFun.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) _x) (AddHomClass.toFunLike.{u1, u1, u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FreeAbelianGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_id_apply FreeAbelianGroup.map_id_applyₓ'. -/
 theorem map_id_apply (x : FreeAbelianGroup α) : map id x = x := by rw [map_id]; rfl
 #align free_abelian_group.map_id_apply FreeAbelianGroup.map_id_apply
 
@@ -563,19 +401,10 @@ theorem map_comp {f : α → β} {g : β → γ} : map (g ∘ f) = (map g).comp
 #align free_abelian_group.map_comp FreeAbelianGroup.map_comp
 -/
 
-/- warning: free_abelian_group.map_comp_apply -> FreeAbelianGroup.map_comp_apply is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_comp_apply FreeAbelianGroup.map_comp_applyₓ'. -/
 theorem map_comp_apply {f : α → β} {g : β → γ} (x : FreeAbelianGroup α) :
     map (g ∘ f) x = (map g) ((map f) x) := by rw [map_comp]; rfl
 #align free_abelian_group.map_comp_apply FreeAbelianGroup.map_comp_apply
 
-/- warning: free_abelian_group.map_of_apply -> FreeAbelianGroup.map_of_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (a : α), Eq.{succ u2} (FreeAbelianGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u2} β)) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.map.{u1, u2} α β f) (FreeAbelianGroup.of.{u1} α a)) (FreeAbelianGroup.of.{u2} β (f a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (a : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u2} β) (FreeAbelianGroup.of.{u1} α a)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u2} β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))))) (FreeAbelianGroup.map.{u1, u2} α β f) (FreeAbelianGroup.of.{u1} α a)) (FreeAbelianGroup.of.{u2} β (f a))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_of_apply FreeAbelianGroup.map_of_applyₓ'. -/
 -- version of map_of which uses `map`
 @[simp]
 theorem map_of_apply {f : α → β} (a : α) : map f (of a) = of (f a) :=
@@ -593,31 +422,16 @@ instance : Mul (FreeAbelianGroup α) :=
 
 variable {α}
 
-/- warning: free_abelian_group.mul_def -> FreeAbelianGroup.mul_def is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.mul_def FreeAbelianGroup.mul_defₓ'. -/
 theorem mul_def (x y : FreeAbelianGroup α) :
     x * y = lift (fun x₂ => lift (fun x₁ => of (x₁ * x₂)) x) y :=
   rfl
 #align free_abelian_group.mul_def FreeAbelianGroup.mul_def
 
-/- warning: free_abelian_group.of_mul_of -> FreeAbelianGroup.of_mul_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : α) (y : α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.hasMul.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α x) (FreeAbelianGroup.of.{u1} α y)) (FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x y))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : α) (y : α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.mul.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α x) (FreeAbelianGroup.of.{u1} α y)) (FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x y))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.of_mul_of FreeAbelianGroup.of_mul_ofₓ'. -/
 @[simp]
 theorem of_mul_of (x y : α) : of x * of y = of (x * y) :=
   rfl
 #align free_abelian_group.of_mul_of FreeAbelianGroup.of_mul_of
 
-/- warning: free_abelian_group.of_mul -> FreeAbelianGroup.of_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : α) (y : α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x y)) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.hasMul.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α x) (FreeAbelianGroup.of.{u1} α y))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : α) (y : α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x y)) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.mul.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α x) (FreeAbelianGroup.of.{u1} α y))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.of_mul FreeAbelianGroup.of_mulₓ'. -/
 theorem of_mul (x y : α) : of (x * y) = of x * of y :=
   rfl
 #align free_abelian_group.of_mul FreeAbelianGroup.of_mul
@@ -697,12 +511,6 @@ def ofMulHom : α →* FreeAbelianGroup α where
 #align free_abelian_group.of_mul_hom FreeAbelianGroup.ofMulHom
 -/
 
-/- warning: free_abelian_group.of_mul_hom_coe -> FreeAbelianGroup.ofMulHom_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} ((fun (_x : MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) => α -> (FreeAbelianGroup.{u1} α)) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (fun (_x : MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) => α -> (FreeAbelianGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => FreeAbelianGroup.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => FreeAbelianGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (FreeAbelianGroup.{u1} α) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u1} (FreeAbelianGroup.{u1} α) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))))) (MonoidHom.monoidHomClass.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))))) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α)
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.of_mul_hom_coe FreeAbelianGroup.ofMulHom_coeₓ'. -/
 @[simp]
 theorem ofMulHom_coe : (ofMulHom : α → FreeAbelianGroup α) = of :=
   rfl
@@ -740,46 +548,25 @@ def liftMonoid : (α →* R) ≃ (FreeAbelianGroup α →+* R)
 #align free_abelian_group.lift_monoid FreeAbelianGroup.liftMonoid
 -/
 
-/- warning: free_abelian_group.lift_monoid_coe_add_monoid_hom -> FreeAbelianGroup.liftMonoid_coe_addMonoidHom is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_coe_add_monoid_hom FreeAbelianGroup.liftMonoid_coe_addMonoidHomₓ'. -/
 @[simp]
 theorem liftMonoid_coe_addMonoidHom (f : α →* R) : ↑(liftMonoid f) = lift f :=
   rfl
 #align free_abelian_group.lift_monoid_coe_add_monoid_hom FreeAbelianGroup.liftMonoid_coe_addMonoidHom
 
-/- warning: free_abelian_group.lift_monoid_coe -> FreeAbelianGroup.liftMonoid_coe is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_coe FreeAbelianGroup.liftMonoid_coeₓ'. -/
 @[simp]
 theorem liftMonoid_coe (f : α →* R) : ⇑(liftMonoid f) = lift f :=
   rfl
 #align free_abelian_group.lift_monoid_coe FreeAbelianGroup.liftMonoid_coe
 
-/- warning: free_abelian_group.lift_monoid_symm_coe -> FreeAbelianGroup.liftMonoid_symm_coe is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_symm_coe FreeAbelianGroup.liftMonoid_symm_coeₓ'. -/
 @[simp]
 theorem liftMonoid_symm_coe (f : FreeAbelianGroup α →+* R) : ⇑(liftMonoid.symm f) = lift.symm ↑f :=
   rfl
 #align free_abelian_group.lift_monoid_symm_coe FreeAbelianGroup.liftMonoid_symm_coe
 
-/- warning: free_abelian_group.one_def -> FreeAbelianGroup.one_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (FreeAbelianGroup.{u1} α) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 1 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 1 (One.one.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.hasOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (FreeAbelianGroup.of.{u1} α (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (FreeAbelianGroup.{u1} α) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 1 (One.toOfNat1.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.one.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (FreeAbelianGroup.of.{u1} α (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.one_def FreeAbelianGroup.one_defₓ'. -/
 theorem one_def : (1 : FreeAbelianGroup α) = of 1 :=
   rfl
 #align free_abelian_group.one_def FreeAbelianGroup.one_def
 
-/- warning: free_abelian_group.of_one -> FreeAbelianGroup.of_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.of.{u1} α (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 1 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 1 (One.one.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.hasOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.of.{u1} α (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 1 (One.toOfNat1.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.one.{u1} α (Monoid.toOne.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.of_one FreeAbelianGroup.of_oneₓ'. -/
 theorem of_one : (of 1 : FreeAbelianGroup α) = 1 :=
   rfl
 #align free_abelian_group.of_one FreeAbelianGroup.of_one
@@ -809,12 +596,6 @@ instance pemptyUnique : Unique (FreeAbelianGroup PEmpty)
 #align free_abelian_group.pempty_unique FreeAbelianGroup.pemptyUnique
 -/
 
-/- warning: free_abelian_group.punit_equiv -> FreeAbelianGroup.punitEquiv is a dubious translation:
-lean 3 declaration is
-  forall (T : Type.{u1}) [_inst_1 : Unique.{succ u1} T], AddEquiv.{u1, 0} (FreeAbelianGroup.{u1} T) Int (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} T) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} T) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} T) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} T) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} T) (FreeAbelianGroup.addCommGroup.{u1} T)))))) Int.hasAdd
-but is expected to have type
-  forall (T : Type.{u1}) [_inst_1 : Unique.{succ u1} T], AddEquiv.{u1, 0} (FreeAbelianGroup.{u1} T) Int (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} T) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} T) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} T) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} T) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} T) (FreeAbelianGroup.addCommGroup.{u1} T)))))) Int.instAddInt
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.punit_equiv FreeAbelianGroup.punitEquivₓ'. -/
 /-- The free abelian group on a type with one term is isomorphic to `ℤ`. -/
 def punitEquiv (T : Type _) [Unique T] : FreeAbelianGroup T ≃+ ℤ
     where
@@ -830,12 +611,6 @@ def punitEquiv (T : Type _) [Unique T] : FreeAbelianGroup T ≃+ ℤ
   map_add' := AddMonoidHom.map_add _
 #align free_abelian_group.punit_equiv FreeAbelianGroup.punitEquiv
 
-/- warning: free_abelian_group.equiv_of_equiv -> FreeAbelianGroup.equivOfEquiv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}}, (Equiv.{succ u1, succ u2} α β) -> (AddEquiv.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toHasAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}}, (Equiv.{succ u1, succ u2} α β) -> (AddEquiv.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))))
-Case conversion may be inaccurate. Consider using '#align free_abelian_group.equiv_of_equiv FreeAbelianGroup.equivOfEquivₓ'. -/
 /-- Isomorphic types have isomorphic free abelian groups. -/
 def equivOfEquiv {α β : Type _} (f : α ≃ β) : FreeAbelianGroup α ≃+ FreeAbelianGroup β
     where

10bf4f82

bump to nightly-2023-05-28-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6797a637

Diff

@@ -437,10 +437,7 @@ theorem sub_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
 `free_abelian_group α →+ free_abelian_group β`. -/
 def seqAddGroupHom (f : FreeAbelianGroup (α → β)) : FreeAbelianGroup α →+ FreeAbelianGroup β :=
   AddMonoidHom.mk' ((· <*> ·) f) fun x y =>
-    show lift (· <$> (x + y)) _ = _
-      by
-      simp only [FreeAbelianGroup.map_add]
-      exact lift.add' f _ _
+    show lift (· <$> (x + y)) _ = _ by simp only [FreeAbelianGroup.map_add]; exact lift.add' f _ _
 #align free_abelian_group.seq_add_group_hom FreeAbelianGroup.seqAddGroupHom
 -/
 
@@ -539,12 +536,9 @@ theorem lift_comp {α} {β} {γ} [AddCommGroup γ] (f : α → β) (g : β → 
   by
   apply FreeAbelianGroup.induction_on x
   · exact AddMonoidHom.map_zero _
-  · intro y
-    rfl
-  · intro x h
-    simp only [h, AddMonoidHom.map_neg]
-  · intro x y h₁ h₂
-    simp only [h₁, h₂, AddMonoidHom.map_add]
+  · intro y; rfl
+  · intro x h; simp only [h, AddMonoidHom.map_neg]
+  · intro x y h₁ h₂; simp only [h₁, h₂, AddMonoidHom.map_add]
 #align free_abelian_group.lift_comp FreeAbelianGroup.lift_comp
 
 #print FreeAbelianGroup.map_id /-
@@ -560,10 +554,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) _x) (AddHomClass.toFunLike.{u1, u1, u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FreeAbelianGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_id_apply FreeAbelianGroup.map_id_applyₓ'. -/
-theorem map_id_apply (x : FreeAbelianGroup α) : map id x = x :=
-  by
-  rw [map_id]
-  rfl
+theorem map_id_apply (x : FreeAbelianGroup α) : map id x = x := by rw [map_id]; rfl
 #align free_abelian_group.map_id_apply FreeAbelianGroup.map_id_apply
 
 #print FreeAbelianGroup.map_comp /-
@@ -576,9 +567,7 @@ theorem map_comp {f : α → β} {g : β → γ} : map (g ∘ f) = (map g).comp
 <too large>
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_comp_apply FreeAbelianGroup.map_comp_applyₓ'. -/
 theorem map_comp_apply {f : α → β} {g : β → γ} (x : FreeAbelianGroup α) :
-    map (g ∘ f) x = (map g) ((map f) x) := by
-  rw [map_comp]
-  rfl
+    map (g ∘ f) x = (map g) ((map f) x) := by rw [map_comp]; rfl
 #align free_abelian_group.map_comp_apply FreeAbelianGroup.map_comp_apply
 
 /- warning: free_abelian_group.map_of_apply -> FreeAbelianGroup.map_of_apply is a dubious translation:
@@ -643,9 +632,7 @@ instance : NonUnitalNonAssocRing (FreeAbelianGroup α) :=
   { FreeAbelianGroup.distrib,
     FreeAbelianGroup.addCommGroup
       _ with
-    zero_mul := fun a => by
-      have h : 0 * a + 0 * a = 0 * a := by simp [← add_mul]
-      simpa using h
+    zero_mul := fun a => by have h : 0 * a + 0 * a = 0 * a := by simp [← add_mul]; simpa using h
     mul_zero := fun a => rfl }
 
 end Mul
@@ -689,22 +676,15 @@ instance : Ring (FreeAbelianGroup α) :=
       rw [lift.of]
       refine'
         FreeAbelianGroup.induction_on x rfl (fun L => _) (fun L ih => _) fun x1 x2 ih1 ih2 => _
-      · erw [lift.of]
-        congr 1
-        exact mul_one L
+      · erw [lift.of]; congr 1; exact mul_one L
       · rw [map_neg, ih]
       · rw [map_add, ih1, ih2]
     one_mul := fun x => by
       unfold Mul.mul Semigroup.mul One.one
       refine' FreeAbelianGroup.induction_on x rfl _ _ _
-      · intro L
-        rw [lift.of, lift.of]
-        congr 1
-        exact one_mul L
-      · intro L ih
-        rw [map_neg, ih]
-      · intro x1 x2 ih1 ih2
-        rw [map_add, ih1, ih2] }
+      · intro L; rw [lift.of, lift.of]; congr 1; exact one_mul L
+      · intro L ih; rw [map_neg, ih]
+      · intro x1 x2 ih1 ih2; rw [map_add, ih1, ih2] }
 
 variable {α}
 
@@ -811,21 +791,13 @@ instance [CommMonoid α] : CommRing (FreeAbelianGroup α) :=
     mul_comm := fun x y =>
       by
       refine' FreeAbelianGroup.induction_on x (MulZeroClass.zero_mul y) _ _ _
-      · intro s
-        refine' FreeAbelianGroup.induction_on y (MulZeroClass.zero_mul _).symm _ _ _
-        · intro t
-          unfold Mul.mul Semigroup.mul Ring.mul
-          iterate 4 rw [lift.of]
-          congr 1
-          exact mul_comm _ _
-        · intro t ih
-          rw [mul_neg, ih, neg_mul_eq_neg_mul]
-        · intro y1 y2 ih1 ih2
-          rw [mul_add, add_mul, ih1, ih2]
-      · intro s ih
-        rw [neg_mul, ih, neg_mul_eq_mul_neg]
-      · intro x1 x2 ih1 ih2
-        rw [add_mul, mul_add, ih1, ih2] }
+      · intro s; refine' FreeAbelianGroup.induction_on y (MulZeroClass.zero_mul _).symm _ _ _
+        · intro t; unfold Mul.mul Semigroup.mul Ring.mul
+          iterate 4 rw [lift.of]; congr 1; exact mul_comm _ _
+        · intro t ih; rw [mul_neg, ih, neg_mul_eq_neg_mul]
+        · intro y1 y2 ih1 ih2; rw [mul_add, add_mul, ih1, ih2]
+      · intro s ih; rw [neg_mul, ih, neg_mul_eq_mul_neg]
+      · intro x1 x2 ih1 ih2; rw [add_mul, mul_add, ih1, ih2] }
 
 #print FreeAbelianGroup.pemptyUnique /-
 instance pemptyUnique : Unique (FreeAbelianGroup PEmpty)
@@ -833,9 +805,7 @@ instance pemptyUnique : Unique (FreeAbelianGroup PEmpty)
   default := 0
   uniq x :=
     FreeAbelianGroup.induction_on x rfl (fun x => PEmpty.elim x) (fun x => PEmpty.elim x)
-      (by
-        rintro - - rfl rfl
-        simp)
+      (by rintro - - rfl rfl; simp)
 #align free_abelian_group.pempty_unique FreeAbelianGroup.pemptyUnique
 -/
 
@@ -853,9 +823,7 @@ def punitEquiv (T : Type _) [Unique T] : FreeAbelianGroup T ≃+ ℤ
   left_inv z :=
     FreeAbelianGroup.induction_on z (by simp only [zero_smul, AddMonoidHom.map_zero])
       (Unique.forall_iff.2 <| by simp only [one_smul, lift.of]) (Unique.forall_iff.2 <| by simp)
-      fun x y hx hy => by
-      simp only [AddMonoidHom.map_add, add_smul] at *
-      rw [hx, hy]
+      fun x y hx hy => by simp only [AddMonoidHom.map_add, add_smul] at *; rw [hx, hy]
   right_inv n := by
     rw [AddMonoidHom.map_zsmul, lift.of]
     exact zsmul_int_one n

10bf4f82

bump to nightly-2023-05-28-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6c6011cf

Diff

@@ -130,10 +130,7 @@ protected theorem of (x : α) : lift f (of x) = f x :=
 #align free_abelian_group.lift.of FreeAbelianGroup.lift.of
 
 /- warning: free_abelian_group.lift.unique -> FreeAbelianGroup.lift.unique is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (g : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))), (forall (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) g (FreeAbelianGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeAbelianGroup.{u1} α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) g x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (g : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) (FreeAbelianGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) g (FreeAbelianGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeAbelianGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) x))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.unique FreeAbelianGroup.lift.uniqueₓ'. -/
 protected theorem unique (g : FreeAbelianGroup α →+ β) (hg : ∀ x, g (of x) = f x) {x} :
     g x = lift f x :=
@@ -141,10 +138,7 @@ protected theorem unique (g : FreeAbelianGroup α →+ β) (hg : ∀ x, g (of x)
 #align free_abelian_group.lift.unique FreeAbelianGroup.lift.unique
 
 /- warning: free_abelian_group.lift.ext -> FreeAbelianGroup.lift.ext is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (g : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (h : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))), (forall (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) g (FreeAbelianGroup.of.{u1} α x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) h (FreeAbelianGroup.of.{u1} α x))) -> (Eq.{max (succ u2) (succ u1)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) g h)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (g : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (h : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) (FreeAbelianGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) g (FreeAbelianGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) h (FreeAbelianGroup.of.{u1} α x))) -> (Eq.{max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) g h)
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.ext FreeAbelianGroup.lift.extₓ'. -/
 /-- See note [partially-applied ext lemmas]. -/
 @[ext]
@@ -153,10 +147,7 @@ protected theorem ext (g h : FreeAbelianGroup α →+ β) (H : ∀ x, g (of x) =
 #align free_abelian_group.lift.ext FreeAbelianGroup.lift.ext
 
 /- warning: free_abelian_group.lift.map_hom -> FreeAbelianGroup.lift.map_hom is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_2 : AddCommGroup.{u2} β] [_inst_3 : AddCommGroup.{u3} γ] (a : FreeAbelianGroup.{u1} α) (f : α -> β) (g : AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))), Eq.{succ u3} γ (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) (fun (_x : AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) => β -> γ) (AddMonoidHom.hasCoeToFun.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) g (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_2) f) a)) (coeFn.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) (fun (_x : AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) => (FreeAbelianGroup.{u1} α) -> γ) (AddMonoidHom.hasCoeToFun.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) (coeFn.{max 1 (max (max (succ u1) (succ u3)) (succ u3) (succ u1)) (max (succ u3) (succ u1)) (succ u1) (succ u3), max (max (succ u1) (succ u3)) (succ u3) (succ u1)} (Equiv.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3)))))) (fun (_x : Equiv.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3)))))) => (α -> γ) -> (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3)))))) (FreeAbelianGroup.lift.{u1, u3} α γ _inst_3) (Function.comp.{succ u1, succ u2, succ u3} α β γ (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) (fun (_x : AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) => β -> γ) (AddMonoidHom.hasCoeToFun.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) g) f)) a)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_2 : AddCommGroup.{u2} β] [_inst_3 : AddCommGroup.{u1} γ] (a : FreeAbelianGroup.{u3} α) (f : α -> β) (g : AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) (fun (a : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => β) a) (AddHomClass.toFunLike.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddMonoidHomClass.toAddHomClass.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoidHom.addMonoidHomClass.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))))) (FunLike.coe.{max (succ u2) (succ u3), max (succ u2) (succ u3), max (succ u2) (succ u3)} (Equiv.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (α -> β) (fun (a : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) a) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (FreeAbelianGroup.lift.{u3, u2} α β _inst_2) f) a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (_x : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => β) _x) (AddHomClass.toFunLike.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddMonoidHomClass.toAddHomClass.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoidHom.addMonoidHomClass.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))))) (FunLike.coe.{max (succ u2) (succ u3), max (succ u2) (succ u3), max (succ u2) (succ u3)} (Equiv.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (FreeAbelianGroup.lift.{u3, u2} α β _inst_2) f) a)) (FunLike.coe.{max (succ u1) (succ u3), succ u3, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (a : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) a) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => γ) _x) (AddHomClass.toFunLike.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (a : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) a) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) (FreeAbelianGroup.{u3} α) γ (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (a : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) a) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) (FunLike.coe.{max (succ u1) (succ u3), max (succ u1) (succ u3), max (succ u1) (succ u3)} (Equiv.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))))) (α -> γ) (fun (_x : α -> γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))))) (FreeAbelianGroup.lift.{u3, u1} α γ _inst_3) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (_x : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) a)
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.map_hom FreeAbelianGroup.lift.map_homₓ'. -/
 theorem map_hom {α β γ} [AddCommGroup β] [AddCommGroup γ] (a : FreeAbelianGroup α) (f : α → β)
     (g : β →+ γ) : g (lift f a) = lift (g ∘ f) a :=
@@ -206,10 +197,7 @@ protected theorem induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbeli
 #align free_abelian_group.induction_on FreeAbelianGroup.induction_on
 
 /- warning: free_abelian_group.lift.add' -> FreeAbelianGroup.lift.add' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (a : FreeAbelianGroup.{u1} α) (f : α -> β) (g : α -> β), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) g) a))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (a : FreeAbelianGroup.{u2} α) (f : α -> β) (g : α -> β), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.754 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.754 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.754 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (instHAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) _inst_1)))))) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) g) a))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.add' FreeAbelianGroup.lift.add'ₓ'. -/
 theorem lift.add' {α β} [AddCommGroup β] (a : FreeAbelianGroup α) (f g : α → β) :
     lift (f + g) a = lift f a + lift g a :=
@@ -235,10 +223,7 @@ def liftAddGroupHom {α} (β) [AddCommGroup β] (a : FreeAbelianGroup α) : (α
 -/
 
 /- warning: free_abelian_group.lift_neg' -> FreeAbelianGroup.lift_neg' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) f)) (Neg.neg.{max u2 u1} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHom.hasNeg.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) _inst_1) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.879 : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (Neg.neg.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (AddMonoidHom.instNegAddMonoidHomToAddZeroClassToAddMonoidToSubNegAddMonoidToAddGroup.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) _inst_1) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_neg' FreeAbelianGroup.lift_neg'ₓ'. -/
 theorem lift_neg' {β} [AddCommGroup β] (f : α → β) : lift (-f) = -lift f :=
   AddMonoidHom.ext fun _ => (liftAddGroupHom _ _ : (α → β) →+ β).map_neg _
@@ -547,10 +532,7 @@ def map (f : α → β) : FreeAbelianGroup α →+ FreeAbelianGroup β :=
 -/
 
 /- warning: free_abelian_group.lift_comp -> FreeAbelianGroup.lift_comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : AddCommGroup.{u3} γ] (f : α -> β) (g : β -> γ) (x : FreeAbelianGroup.{u1} α), Eq.{succ u3} γ (coeFn.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) (fun (_x : AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) => (FreeAbelianGroup.{u1} α) -> γ) (AddMonoidHom.hasCoeToFun.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u3)) (succ u3) (succ u1)) (max (succ u3) (succ u1)) (succ u1) (succ u3), max (max (succ u1) (succ u3)) (succ u3) (succ u1)} (Equiv.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) => (α -> γ) -> (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (FreeAbelianGroup.lift.{u1, u3} α γ _inst_1) (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x) (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) (fun (_x : AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) => (FreeAbelianGroup.{u2} β) -> γ) (AddMonoidHom.hasCoeToFun.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) (coeFn.{max 1 (max (max (succ u2) (succ u3)) (succ u3) (succ u2)) (max (succ u3) (succ u2)) (succ u2) (succ u3), max (max (succ u2) (succ u3)) (succ u3) (succ u2)} (Equiv.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (fun (_x : Equiv.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) => (β -> γ) -> (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (FreeAbelianGroup.lift.{u2, u3} β γ _inst_1) g) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u2} β)) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.map.{u1, u2} α β f) x))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : AddCommGroup.{u1} γ] (f : α -> β) (g : β -> γ) (x : FreeAbelianGroup.{u3} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => γ) x) (FunLike.coe.{max (succ u1) (succ u3), succ u3, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => γ) _x) (AddHomClass.toFunLike.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) (FreeAbelianGroup.{u3} α) γ (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u3), max (succ u1) (succ u3), max (succ u1) (succ u3)} (Equiv.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (α -> γ) (fun (_x : α -> γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (FreeAbelianGroup.lift.{u3, u1} α γ _inst_1) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) x) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) g) (FreeAbelianGroup.{u2} β) (fun (_x : FreeAbelianGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} β) => γ) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) g) (FreeAbelianGroup.{u2} β) γ (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) g) (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (β -> γ) (fun (_x : β -> γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} β γ _inst_1) g) (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => FreeAbelianGroup.{u2} β) _x) (AddHomClass.toFunLike.{max u3 u2, u3, u2} (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddMonoidHomClass.toAddHomClass.{max u3 u2, u3, u2} (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoidHom.addMonoidHomClass.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))))) (FreeAbelianGroup.map.{u3, u2} α β f) x))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_comp FreeAbelianGroup.lift_compₓ'. -/
 theorem lift_comp {α} {β} {γ} [AddCommGroup γ] (f : α → β) (g : β → γ) (x : FreeAbelianGroup α) :
     lift (g ∘ f) x = lift g (map f x) :=
@@ -591,10 +573,7 @@ theorem map_comp {f : α → β} {g : β → γ} : map (g ∘ f) = (map g).comp
 -/
 
 /- warning: free_abelian_group.map_comp_apply -> FreeAbelianGroup.map_comp_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {g : β -> γ} (x : FreeAbelianGroup.{u1} α), Eq.{succ u3} (FreeAbelianGroup.{u3} γ) (coeFn.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (fun (_x : AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u3} γ)) (AddMonoidHom.hasCoeToFun.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x) (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (fun (_x : AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) => (FreeAbelianGroup.{u2} β) -> (FreeAbelianGroup.{u3} γ)) (AddMonoidHom.hasCoeToFun.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.map.{u2, u3} β γ g) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u2} β)) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.map.{u1, u2} α β f) x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {g : β -> γ} (x : FreeAbelianGroup.{u1} α), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u3} γ) x) (FunLike.coe.{max (succ u1) (succ u3), succ u1, succ u3} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u3} γ) _x) (AddHomClass.toFunLike.{max u1 u3, u1, u3} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (AddMonoidHomClass.toAddHomClass.{max u1 u3, u1, u3} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ))))) (AddMonoidHom.addMonoidHomClass.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))))) (FreeAbelianGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x) (FunLike.coe.{max (succ u2) (succ u3), succ u2, succ u3} (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.{u2} β) (fun (_x : FreeAbelianGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} β) => FreeAbelianGroup.{u3} γ) _x) (AddHomClass.toFunLike.{max u2 u3, u2, u3} (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (AddMonoidHomClass.toAddHomClass.{max u2 u3, u2, u3} (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ))))) (AddMonoidHom.addMonoidHomClass.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))))) (FreeAbelianGroup.map.{u2, u3} β γ g) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u2} β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))))) (FreeAbelianGroup.map.{u1, u2} α β f) x))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_comp_apply FreeAbelianGroup.map_comp_applyₓ'. -/
 theorem map_comp_apply {f : α → β} {g : β → γ} (x : FreeAbelianGroup α) :
     map (g ∘ f) x = (map g) ((map f) x) := by
@@ -626,10 +605,7 @@ instance : Mul (FreeAbelianGroup α) :=
 variable {α}
 
 /- warning: free_abelian_group.mul_def -> FreeAbelianGroup.mul_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.hasMul.{u1} α _inst_1)) x y) (coeFn.{succ u1, succ u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (_x : AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.hasCoeToFun.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (fun (_x : Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) => (α -> (FreeAbelianGroup.{u1} α)) -> (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₂ : α) => coeFn.{succ u1, succ u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (_x : AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.hasCoeToFun.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (fun (_x : Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) => (α -> (FreeAbelianGroup.{u1} α)) -> (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) y)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.mul.{u1} α _inst_1)) x y) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (a : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) a) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (a : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) _x) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (a : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) a) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (a : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (a : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) a) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (a : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) (fun (_x : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) _x) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (_x : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) y)
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.mul_def FreeAbelianGroup.mul_defₓ'. -/
 theorem mul_def (x y : FreeAbelianGroup α) :
     x * y = lift (fun x₂ => lift (fun x₁ => of (x₁ * x₂)) x) y :=
@@ -785,10 +761,7 @@ def liftMonoid : (α →* R) ≃ (FreeAbelianGroup α →+* R)
 -/
 
 /- warning: free_abelian_group.lift_monoid_coe_add_monoid_hom -> FreeAbelianGroup.liftMonoid_coe_addMonoidHom is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Ring.{u2} R] (f : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))), Eq.{max (succ u2) (succ u1)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u2) (succ u1)} a b] => self.0) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (AddMonoidHom.hasCoeT.{u1, u2, max u1 u2} (FreeAbelianGroup.{u1} α) R (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) (RingHomClass.toAddMonoidHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)) (RingHom.ringHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) (coeFn.{max 1 (max (max (succ u2) (succ u1)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u2) (succ u1), max (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) => (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) -> (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u1, u2} α R _inst_1 _inst_2) f)) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) => (α -> R) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (FreeAbelianGroup.lift.{u1, u2} α R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (fun (_x : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) => α -> R) (MonoidHom.hasCoeToFun.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) f))
-but is expected to have type
-  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (AddMonoidHomClass.toAddMonoidHom.{u2, u1, max u2 u1} (FreeAbelianGroup.{u2} α) R ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))) (RingHomClass.toAddMonoidHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (fun (_x : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_coe_add_monoid_hom FreeAbelianGroup.liftMonoid_coe_addMonoidHomₓ'. -/
 @[simp]
 theorem liftMonoid_coe_addMonoidHom (f : α →* R) : ↑(liftMonoid f) = lift f :=
@@ -796,10 +769,7 @@ theorem liftMonoid_coe_addMonoidHom (f : α →* R) : ↑(liftMonoid f) = lift f
 #align free_abelian_group.lift_monoid_coe_add_monoid_hom FreeAbelianGroup.liftMonoid_coe_addMonoidHom
 
 /- warning: free_abelian_group.lift_monoid_coe -> FreeAbelianGroup.liftMonoid_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Ring.{u2} R] (f : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))), Eq.{max (succ u1) (succ u2)} ((FreeAbelianGroup.{u1} α) -> R) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (fun (_x : RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) => (FreeAbelianGroup.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (coeFn.{max 1 (max (max (succ u2) (succ u1)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u2) (succ u1), max (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) => (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) -> (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u1, u2} α R _inst_1 _inst_2) f)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) => (FreeAbelianGroup.{u1} α) -> R) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) => (α -> R) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (FreeAbelianGroup.lift.{u1, u2} α R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (fun (_x : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) => α -> R) (MonoidHom.hasCoeToFun.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) f)))
-but is expected to have type
-  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : FreeAbelianGroup.{u2} α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeAbelianGroup.{u2} α) => R) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeAbelianGroup.{u2} α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonUnitalNonAssocSemiring.toMul.{u2} (FreeAbelianGroup.{u2} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))))) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (NonUnitalRingHomClass.toMulHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (RingHomClass.toNonUnitalRingHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (fun (_x : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2) f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => R) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) R (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_coe FreeAbelianGroup.liftMonoid_coeₓ'. -/
 @[simp]
 theorem liftMonoid_coe (f : α →* R) : ⇑(liftMonoid f) = lift f :=
@@ -807,10 +777,7 @@ theorem liftMonoid_coe (f : α →* R) : ⇑(liftMonoid f) = lift f :=
 #align free_abelian_group.lift_monoid_coe FreeAbelianGroup.liftMonoid_coe
 
 /- warning: free_abelian_group.lift_monoid_symm_coe -> FreeAbelianGroup.liftMonoid_symm_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Ring.{u2} R] (f : RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))), Eq.{max (succ u1) (succ u2)} (α -> R) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (fun (_x : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) => α -> R) (MonoidHom.hasCoeToFun.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) => (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) -> (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) (Equiv.symm.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (FreeAbelianGroup.liftMonoid.{u1, u2} α R _inst_1 _inst_2)) f)) (coeFn.{max 1 (max (max (succ u2) (succ u1)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u2) (succ u1), max (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (α -> R)) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (α -> R)) => (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) -> α -> R) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (α -> R)) (Equiv.symm.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (FreeAbelianGroup.lift.{u1, u2} α R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u2) (succ u1)} a b] => self.0) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (AddMonoidHom.hasCoeT.{u1, u2, max u1 u2} (FreeAbelianGroup.{u1} α) R (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) (RingHomClass.toAddMonoidHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)) (RingHom.ringHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) f))
-but is expected to have type
-  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) f) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) f) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) f) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (fun (_x : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))))) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2)) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (α -> R)) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (fun (_x : AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) => α -> R) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (α -> R)) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2))) (AddMonoidHomClass.toAddMonoidHom.{u2, u1, max u2 u1} (FreeAbelianGroup.{u2} α) R (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (AddMonoidWithOne.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroupWithOne.toAddMonoidWithOne.{u2} (FreeAbelianGroup.{u2} α) (Ring.toAddGroupWithOne.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))))) (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_2)))) (RingHomClass.toAddMonoidHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) f))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_symm_coe FreeAbelianGroup.liftMonoid_symm_coeₓ'. -/
 @[simp]
 theorem liftMonoid_symm_coe (f : FreeAbelianGroup α →+* R) : ⇑(liftMonoid.symm f) = lift.symm ↑f :=

10bf4f82

bump to nightly-2023-05-19-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

a31df521

Diff

@@ -120,7 +120,7 @@ open FreeAbelianGroup
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) (FreeAbelianGroup.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) (FreeAbelianGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) (FreeAbelianGroup.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) (FreeAbelianGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) (FreeAbelianGroup.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.of FreeAbelianGroup.lift.ofₓ'. -/
 @[simp]
 protected theorem of (x : α) : lift f (of x) = f x :=
@@ -133,7 +133,7 @@ protected theorem of (x : α) : lift f (of x) = f x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (g : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))), (forall (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) g (FreeAbelianGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeAbelianGroup.{u1} α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) g x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (g : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) (FreeAbelianGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) g (FreeAbelianGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeAbelianGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (g : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) (FreeAbelianGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) g (FreeAbelianGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeAbelianGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) x))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.unique FreeAbelianGroup.lift.uniqueₓ'. -/
 protected theorem unique (g : FreeAbelianGroup α →+ β) (hg : ∀ x, g (of x) = f x) {x} :
     g x = lift f x :=
@@ -156,7 +156,7 @@ protected theorem ext (g h : FreeAbelianGroup α →+ β) (H : ∀ x, g (of x) =
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_2 : AddCommGroup.{u2} β] [_inst_3 : AddCommGroup.{u3} γ] (a : FreeAbelianGroup.{u1} α) (f : α -> β) (g : AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))), Eq.{succ u3} γ (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) (fun (_x : AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) => β -> γ) (AddMonoidHom.hasCoeToFun.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) g (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_2) f) a)) (coeFn.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) (fun (_x : AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) => (FreeAbelianGroup.{u1} α) -> γ) (AddMonoidHom.hasCoeToFun.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) (coeFn.{max 1 (max (max (succ u1) (succ u3)) (succ u3) (succ u1)) (max (succ u3) (succ u1)) (succ u1) (succ u3), max (max (succ u1) (succ u3)) (succ u3) (succ u1)} (Equiv.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3)))))) (fun (_x : Equiv.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3)))))) => (α -> γ) -> (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3)))))) (FreeAbelianGroup.lift.{u1, u3} α γ _inst_3) (Function.comp.{succ u1, succ u2, succ u3} α β γ (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) (fun (_x : AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) => β -> γ) (AddMonoidHom.hasCoeToFun.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) g) f)) a)
 but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_2 : AddCommGroup.{u2} β] [_inst_3 : AddCommGroup.{u1} γ] (a : FreeAbelianGroup.{u3} α) (f : α -> β) (g : AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) (fun (a : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => β) a) (AddHomClass.toFunLike.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddMonoidHomClass.toAddHomClass.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoidHom.addMonoidHomClass.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))))) (FunLike.coe.{max (succ u2) (succ u3), max (succ u2) (succ u3), max (succ u2) (succ u3)} (Equiv.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (α -> β) (fun (a : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) a) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (FreeAbelianGroup.lift.{u3, u2} α β _inst_2) f) a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (_x : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => β) _x) (AddHomClass.toFunLike.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddMonoidHomClass.toAddHomClass.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoidHom.addMonoidHomClass.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))))) (FunLike.coe.{max (succ u2) (succ u3), max (succ u2) (succ u3), max (succ u2) (succ u3)} (Equiv.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (FreeAbelianGroup.lift.{u3, u2} α β _inst_2) f) a)) (FunLike.coe.{max (succ u1) (succ u3), succ u3, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (a : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) a) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => γ) _x) (AddHomClass.toFunLike.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (a : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) a) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) (FreeAbelianGroup.{u3} α) γ (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (a : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) a) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) (FunLike.coe.{max (succ u1) (succ u3), max (succ u1) (succ u3), max (succ u1) (succ u3)} (Equiv.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))))) (α -> γ) (fun (_x : α -> γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))))) (FreeAbelianGroup.lift.{u3, u1} α γ _inst_3) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (_x : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) a)
+  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_2 : AddCommGroup.{u2} β] [_inst_3 : AddCommGroup.{u1} γ] (a : FreeAbelianGroup.{u3} α) (f : α -> β) (g : AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) (fun (a : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => β) a) (AddHomClass.toFunLike.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddMonoidHomClass.toAddHomClass.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoidHom.addMonoidHomClass.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))))) (FunLike.coe.{max (succ u2) (succ u3), max (succ u2) (succ u3), max (succ u2) (succ u3)} (Equiv.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (α -> β) (fun (a : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) a) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (FreeAbelianGroup.lift.{u3, u2} α β _inst_2) f) a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (_x : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => β) _x) (AddHomClass.toFunLike.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddMonoidHomClass.toAddHomClass.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoidHom.addMonoidHomClass.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))))) (FunLike.coe.{max (succ u2) (succ u3), max (succ u2) (succ u3), max (succ u2) (succ u3)} (Equiv.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (FreeAbelianGroup.lift.{u3, u2} α β _inst_2) f) a)) (FunLike.coe.{max (succ u1) (succ u3), succ u3, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (a : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) a) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => γ) _x) (AddHomClass.toFunLike.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (a : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) a) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) (FreeAbelianGroup.{u3} α) γ (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (a : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) a) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) (FunLike.coe.{max (succ u1) (succ u3), max (succ u1) (succ u3), max (succ u1) (succ u3)} (Equiv.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))))) (α -> γ) (fun (_x : α -> γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))))) (FreeAbelianGroup.lift.{u3, u1} α γ _inst_3) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (_x : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) a)
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.map_hom FreeAbelianGroup.lift.map_homₓ'. -/
 theorem map_hom {α β γ} [AddCommGroup β] [AddCommGroup γ] (a : FreeAbelianGroup α) (f : α → β)
     (g : β →+ γ) : g (lift f a) = lift (g ∘ f) a :=
@@ -209,7 +209,7 @@ protected theorem induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbeli
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (a : FreeAbelianGroup.{u1} α) (f : α -> β) (g : α -> β), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) g) a))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (a : FreeAbelianGroup.{u2} α) (f : α -> β) (g : α -> β), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.754 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.754 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.754 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (instHAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) _inst_1)))))) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) g) a))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (a : FreeAbelianGroup.{u2} α) (f : α -> β) (g : α -> β), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.754 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.754 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.754 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (instHAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) _inst_1)))))) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) g) a))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.add' FreeAbelianGroup.lift.add'ₓ'. -/
 theorem lift.add' {α β} [AddCommGroup β] (a : FreeAbelianGroup α) (f g : α → β) :
     lift (f + g) a = lift f a + lift g a :=
@@ -238,7 +238,7 @@ def liftAddGroupHom {α} (β) [AddCommGroup β] (a : FreeAbelianGroup α) : (α
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) f)) (Neg.neg.{max u2 u1} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHom.hasNeg.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) _inst_1) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.879 : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (Neg.neg.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (AddMonoidHom.instNegAddMonoidHomToAddZeroClassToAddMonoidToSubNegAddMonoidToAddGroup.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) _inst_1) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.879 : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (Neg.neg.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (AddMonoidHom.instNegAddMonoidHomToAddZeroClassToAddMonoidToSubNegAddMonoidToAddGroup.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) _inst_1) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_neg' FreeAbelianGroup.lift_neg'ₓ'. -/
 theorem lift_neg' {β} [AddCommGroup β] (f : α → β) : lift (-f) = -lift f :=
   AddMonoidHom.ext fun _ => (liftAddGroupHom _ _ : (α → β) →+ β).map_neg _
@@ -550,7 +550,7 @@ def map (f : α → β) : FreeAbelianGroup α →+ FreeAbelianGroup β :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : AddCommGroup.{u3} γ] (f : α -> β) (g : β -> γ) (x : FreeAbelianGroup.{u1} α), Eq.{succ u3} γ (coeFn.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) (fun (_x : AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) => (FreeAbelianGroup.{u1} α) -> γ) (AddMonoidHom.hasCoeToFun.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u3)) (succ u3) (succ u1)) (max (succ u3) (succ u1)) (succ u1) (succ u3), max (max (succ u1) (succ u3)) (succ u3) (succ u1)} (Equiv.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) => (α -> γ) -> (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (FreeAbelianGroup.lift.{u1, u3} α γ _inst_1) (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x) (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) (fun (_x : AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) => (FreeAbelianGroup.{u2} β) -> γ) (AddMonoidHom.hasCoeToFun.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) (coeFn.{max 1 (max (max (succ u2) (succ u3)) (succ u3) (succ u2)) (max (succ u3) (succ u2)) (succ u2) (succ u3), max (max (succ u2) (succ u3)) (succ u3) (succ u2)} (Equiv.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (fun (_x : Equiv.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) => (β -> γ) -> (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (FreeAbelianGroup.lift.{u2, u3} β γ _inst_1) g) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u2} β)) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.map.{u1, u2} α β f) x))
 but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : AddCommGroup.{u1} γ] (f : α -> β) (g : β -> γ) (x : FreeAbelianGroup.{u3} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => γ) x) (FunLike.coe.{max (succ u1) (succ u3), succ u3, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => γ) _x) (AddHomClass.toFunLike.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) (FreeAbelianGroup.{u3} α) γ (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u3), max (succ u1) (succ u3), max (succ u1) (succ u3)} (Equiv.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (α -> γ) (fun (_x : α -> γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (FreeAbelianGroup.lift.{u3, u1} α γ _inst_1) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) x) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) g) (FreeAbelianGroup.{u2} β) (fun (_x : FreeAbelianGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} β) => γ) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) g) (FreeAbelianGroup.{u2} β) γ (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) g) (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (β -> γ) (fun (_x : β -> γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} β γ _inst_1) g) (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => FreeAbelianGroup.{u2} β) _x) (AddHomClass.toFunLike.{max u3 u2, u3, u2} (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddMonoidHomClass.toAddHomClass.{max u3 u2, u3, u2} (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoidHom.addMonoidHomClass.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))))) (FreeAbelianGroup.map.{u3, u2} α β f) x))
+  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : AddCommGroup.{u1} γ] (f : α -> β) (g : β -> γ) (x : FreeAbelianGroup.{u3} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => γ) x) (FunLike.coe.{max (succ u1) (succ u3), succ u3, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => γ) _x) (AddHomClass.toFunLike.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) (FreeAbelianGroup.{u3} α) γ (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u3), max (succ u1) (succ u3), max (succ u1) (succ u3)} (Equiv.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (α -> γ) (fun (_x : α -> γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (FreeAbelianGroup.lift.{u3, u1} α γ _inst_1) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) x) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) g) (FreeAbelianGroup.{u2} β) (fun (_x : FreeAbelianGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} β) => γ) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) g) (FreeAbelianGroup.{u2} β) γ (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) g) (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (β -> γ) (fun (_x : β -> γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} β γ _inst_1) g) (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => FreeAbelianGroup.{u2} β) _x) (AddHomClass.toFunLike.{max u3 u2, u3, u2} (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddMonoidHomClass.toAddHomClass.{max u3 u2, u3, u2} (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoidHom.addMonoidHomClass.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))))) (FreeAbelianGroup.map.{u3, u2} α β f) x))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_comp FreeAbelianGroup.lift_compₓ'. -/
 theorem lift_comp {α} {β} {γ} [AddCommGroup γ] (f : α → β) (g : β → γ) (x : FreeAbelianGroup α) :
     lift (g ∘ f) x = lift g (map f x) :=
@@ -629,7 +629,7 @@ variable {α}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.hasMul.{u1} α _inst_1)) x y) (coeFn.{succ u1, succ u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (_x : AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.hasCoeToFun.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (fun (_x : Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) => (α -> (FreeAbelianGroup.{u1} α)) -> (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₂ : α) => coeFn.{succ u1, succ u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (_x : AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.hasCoeToFun.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (fun (_x : Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) => (α -> (FreeAbelianGroup.{u1} α)) -> (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) y)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.mul.{u1} α _inst_1)) x y) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (a : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) a) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (a : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) _x) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (a : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) a) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (a : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (a : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) a) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (a : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) (fun (_x : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) _x) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (_x : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) y)
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.mul.{u1} α _inst_1)) x y) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (a : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) a) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (a : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) _x) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (a : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) a) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (a : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (a : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) a) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (a : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) (fun (_x : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) _x) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (_x : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) y)
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.mul_def FreeAbelianGroup.mul_defₓ'. -/
 theorem mul_def (x y : FreeAbelianGroup α) :
     x * y = lift (fun x₂ => lift (fun x₁ => of (x₁ * x₂)) x) y :=
@@ -745,7 +745,7 @@ def ofMulHom : α →* FreeAbelianGroup α where
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} ((fun (_x : MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) => α -> (FreeAbelianGroup.{u1} α)) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (fun (_x : MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) => α -> (FreeAbelianGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => FreeAbelianGroup.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => FreeAbelianGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (FreeAbelianGroup.{u1} α) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u1} (FreeAbelianGroup.{u1} α) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))))) (MonoidHom.monoidHomClass.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))))) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α)
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => FreeAbelianGroup.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => FreeAbelianGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (FreeAbelianGroup.{u1} α) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u1} (FreeAbelianGroup.{u1} α) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))))) (MonoidHom.monoidHomClass.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))))) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α)
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.of_mul_hom_coe FreeAbelianGroup.ofMulHom_coeₓ'. -/
 @[simp]
 theorem ofMulHom_coe : (ofMulHom : α → FreeAbelianGroup α) = of :=
@@ -788,7 +788,7 @@ def liftMonoid : (α →* R) ≃ (FreeAbelianGroup α →+* R)
 lean 3 declaration is
   forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Ring.{u2} R] (f : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))), Eq.{max (succ u2) (succ u1)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u2) (succ u1)} a b] => self.0) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (AddMonoidHom.hasCoeT.{u1, u2, max u1 u2} (FreeAbelianGroup.{u1} α) R (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) (RingHomClass.toAddMonoidHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)) (RingHom.ringHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) (coeFn.{max 1 (max (max (succ u2) (succ u1)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u2) (succ u1), max (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) => (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) -> (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u1, u2} α R _inst_1 _inst_2) f)) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) => (α -> R) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (FreeAbelianGroup.lift.{u1, u2} α R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (fun (_x : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) => α -> R) (MonoidHom.hasCoeToFun.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) f))
 but is expected to have type
-  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (AddMonoidHomClass.toAddMonoidHom.{u2, u1, max u2 u1} (FreeAbelianGroup.{u2} α) R ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))) (RingHomClass.toAddMonoidHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (fun (_x : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f))
+  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (AddMonoidHomClass.toAddMonoidHom.{u2, u1, max u2 u1} (FreeAbelianGroup.{u2} α) R ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))) (RingHomClass.toAddMonoidHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (fun (_x : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_coe_add_monoid_hom FreeAbelianGroup.liftMonoid_coe_addMonoidHomₓ'. -/
 @[simp]
 theorem liftMonoid_coe_addMonoidHom (f : α →* R) : ↑(liftMonoid f) = lift f :=
@@ -799,7 +799,7 @@ theorem liftMonoid_coe_addMonoidHom (f : α →* R) : ↑(liftMonoid f) = lift f
 lean 3 declaration is
   forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Ring.{u2} R] (f : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))), Eq.{max (succ u1) (succ u2)} ((FreeAbelianGroup.{u1} α) -> R) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (fun (_x : RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) => (FreeAbelianGroup.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (coeFn.{max 1 (max (max (succ u2) (succ u1)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u2) (succ u1), max (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) => (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) -> (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u1, u2} α R _inst_1 _inst_2) f)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) => (FreeAbelianGroup.{u1} α) -> R) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) => (α -> R) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (FreeAbelianGroup.lift.{u1, u2} α R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (fun (_x : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) => α -> R) (MonoidHom.hasCoeToFun.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) f)))
 but is expected to have type
-  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : FreeAbelianGroup.{u2} α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeAbelianGroup.{u2} α) => R) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeAbelianGroup.{u2} α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonUnitalNonAssocSemiring.toMul.{u2} (FreeAbelianGroup.{u2} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))))) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (NonUnitalRingHomClass.toMulHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (RingHomClass.toNonUnitalRingHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (fun (_x : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2) f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => R) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) R (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)))
+  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : FreeAbelianGroup.{u2} α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeAbelianGroup.{u2} α) => R) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeAbelianGroup.{u2} α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonUnitalNonAssocSemiring.toMul.{u2} (FreeAbelianGroup.{u2} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))))) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (NonUnitalRingHomClass.toMulHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (RingHomClass.toNonUnitalRingHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (fun (_x : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2) f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => R) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) R (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_coe FreeAbelianGroup.liftMonoid_coeₓ'. -/
 @[simp]
 theorem liftMonoid_coe (f : α →* R) : ⇑(liftMonoid f) = lift f :=
@@ -810,7 +810,7 @@ theorem liftMonoid_coe (f : α →* R) : ⇑(liftMonoid f) = lift f :=
 lean 3 declaration is
   forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Ring.{u2} R] (f : RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))), Eq.{max (succ u1) (succ u2)} (α -> R) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (fun (_x : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) => α -> R) (MonoidHom.hasCoeToFun.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) => (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) -> (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) (Equiv.symm.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (FreeAbelianGroup.liftMonoid.{u1, u2} α R _inst_1 _inst_2)) f)) (coeFn.{max 1 (max (max (succ u2) (succ u1)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u2) (succ u1), max (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (α -> R)) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (α -> R)) => (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) -> α -> R) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (α -> R)) (Equiv.symm.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (FreeAbelianGroup.lift.{u1, u2} α R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u2) (succ u1)} a b] => self.0) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (AddMonoidHom.hasCoeT.{u1, u2, max u1 u2} (FreeAbelianGroup.{u1} α) R (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) (RingHomClass.toAddMonoidHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)) (RingHom.ringHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) f))
 but is expected to have type
-  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) f) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) f) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) f) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (fun (_x : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))))) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2)) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (α -> R)) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (fun (_x : AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) => α -> R) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (α -> R)) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2))) (AddMonoidHomClass.toAddMonoidHom.{u2, u1, max u2 u1} (FreeAbelianGroup.{u2} α) R (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (AddMonoidWithOne.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroupWithOne.toAddMonoidWithOne.{u2} (FreeAbelianGroup.{u2} α) (Ring.toAddGroupWithOne.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))))) (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_2)))) (RingHomClass.toAddMonoidHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) f))
+  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) f) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) f) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) f) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (fun (_x : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))))) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2)) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (α -> R)) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (fun (_x : AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) => α -> R) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (α -> R)) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2))) (AddMonoidHomClass.toAddMonoidHom.{u2, u1, max u2 u1} (FreeAbelianGroup.{u2} α) R (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (AddMonoidWithOne.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroupWithOne.toAddMonoidWithOne.{u2} (FreeAbelianGroup.{u2} α) (Ring.toAddGroupWithOne.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))))) (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_2)))) (RingHomClass.toAddMonoidHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) f))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_symm_coe FreeAbelianGroup.liftMonoid_symm_coeₓ'. -/
 @[simp]
 theorem liftMonoid_symm_coe (f : FreeAbelianGroup α →+* R) : ⇑(liftMonoid.symm f) = lift.symm ↑f :=

10bf4f82

bump to nightly-2023-05-16-14

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

b356e20f

Diff

@@ -209,7 +209,7 @@ protected theorem induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbeli
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (a : FreeAbelianGroup.{u1} α) (f : α -> β) (g : α -> β), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) g) a))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (a : FreeAbelianGroup.{u2} α) (f : α -> β) (g : α -> β), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.785 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.785 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.785 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (instHAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) _inst_1)))))) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) g) a))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (a : FreeAbelianGroup.{u2} α) (f : α -> β) (g : α -> β), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.754 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.754 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.754 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (instHAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) _inst_1)))))) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) g) a))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.add' FreeAbelianGroup.lift.add'ₓ'. -/
 theorem lift.add' {α β} [AddCommGroup β] (a : FreeAbelianGroup α) (f g : α → β) :
     lift (f + g) a = lift f a + lift g a :=
@@ -238,7 +238,7 @@ def liftAddGroupHom {α} (β) [AddCommGroup β] (a : FreeAbelianGroup α) : (α
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) f)) (Neg.neg.{max u2 u1} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHom.hasNeg.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) _inst_1) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.910 : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (Neg.neg.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (AddMonoidHom.instNegAddMonoidHomToAddZeroClassToAddMonoidToSubNegAddMonoidToAddGroup.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) _inst_1) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.879 : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (Neg.neg.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (AddMonoidHom.instNegAddMonoidHomToAddZeroClassToAddMonoidToSubNegAddMonoidToAddGroup.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) _inst_1) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_neg' FreeAbelianGroup.lift_neg'ₓ'. -/
 theorem lift_neg' {β} [AddCommGroup β] (f : α → β) : lift (-f) = -lift f :=
   AddMonoidHom.ext fun _ => (liftAddGroupHom _ _ : (α → β) →+ β).map_neg _
@@ -394,7 +394,7 @@ theorem sub_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toHasSeq.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toHasPure.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) (α -> β) f) x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1668 : Unit) => x)) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x)
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1637 : Unit) => x)) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x)
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.pure_seq FreeAbelianGroup.pure_seqₓ'. -/
 @[simp]
 theorem pure_seq (f : α → β) (x : FreeAbelianGroup α) : pure f <*> x = f <$> x :=
@@ -405,7 +405,7 @@ theorem pure_seq (f : α → β) (x : FreeAbelianGroup α) : pure f <*> x = f <$
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))))) x) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))))) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1702 : Unit) => x)) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
+  forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))))) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1671 : Unit) => x)) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.zero_seq FreeAbelianGroup.zero_seqₓ'. -/
 @[simp]
 theorem zero_seq (x : FreeAbelianGroup α) : (0 : FreeAbelianGroup (α → β)) <*> x = 0 :=
@@ -416,7 +416,7 @@ theorem zero_seq (x : FreeAbelianGroup α) : (0 : FreeAbelianGroup (α → β))
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) x) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β g x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1740 : Unit) => x)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1751 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1761 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1709 : Unit) => x)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1720 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1730 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.add_seq FreeAbelianGroup.add_seqₓ'. -/
 @[simp]
 theorem add_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
@@ -428,7 +428,7 @@ theorem add_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))) f) x) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1793 : Unit) => x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1804 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1762 : Unit) => x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1773 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.neg_seq FreeAbelianGroup.neg_seqₓ'. -/
 @[simp]
 theorem neg_seq (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : -f <*> x = -(f <*> x) :=
@@ -439,7 +439,7 @@ theorem neg_seq (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : -
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) x) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β g x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1842 : Unit) => x)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1853 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1863 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1811 : Unit) => x)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1822 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1832 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.sub_seq FreeAbelianGroup.sub_seqₓ'. -/
 @[simp]
 theorem sub_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
@@ -463,7 +463,7 @@ def seqAddGroupHom (f : FreeAbelianGroup (α → β)) : FreeAbelianGroup α →+
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2012 : Unit) => OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1981 : Unit) => OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_zero FreeAbelianGroup.seq_zeroₓ'. -/
 @[simp]
 theorem seq_zero (f : FreeAbelianGroup (α → β)) : f <*> 0 = 0 :=
@@ -474,7 +474,7 @@ theorem seq_zero (f : FreeAbelianGroup (α → β)) : f <*> 0 = 0 :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2045 : Unit) => HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2060 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2070 : Unit) => y)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2014 : Unit) => HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2029 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2039 : Unit) => y)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_add FreeAbelianGroup.seq_addₓ'. -/
 @[simp]
 theorem seq_add (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
@@ -486,7 +486,7 @@ theorem seq_add (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2102 : Unit) => Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2116 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2071 : Unit) => Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2085 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_neg FreeAbelianGroup.seq_negₓ'. -/
 @[simp]
 theorem seq_neg (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : f <*> -x = -(f <*> x) :=
@@ -497,7 +497,7 @@ theorem seq_neg (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2149 : Unit) => HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2164 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2174 : Unit) => y)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2118 : Unit) => HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2133 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2143 : Unit) => y)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_sub FreeAbelianGroup.seq_subₓ'. -/
 @[simp]
 theorem seq_sub (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :

10bf4f82

bump to nightly-2023-05-08-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/08e1d8d4d989df3a6df86f385e9053ec8a372cc1

63e712c6

Diff

@@ -745,7 +745,7 @@ def ofMulHom : α →* FreeAbelianGroup α where
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} ((fun (_x : MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) => α -> (FreeAbelianGroup.{u1} α)) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (fun (_x : MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) => α -> (FreeAbelianGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => FreeAbelianGroup.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => FreeAbelianGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (FreeAbelianGroup.{u1} α) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u1} (FreeAbelianGroup.{u1} α) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))))) (MonoidHom.monoidHomClass.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))))) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α)
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => FreeAbelianGroup.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => FreeAbelianGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (FreeAbelianGroup.{u1} α) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u1} (FreeAbelianGroup.{u1} α) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))))) (MonoidHom.monoidHomClass.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (Semiring.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toSemiring.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))))) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α)
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.of_mul_hom_coe FreeAbelianGroup.ofMulHom_coeₓ'. -/
 @[simp]
 theorem ofMulHom_coe : (ofMulHom : α → FreeAbelianGroup α) = of :=
@@ -788,7 +788,7 @@ def liftMonoid : (α →* R) ≃ (FreeAbelianGroup α →+* R)
 lean 3 declaration is
   forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Ring.{u2} R] (f : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))), Eq.{max (succ u2) (succ u1)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u2) (succ u1)} a b] => self.0) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (AddMonoidHom.hasCoeT.{u1, u2, max u1 u2} (FreeAbelianGroup.{u1} α) R (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) (RingHomClass.toAddMonoidHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)) (RingHom.ringHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) (coeFn.{max 1 (max (max (succ u2) (succ u1)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u2) (succ u1), max (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) => (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) -> (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u1, u2} α R _inst_1 _inst_2) f)) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) => (α -> R) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (FreeAbelianGroup.lift.{u1, u2} α R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (fun (_x : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) => α -> R) (MonoidHom.hasCoeToFun.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) f))
 but is expected to have type
-  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) f)) (AddMonoidHomClass.toAddMonoidHom.{u2, u1, max u2 u1} (FreeAbelianGroup.{u2} α) R ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) f) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))) (RingHomClass.toAddMonoidHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (fun (_x : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) f))
+  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (AddMonoidHomClass.toAddMonoidHom.{u2, u1, max u2 u1} (FreeAbelianGroup.{u2} α) R ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))) (RingHomClass.toAddMonoidHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (fun (_x : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_coe_add_monoid_hom FreeAbelianGroup.liftMonoid_coe_addMonoidHomₓ'. -/
 @[simp]
 theorem liftMonoid_coe_addMonoidHom (f : α →* R) : ↑(liftMonoid f) = lift f :=
@@ -799,7 +799,7 @@ theorem liftMonoid_coe_addMonoidHom (f : α →* R) : ↑(liftMonoid f) = lift f
 lean 3 declaration is
   forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Ring.{u2} R] (f : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))), Eq.{max (succ u1) (succ u2)} ((FreeAbelianGroup.{u1} α) -> R) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (fun (_x : RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) => (FreeAbelianGroup.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (coeFn.{max 1 (max (max (succ u2) (succ u1)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u2) (succ u1), max (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) => (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) -> (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u1, u2} α R _inst_1 _inst_2) f)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) => (FreeAbelianGroup.{u1} α) -> R) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) => (α -> R) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (FreeAbelianGroup.lift.{u1, u2} α R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (fun (_x : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) => α -> R) (MonoidHom.hasCoeToFun.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) f)))
 but is expected to have type
-  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : FreeAbelianGroup.{u2} α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeAbelianGroup.{u2} α) => R) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeAbelianGroup.{u2} α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonUnitalNonAssocSemiring.toMul.{u2} (FreeAbelianGroup.{u2} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))))) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (NonUnitalRingHomClass.toMulHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (RingHomClass.toNonUnitalRingHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (fun (_x : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2) f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => R) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) R (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) f)))
+  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : FreeAbelianGroup.{u2} α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeAbelianGroup.{u2} α) => R) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeAbelianGroup.{u2} α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonUnitalNonAssocSemiring.toMul.{u2} (FreeAbelianGroup.{u2} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))))) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (NonUnitalRingHomClass.toMulHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (RingHomClass.toNonUnitalRingHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (fun (_x : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2) f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => R) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) R (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) f)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_coe FreeAbelianGroup.liftMonoid_coeₓ'. -/
 @[simp]
 theorem liftMonoid_coe (f : α →* R) : ⇑(liftMonoid f) = lift f :=
@@ -810,7 +810,7 @@ theorem liftMonoid_coe (f : α →* R) : ⇑(liftMonoid f) = lift f :=
 lean 3 declaration is
   forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Ring.{u2} R] (f : RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))), Eq.{max (succ u1) (succ u2)} (α -> R) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (fun (_x : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) => α -> R) (MonoidHom.hasCoeToFun.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) => (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) -> (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) (Equiv.symm.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (FreeAbelianGroup.liftMonoid.{u1, u2} α R _inst_1 _inst_2)) f)) (coeFn.{max 1 (max (max (succ u2) (succ u1)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u2) (succ u1), max (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (α -> R)) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (α -> R)) => (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) -> α -> R) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (α -> R)) (Equiv.symm.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (FreeAbelianGroup.lift.{u1, u2} α R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u2) (succ u1)} a b] => self.0) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (AddMonoidHom.hasCoeT.{u1, u2, max u1 u2} (FreeAbelianGroup.{u1} α) R (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) (RingHomClass.toAddMonoidHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)) (RingHom.ringHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) f))
 but is expected to have type
-  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) f) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) f) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) f) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (fun (_x : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))))) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2)) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (α -> R)) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (fun (_x : AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) => α -> R) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (α -> R)) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2))) (AddMonoidHomClass.toAddMonoidHom.{u2, u1, max u2 u1} (FreeAbelianGroup.{u2} α) R (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (AddMonoidWithOne.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroupWithOne.toAddMonoidWithOne.{u2} (FreeAbelianGroup.{u2} α) (Ring.toAddGroupWithOne.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))))) (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_2)))) (RingHomClass.toAddMonoidHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) f))
+  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) f) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) f) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) f) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (fun (_x : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))))) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2)) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (α -> R)) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (fun (_x : AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) => α -> R) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (α -> R)) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2))) (AddMonoidHomClass.toAddMonoidHom.{u2, u1, max u2 u1} (FreeAbelianGroup.{u2} α) R (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (AddMonoidWithOne.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroupWithOne.toAddMonoidWithOne.{u2} (FreeAbelianGroup.{u2} α) (Ring.toAddGroupWithOne.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))))) (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_2)))) (RingHomClass.toAddMonoidHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2))) (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (Semiring.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toSemiring.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R _inst_2)))) f))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_symm_coe FreeAbelianGroup.liftMonoid_symm_coeₓ'. -/
 @[simp]
 theorem liftMonoid_symm_coe (f : FreeAbelianGroup α →+* R) : ⇑(liftMonoid.symm f) = lift.symm ↑f :=

10bf4f82

bump to nightly-2023-04-17-10

mathlib commit https://github.com/leanprover-community/mathlib/commit/17ad94b4953419f3e3ce3e77da3239c62d1d09f0

f9776b40

Diff

@@ -209,7 +209,7 @@ protected theorem induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbeli
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (a : FreeAbelianGroup.{u1} α) (f : α -> β) (g : α -> β), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) g) a))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (a : FreeAbelianGroup.{u2} α) (f : α -> β) (g : α -> β), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.784 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.784 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.784 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (instHAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) _inst_1)))))) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) g) a))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (a : FreeAbelianGroup.{u2} α) (f : α -> β) (g : α -> β), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.785 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.785 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.785 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (instHAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) _inst_1)))))) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) g) a))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.add' FreeAbelianGroup.lift.add'ₓ'. -/
 theorem lift.add' {α β} [AddCommGroup β] (a : FreeAbelianGroup α) (f g : α → β) :
     lift (f + g) a = lift f a + lift g a :=
@@ -238,7 +238,7 @@ def liftAddGroupHom {α} (β) [AddCommGroup β] (a : FreeAbelianGroup α) : (α
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) f)) (Neg.neg.{max u2 u1} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHom.hasNeg.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) _inst_1) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.909 : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (Neg.neg.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (AddMonoidHom.instNegAddMonoidHomToAddZeroClassToAddMonoidToSubNegAddMonoidToAddGroup.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) _inst_1) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.910 : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (Neg.neg.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (AddMonoidHom.instNegAddMonoidHomToAddZeroClassToAddMonoidToSubNegAddMonoidToAddGroup.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) _inst_1) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_neg' FreeAbelianGroup.lift_neg'ₓ'. -/
 theorem lift_neg' {β} [AddCommGroup β] (f : α → β) : lift (-f) = -lift f :=
   AddMonoidHom.ext fun _ => (liftAddGroupHom _ _ : (α → β) →+ β).map_neg _
@@ -394,7 +394,7 @@ theorem sub_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toHasSeq.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toHasPure.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) (α -> β) f) x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1667 : Unit) => x)) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x)
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1668 : Unit) => x)) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x)
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.pure_seq FreeAbelianGroup.pure_seqₓ'. -/
 @[simp]
 theorem pure_seq (f : α → β) (x : FreeAbelianGroup α) : pure f <*> x = f <$> x :=
@@ -405,7 +405,7 @@ theorem pure_seq (f : α → β) (x : FreeAbelianGroup α) : pure f <*> x = f <$
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))))) x) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))))) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1701 : Unit) => x)) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
+  forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))))) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1702 : Unit) => x)) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.zero_seq FreeAbelianGroup.zero_seqₓ'. -/
 @[simp]
 theorem zero_seq (x : FreeAbelianGroup α) : (0 : FreeAbelianGroup (α → β)) <*> x = 0 :=
@@ -416,7 +416,7 @@ theorem zero_seq (x : FreeAbelianGroup α) : (0 : FreeAbelianGroup (α → β))
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) x) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β g x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1739 : Unit) => x)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1750 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1760 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1740 : Unit) => x)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1751 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1761 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.add_seq FreeAbelianGroup.add_seqₓ'. -/
 @[simp]
 theorem add_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
@@ -428,7 +428,7 @@ theorem add_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))) f) x) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1792 : Unit) => x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1803 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1793 : Unit) => x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1804 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.neg_seq FreeAbelianGroup.neg_seqₓ'. -/
 @[simp]
 theorem neg_seq (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : -f <*> x = -(f <*> x) :=
@@ -439,7 +439,7 @@ theorem neg_seq (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : -
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) x) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β g x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1841 : Unit) => x)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1852 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1862 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1842 : Unit) => x)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1853 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1863 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.sub_seq FreeAbelianGroup.sub_seqₓ'. -/
 @[simp]
 theorem sub_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
@@ -463,7 +463,7 @@ def seqAddGroupHom (f : FreeAbelianGroup (α → β)) : FreeAbelianGroup α →+
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2011 : Unit) => OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2012 : Unit) => OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_zero FreeAbelianGroup.seq_zeroₓ'. -/
 @[simp]
 theorem seq_zero (f : FreeAbelianGroup (α → β)) : f <*> 0 = 0 :=
@@ -474,7 +474,7 @@ theorem seq_zero (f : FreeAbelianGroup (α → β)) : f <*> 0 = 0 :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2044 : Unit) => HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2059 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2069 : Unit) => y)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2045 : Unit) => HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2060 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2070 : Unit) => y)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_add FreeAbelianGroup.seq_addₓ'. -/
 @[simp]
 theorem seq_add (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
@@ -486,7 +486,7 @@ theorem seq_add (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2101 : Unit) => Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2115 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2102 : Unit) => Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2116 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_neg FreeAbelianGroup.seq_negₓ'. -/
 @[simp]
 theorem seq_neg (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : f <*> -x = -(f <*> x) :=
@@ -497,7 +497,7 @@ theorem seq_neg (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2148 : Unit) => HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2163 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2173 : Unit) => y)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2149 : Unit) => HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2164 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2174 : Unit) => y)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_sub FreeAbelianGroup.seq_subₓ'. -/
 @[simp]
 theorem seq_sub (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :

10bf4f82

bump to nightly-2023-03-17-00

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce7e9d53d4bbc38065db3b595cd5bd73c323bc1d

c85864d4

Diff

@@ -125,7 +125,7 @@ Case conversion may be inaccurate. Consider using '#align free_abelian_group.lif
 @[simp]
 protected theorem of (x : α) : lift f (of x) = f x :=
   by
-  convert @Abelianization.lift.of (FreeGroup α) _ (Multiplicative β) _ _ _
+  convert@Abelianization.lift.of (FreeGroup α) _ (Multiplicative β) _ _ _
   convert free_group.lift.of.symm
 #align free_abelian_group.lift.of FreeAbelianGroup.lift.of
 
@@ -209,7 +209,7 @@ protected theorem induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbeli
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (a : FreeAbelianGroup.{u1} α) (f : α -> β) (g : α -> β), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) g) a))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (a : FreeAbelianGroup.{u2} α) (f : α -> β) (g : α -> β), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.751 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.751 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.751 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (instHAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) _inst_1)))))) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) g) a))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (a : FreeAbelianGroup.{u2} α) (f : α -> β) (g : α -> β), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.784 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.784 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.784 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (instHAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) _inst_1)))))) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) g) a))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.add' FreeAbelianGroup.lift.add'ₓ'. -/
 theorem lift.add' {α β} [AddCommGroup β] (a : FreeAbelianGroup α) (f g : α → β) :
     lift (f + g) a = lift f a + lift g a :=
@@ -238,7 +238,7 @@ def liftAddGroupHom {α} (β) [AddCommGroup β] (a : FreeAbelianGroup α) : (α
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) f)) (Neg.neg.{max u2 u1} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHom.hasNeg.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) _inst_1) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.876 : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (Neg.neg.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (AddMonoidHom.instNegAddMonoidHomToAddZeroClassToAddMonoidToSubNegAddMonoidToAddGroup.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) _inst_1) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.909 : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (Neg.neg.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (AddMonoidHom.instNegAddMonoidHomToAddZeroClassToAddMonoidToSubNegAddMonoidToAddGroup.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) _inst_1) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_neg' FreeAbelianGroup.lift_neg'ₓ'. -/
 theorem lift_neg' {β} [AddCommGroup β] (f : α → β) : lift (-f) = -lift f :=
   AddMonoidHom.ext fun _ => (liftAddGroupHom _ _ : (α → β) →+ β).map_neg _
@@ -394,7 +394,7 @@ theorem sub_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toHasSeq.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toHasPure.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) (α -> β) f) x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1634 : Unit) => x)) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x)
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1667 : Unit) => x)) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x)
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.pure_seq FreeAbelianGroup.pure_seqₓ'. -/
 @[simp]
 theorem pure_seq (f : α → β) (x : FreeAbelianGroup α) : pure f <*> x = f <$> x :=
@@ -405,7 +405,7 @@ theorem pure_seq (f : α → β) (x : FreeAbelianGroup α) : pure f <*> x = f <$
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))))) x) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))))) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1668 : Unit) => x)) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
+  forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))))) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1701 : Unit) => x)) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.zero_seq FreeAbelianGroup.zero_seqₓ'. -/
 @[simp]
 theorem zero_seq (x : FreeAbelianGroup α) : (0 : FreeAbelianGroup (α → β)) <*> x = 0 :=
@@ -416,7 +416,7 @@ theorem zero_seq (x : FreeAbelianGroup α) : (0 : FreeAbelianGroup (α → β))
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) x) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β g x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1706 : Unit) => x)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1717 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1727 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1739 : Unit) => x)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1750 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1760 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.add_seq FreeAbelianGroup.add_seqₓ'. -/
 @[simp]
 theorem add_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
@@ -428,7 +428,7 @@ theorem add_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))) f) x) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1759 : Unit) => x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1770 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1792 : Unit) => x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1803 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.neg_seq FreeAbelianGroup.neg_seqₓ'. -/
 @[simp]
 theorem neg_seq (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : -f <*> x = -(f <*> x) :=
@@ -439,7 +439,7 @@ theorem neg_seq (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : -
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) x) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β g x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1808 : Unit) => x)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1819 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1829 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1841 : Unit) => x)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1852 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1862 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.sub_seq FreeAbelianGroup.sub_seqₓ'. -/
 @[simp]
 theorem sub_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
@@ -463,7 +463,7 @@ def seqAddGroupHom (f : FreeAbelianGroup (α → β)) : FreeAbelianGroup α →+
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1978 : Unit) => OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2011 : Unit) => OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_zero FreeAbelianGroup.seq_zeroₓ'. -/
 @[simp]
 theorem seq_zero (f : FreeAbelianGroup (α → β)) : f <*> 0 = 0 :=
@@ -474,7 +474,7 @@ theorem seq_zero (f : FreeAbelianGroup (α → β)) : f <*> 0 = 0 :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2011 : Unit) => HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2026 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2036 : Unit) => y)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2044 : Unit) => HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2059 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2069 : Unit) => y)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_add FreeAbelianGroup.seq_addₓ'. -/
 @[simp]
 theorem seq_add (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
@@ -486,7 +486,7 @@ theorem seq_add (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2068 : Unit) => Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2082 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2101 : Unit) => Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2115 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_neg FreeAbelianGroup.seq_negₓ'. -/
 @[simp]
 theorem seq_neg (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : f <*> -x = -(f <*> x) :=
@@ -497,7 +497,7 @@ theorem seq_neg (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2115 : Unit) => HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2130 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2140 : Unit) => y)))
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2148 : Unit) => HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2163 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2173 : Unit) => y)))
 Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_sub FreeAbelianGroup.seq_subₓ'. -/
 @[simp]
 theorem seq_sub (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :

10bf4f82

bump to nightly-2023-03-16-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce7e9d53d4bbc38065db3b595cd5bd73c323bc1d

8ae28b0b

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
 
 ! This file was ported from Lean 3 source module group_theory.free_abelian_group
-! leanprover-community/mathlib commit 70fd9563a21e7b963887c9360bd29b2393e6225a
+! leanprover-community/mathlib commit 10bf4f825ad729c5653adc039dafa3622e7f93c9
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,6 +16,9 @@ import Mathbin.Algebra.Module.Basic
 /-!
 # Free abelian groups
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 The free abelian group on a type `α`, defined as the abelianisation of
 the free group on `α`.

70fd9563

bump to nightly-2023-03-14-14

mathlib commit https://github.com/leanprover-community/mathlib/commit/2196ab363eb097c008d4497125e0dde23fb36db2

8ccbd772

Diff

@@ -75,10 +75,12 @@ universe u v
 
 variable (α : Type u)
 
+#print FreeAbelianGroup /-
 /-- The free abelian group on a type. -/
 def FreeAbelianGroup : Type u :=
   Additive <| Abelianization <| FreeGroup α
 #align free_abelian_group FreeAbelianGroup
+-/
 
 instance : AddCommGroup (FreeAbelianGroup α) :=
   @Additive.addCommGroup _ <| Abelianization.commGroup _
@@ -90,16 +92,20 @@ variable {α}
 
 namespace FreeAbelianGroup
 
+#print FreeAbelianGroup.of /-
 /-- The canonical map from α to `free_abelian_group α` -/
 def of (x : α) : FreeAbelianGroup α :=
   Abelianization.of <| FreeGroup.of x
 #align free_abelian_group.of FreeAbelianGroup.of
+-/
 
+#print FreeAbelianGroup.lift /-
 /-- The map `free_abelian_group α →+ A` induced by a map of types `α → A`. -/
 def lift {β : Type v} [AddCommGroup β] : (α → β) ≃ (FreeAbelianGroup α →+ β) :=
   (@FreeGroup.lift _ (Multiplicative β) _).trans <|
     (@Abelianization.lift _ _ (Multiplicative β) _).trans MonoidHom.toAdditive
 #align free_abelian_group.lift FreeAbelianGroup.lift
+-/
 
 namespace lift
 
@@ -107,6 +113,12 @@ variable {β : Type v} [AddCommGroup β] (f : α → β)
 
 open FreeAbelianGroup
 
+/- warning: free_abelian_group.lift.of -> FreeAbelianGroup.lift.of is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) (FreeAbelianGroup.of.{u1} α x)) (f x)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) (FreeAbelianGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) (FreeAbelianGroup.of.{u1} α x)) (f x)
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.of FreeAbelianGroup.lift.ofₓ'. -/
 @[simp]
 protected theorem of (x : α) : lift f (of x) = f x :=
   by
@@ -114,17 +126,35 @@ protected theorem of (x : α) : lift f (of x) = f x :=
   convert free_group.lift.of.symm
 #align free_abelian_group.lift.of FreeAbelianGroup.lift.of
 
+/- warning: free_abelian_group.lift.unique -> FreeAbelianGroup.lift.unique is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (g : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))), (forall (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) g (FreeAbelianGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeAbelianGroup.{u1} α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) g x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β) (g : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) (FreeAbelianGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) g (FreeAbelianGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeAbelianGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) f) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) x))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.unique FreeAbelianGroup.lift.uniqueₓ'. -/
 protected theorem unique (g : FreeAbelianGroup α →+ β) (hg : ∀ x, g (of x) = f x) {x} :
     g x = lift f x :=
   AddMonoidHom.congr_fun (lift.symm_apply_eq.mp (funext hg : g ∘ of = f)) _
 #align free_abelian_group.lift.unique FreeAbelianGroup.lift.unique
 
+/- warning: free_abelian_group.lift.ext -> FreeAbelianGroup.lift.ext is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (g : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (h : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))), (forall (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) g (FreeAbelianGroup.of.{u1} α x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) h (FreeAbelianGroup.of.{u1} α x))) -> (Eq.{max (succ u2) (succ u1)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) g h)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (g : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (h : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) (FreeAbelianGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) g (FreeAbelianGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) h (FreeAbelianGroup.of.{u1} α x))) -> (Eq.{max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) g h)
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.ext FreeAbelianGroup.lift.extₓ'. -/
 /-- See note [partially-applied ext lemmas]. -/
 @[ext]
 protected theorem ext (g h : FreeAbelianGroup α →+ β) (H : ∀ x, g (of x) = h (of x)) : g = h :=
   lift.symm.Injective <| funext H
 #align free_abelian_group.lift.ext FreeAbelianGroup.lift.ext
 
+/- warning: free_abelian_group.lift.map_hom -> FreeAbelianGroup.lift.map_hom is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_2 : AddCommGroup.{u2} β] [_inst_3 : AddCommGroup.{u3} γ] (a : FreeAbelianGroup.{u1} α) (f : α -> β) (g : AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))), Eq.{succ u3} γ (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) (fun (_x : AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) => β -> γ) (AddMonoidHom.hasCoeToFun.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) g (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_2) f) a)) (coeFn.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) (fun (_x : AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) => (FreeAbelianGroup.{u1} α) -> γ) (AddMonoidHom.hasCoeToFun.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) (coeFn.{max 1 (max (max (succ u1) (succ u3)) (succ u3) (succ u1)) (max (succ u3) (succ u1)) (succ u1) (succ u3), max (max (succ u1) (succ u3)) (succ u3) (succ u1)} (Equiv.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3)))))) (fun (_x : Equiv.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3)))))) => (α -> γ) -> (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3)))))) (FreeAbelianGroup.lift.{u1, u3} α γ _inst_3) (Function.comp.{succ u1, succ u2, succ u3} α β γ (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) (fun (_x : AddMonoidHom.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) => β -> γ) (AddMonoidHom.hasCoeToFun.{u2, u3} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_3))))) g) f)) a)
+but is expected to have type
+  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_2 : AddCommGroup.{u2} β] [_inst_3 : AddCommGroup.{u1} γ] (a : FreeAbelianGroup.{u3} α) (f : α -> β) (g : AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) (fun (a : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => β) a) (AddHomClass.toFunLike.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddMonoidHomClass.toAddHomClass.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoidHom.addMonoidHomClass.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))))) (FunLike.coe.{max (succ u2) (succ u3), max (succ u2) (succ u3), max (succ u2) (succ u3)} (Equiv.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (α -> β) (fun (a : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) a) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (FreeAbelianGroup.lift.{u3, u2} α β _inst_2) f) a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (_x : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => β) _x) (AddHomClass.toFunLike.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddMonoidHomClass.toAddHomClass.{max u2 u3, u3, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) f) (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoidHom.addMonoidHomClass.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))))) (FunLike.coe.{max (succ u2) (succ u3), max (succ u2) (succ u3), max (succ u2) (succ u3)} (Equiv.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (α -> β) (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) β (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))))) (FreeAbelianGroup.lift.{u3, u2} α β _inst_2) f) a)) (FunLike.coe.{max (succ u1) (succ u3), succ u3, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (a : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) a) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => γ) _x) (AddHomClass.toFunLike.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (a : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) a) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) (FreeAbelianGroup.{u3} α) γ (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (a : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) a) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) (FunLike.coe.{max (succ u1) (succ u3), max (succ u1) (succ u3), max (succ u1) (succ u3)} (Equiv.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))))) (α -> γ) (fun (_x : α -> γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))))) (FreeAbelianGroup.lift.{u3, u1} α γ _inst_3) (Function.comp.{succ u3, succ u2, succ u1} α β γ (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β (fun (_x : β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : β) => γ) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} (AddMonoidHom.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))) β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} β γ (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_2)))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_3))))))) g) f)) a)
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.map_hom FreeAbelianGroup.lift.map_homₓ'. -/
 theorem map_hom {α β γ} [AddCommGroup β] [AddCommGroup γ] (a : FreeAbelianGroup α) (f : α → β)
     (g : β →+ γ) : g (lift f a) = lift (g ∘ f) a :=
   by
@@ -142,6 +172,7 @@ section
 
 open Classical
 
+#print FreeAbelianGroup.of_injective /-
 theorem of_injective : Function.Injective (of : α → FreeAbelianGroup α) := fun x y hoxy =>
   by_contradiction fun hxy : x ≠ y =>
     let f : FreeAbelianGroup α →+ ℤ := lift fun z => if x = z then (1 : ℤ) else 0
@@ -150,11 +181,18 @@ theorem of_injective : Function.Injective (of : α → FreeAbelianGroup α) := f
     have hfy0 : f (of y) = 0 := (lift.of _ _).trans <| if_neg hxy
     one_ne_zero <| hfy1.symm.trans hfy0
 #align free_abelian_group.of_injective FreeAbelianGroup.of_injective
+-/
 
 end
 
 attribute [local instance] QuotientGroup.leftRel
 
+/- warning: free_abelian_group.induction_on -> FreeAbelianGroup.induction_on is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {C : (FreeAbelianGroup.{u1} α) -> Prop} (z : FreeAbelianGroup.{u1} α), (C (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))))) -> (forall (x : α), C (FreeAbelianGroup.of.{u1} α x)) -> (forall (x : α), (C (FreeAbelianGroup.of.{u1} α x)) -> (C (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) (FreeAbelianGroup.of.{u1} α x)))) -> (forall (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y))) -> (C z)
+but is expected to have type
+  forall {α : Type.{u1}} {C : (FreeAbelianGroup.{u1} α) -> Prop} (z : FreeAbelianGroup.{u1} α), (C (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) -> (forall (x : α), C (FreeAbelianGroup.of.{u1} α x)) -> (forall (x : α), (C (FreeAbelianGroup.of.{u1} α x)) -> (C (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.of.{u1} α x)))) -> (forall (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y))) -> (C z)
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.induction_on FreeAbelianGroup.induction_onₓ'. -/
 @[elab_as_elim]
 protected theorem induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α) (C0 : C 0)
     (C1 : ∀ x, C <| of x) (Cn : ∀ x, C (of x) → C (-of x)) (Cp : ∀ x y, C x → C y → C (x + y)) :
@@ -164,6 +202,12 @@ protected theorem induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbeli
       List.recOn L C0 fun ⟨x, b⟩ tl ih => Bool.recOn b (Cp _ _ (Cn _ (C1 x)) ih) (Cp _ _ (C1 x) ih)
 #align free_abelian_group.induction_on FreeAbelianGroup.induction_on
 
+/- warning: free_abelian_group.lift.add' -> FreeAbelianGroup.lift.add' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (a : FreeAbelianGroup.{u1} α) (f : α -> β) (g : α -> β), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f) a) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) => (FreeAbelianGroup.{u1} α) -> β) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) g) a))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (a : FreeAbelianGroup.{u2} α) (f : α -> β) (g : α -> β), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.751 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.751 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.751 : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) f g)) a) (HAdd.hAdd.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (instHAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) a) _inst_1)))))) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f) a) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => β) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) g) (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) g) a))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift.add' FreeAbelianGroup.lift.add'ₓ'. -/
 theorem lift.add' {α β} [AddCommGroup β] (a : FreeAbelianGroup α) (f g : α → β) :
     lift (f + g) a = lift f a + lift g a :=
   by
@@ -177,6 +221,7 @@ theorem lift.add' {α β} [AddCommGroup β] (a : FreeAbelianGroup α) (f g : α
     simp only [(lift _).map_add, hx, hy, add_add_add_comm]
 #align free_abelian_group.lift.add' FreeAbelianGroup.lift.add'
 
+#print FreeAbelianGroup.liftAddGroupHom /-
 /-- If `g : free_abelian_group X` and `A` is an abelian group then `lift_add_group_hom g`
 is the additive group homomorphism sending a function `X → A` to the term of type `A`
 corresponding to the evaluation of the induced map `free_abelian_group X → A` at `g`. -/
@@ -184,7 +229,14 @@ corresponding to the evaluation of the induced map `free_abelian_group X → A`
 def liftAddGroupHom {α} (β) [AddCommGroup β] (a : FreeAbelianGroup α) : (α → β) →+ β :=
   AddMonoidHom.mk' (fun f => lift f a) (lift.add' a)
 #align free_abelian_group.lift_add_group_hom FreeAbelianGroup.liftAddGroupHom
+-/
 
+/- warning: free_abelian_group.lift_neg' -> FreeAbelianGroup.lift_neg' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddCommGroup.{u2} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))) f)) (Neg.neg.{max u2 u1} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1))))) (AddMonoidHom.hasNeg.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) _inst_1) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) => (α -> β) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) β (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β _inst_1)))))) (FreeAbelianGroup.lift.{u1, u2} α β _inst_1) f))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddCommGroup.{u1} β] (f : α -> β), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (a._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.876 : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β _inst_1)))))) f)) (Neg.neg.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) f) (AddMonoidHom.instNegAddMonoidHomToAddZeroClassToAddMonoidToSubNegAddMonoidToAddGroup.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) _inst_1) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) β (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (AddCommGroup.toAddGroup.{u1} β _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} α β _inst_1) f))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_neg' FreeAbelianGroup.lift_neg'ₓ'. -/
 theorem lift_neg' {β} [AddCommGroup β] (f : α → β) : lift (-f) = -lift f :=
   AddMonoidHom.ext fun _ => (liftAddGroupHom _ _ : (α → β) →+ β).map_neg _
 #align free_abelian_group.lift_neg' FreeAbelianGroup.lift_neg'
@@ -197,6 +249,12 @@ instance : Monad FreeAbelianGroup.{u} where
   pure α := of
   bind α β x f := lift f x
 
+/- warning: free_abelian_group.induction_on' -> FreeAbelianGroup.induction_on' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {C : (FreeAbelianGroup.{u1} α) -> Prop} (z : FreeAbelianGroup.{u1} α), (C (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))))) -> (forall (x : α), C (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α x)) -> (forall (x : α), (C (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α x)) -> (C (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α x)))) -> (forall (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y))) -> (C z)
+but is expected to have type
+  forall {α : Type.{u1}} {C : (FreeAbelianGroup.{u1} α) -> Prop} (z : FreeAbelianGroup.{u1} α), (C (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) -> (forall (x : α), C (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α x)) -> (forall (x : α), (C (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α x)) -> (C (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α x)))) -> (forall (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y))) -> (C z)
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.induction_on' FreeAbelianGroup.induction_on'ₓ'. -/
 @[elab_as_elim]
 protected theorem induction_on' {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α) (C0 : C 0)
     (C1 : ∀ x, C <| pure x) (Cn : ∀ x, C (pure x) → C (-pure x))
@@ -204,92 +262,189 @@ protected theorem induction_on' {C : FreeAbelianGroup α → Prop} (z : FreeAbel
   FreeAbelianGroup.induction_on z C0 C1 Cn Cp
 #align free_abelian_group.induction_on' FreeAbelianGroup.induction_on'
 
+/- warning: free_abelian_group.map_pure -> FreeAbelianGroup.map_pure is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β f (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α x)) (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) β (f x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α x)) (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) β (f x))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_pure FreeAbelianGroup.map_pureₓ'. -/
 @[simp]
 theorem map_pure (f : α → β) (x : α) : f <$> (pure x : FreeAbelianGroup α) = pure (f x) :=
   rfl
 #align free_abelian_group.map_pure FreeAbelianGroup.map_pure
 
+/- warning: free_abelian_group.map_zero -> FreeAbelianGroup.map_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β f (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_zero FreeAbelianGroup.map_zeroₓ'. -/
 @[simp]
 protected theorem map_zero (f : α → β) : f <$> (0 : FreeAbelianGroup α) = 0 :=
   (lift (of ∘ f)).map_zero
 #align free_abelian_group.map_zero FreeAbelianGroup.map_zero
 
+/- warning: free_abelian_group.map_add -> FreeAbelianGroup.map_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β f (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f y))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_add FreeAbelianGroup.map_addₓ'. -/
 @[simp]
 protected theorem map_add (f : α → β) (x y : FreeAbelianGroup α) :
     f <$> (x + y) = f <$> x + f <$> y :=
   (lift _).map_add _ _
 #align free_abelian_group.map_add FreeAbelianGroup.map_add
 
+/- warning: free_abelian_group.map_neg -> FreeAbelianGroup.map_neg is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β f (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_neg FreeAbelianGroup.map_negₓ'. -/
 @[simp]
 protected theorem map_neg (f : α → β) (x : FreeAbelianGroup α) : f <$> (-x) = -f <$> x :=
   map_neg (lift <| of ∘ f) _
 #align free_abelian_group.map_neg FreeAbelianGroup.map_neg
 
+/- warning: free_abelian_group.map_sub -> FreeAbelianGroup.map_sub is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β f (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f y))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_sub FreeAbelianGroup.map_subₓ'. -/
 @[simp]
 protected theorem map_sub (f : α → β) (x y : FreeAbelianGroup α) :
     f <$> (x - y) = f <$> x - f <$> y :=
   map_sub (lift <| of ∘ f) _ _
 #align free_abelian_group.map_sub FreeAbelianGroup.map_sub
 
+/- warning: free_abelian_group.map_of -> FreeAbelianGroup.map_of is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (y : α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (FreeAbelianGroup.of.{u1} α y)) (FreeAbelianGroup.of.{u1} β (f y))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (y : α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (FreeAbelianGroup.of.{u1} α y)) (FreeAbelianGroup.of.{u1} β (f y))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_of FreeAbelianGroup.map_ofₓ'. -/
 @[simp]
 theorem map_of (f : α → β) (y : α) : f <$> of y = of (f y) :=
   rfl
 #align free_abelian_group.map_of FreeAbelianGroup.map_of
 
+/- warning: free_abelian_group.pure_bind -> FreeAbelianGroup.pure_bind is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α x) f) (f x)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α x) f) (f x)
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.pure_bind FreeAbelianGroup.pure_bindₓ'. -/
 @[simp]
 theorem pure_bind (f : α → FreeAbelianGroup β) (x) : pure x >>= f = f x :=
   lift.of _ _
 #align free_abelian_group.pure_bind FreeAbelianGroup.pure_bind
 
+/- warning: free_abelian_group.zero_bind -> FreeAbelianGroup.zero_bind is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) f) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) f) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.zero_bind FreeAbelianGroup.zero_bindₓ'. -/
 @[simp]
 theorem zero_bind (f : α → FreeAbelianGroup β) : 0 >>= f = 0 :=
   (lift f).map_zero
 #align free_abelian_group.zero_bind FreeAbelianGroup.zero_bind
 
+/- warning: free_abelian_group.add_bind -> FreeAbelianGroup.add_bind is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y) f) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β x f) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β y f))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y) f) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β x f) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β y f))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.add_bind FreeAbelianGroup.add_bindₓ'. -/
 @[simp]
 theorem add_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
     x + y >>= f = (x >>= f) + (y >>= f) :=
   (lift _).map_add _ _
 #align free_abelian_group.add_bind FreeAbelianGroup.add_bind
 
+/- warning: free_abelian_group.neg_bind -> FreeAbelianGroup.neg_bind is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) x) f) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β x f))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) x) f) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β x f))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.neg_bind FreeAbelianGroup.neg_bindₓ'. -/
 @[simp]
 theorem neg_bind (f : α → FreeAbelianGroup β) (x : FreeAbelianGroup α) : -x >>= f = -(x >>= f) :=
   map_neg (lift f) _
 #align free_abelian_group.neg_bind FreeAbelianGroup.neg_bind
 
+/- warning: free_abelian_group.sub_bind -> FreeAbelianGroup.sub_bind is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y) f) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β x f) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toHasBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1}) α β y f))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeAbelianGroup.{u1} β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y) f) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β x f) (Bind.bind.{u1, u1} FreeAbelianGroup.{u1} (Monad.toBind.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1}) α β y f))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.sub_bind FreeAbelianGroup.sub_bindₓ'. -/
 @[simp]
 theorem sub_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
     x - y >>= f = (x >>= f) - (y >>= f) :=
   map_sub (lift f) _ _
 #align free_abelian_group.sub_bind FreeAbelianGroup.sub_bind
 
+/- warning: free_abelian_group.pure_seq -> FreeAbelianGroup.pure_seq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toHasSeq.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) α β (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Applicative.toHasPure.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeAbelianGroup.{u1} α) FreeAbelianGroup.monad.{u1})) (α -> β) f) x) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Pure.pure.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toPure.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1634 : Unit) => x)) (Functor.map.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f x)
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.pure_seq FreeAbelianGroup.pure_seqₓ'. -/
 @[simp]
 theorem pure_seq (f : α → β) (x : FreeAbelianGroup α) : pure f <*> x = f <$> x :=
   pure_bind _ _
 #align free_abelian_group.pure_seq FreeAbelianGroup.pure_seq
 
+/- warning: free_abelian_group.zero_seq -> FreeAbelianGroup.zero_seq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))))) x) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} (α -> β)) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))))) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1668 : Unit) => x)) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.zero_seq FreeAbelianGroup.zero_seqₓ'. -/
 @[simp]
 theorem zero_seq (x : FreeAbelianGroup α) : (0 : FreeAbelianGroup (α → β)) <*> x = 0 :=
   zero_bind _
 #align free_abelian_group.zero_seq FreeAbelianGroup.zero_seq
 
+/- warning: free_abelian_group.add_seq -> FreeAbelianGroup.add_seq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) x) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β g x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1706 : Unit) => x)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1717 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1727 : Unit) => x)))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.add_seq FreeAbelianGroup.add_seqₓ'. -/
 @[simp]
 theorem add_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
     f + g <*> x = (f <*> x) + (g <*> x) :=
   add_bind _ _ _
 #align free_abelian_group.add_seq FreeAbelianGroup.add_seq
 
+/- warning: free_abelian_group.neg_seq -> FreeAbelianGroup.neg_seq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))) f) x) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (Neg.neg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β))))))) f) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1759 : Unit) => x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1770 : Unit) => x)))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.neg_seq FreeAbelianGroup.neg_seqₓ'. -/
 @[simp]
 theorem neg_seq (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : -f <*> x = -(f <*> x) :=
   neg_bind _ _
 #align free_abelian_group.neg_seq FreeAbelianGroup.neg_seq
 
+/- warning: free_abelian_group.sub_seq -> FreeAbelianGroup.sub_seq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) x) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β g x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (g : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.{u1} (α -> β)) (instHSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} (α -> β)) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} (α -> β)) (FreeAbelianGroup.addCommGroup.{u1} (α -> β)))))) f g) (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1808 : Unit) => x)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1819 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β g (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1829 : Unit) => x)))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.sub_seq FreeAbelianGroup.sub_seqₓ'. -/
 @[simp]
 theorem sub_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
     f - g <*> x = (f <*> x) - (g <*> x) :=
   sub_bind _ _ _
 #align free_abelian_group.sub_seq FreeAbelianGroup.sub_seq
 
+#print FreeAbelianGroup.seqAddGroupHom /-
 /-- If `f : free_abelian_group (α → β)`, then `f <*>` is an additive morphism
 `free_abelian_group α →+ free_abelian_group β`. -/
 def seqAddGroupHom (f : FreeAbelianGroup (α → β)) : FreeAbelianGroup α →+ FreeAbelianGroup β :=
@@ -299,23 +454,48 @@ def seqAddGroupHom (f : FreeAbelianGroup (α → β)) : FreeAbelianGroup α →+
       simp only [FreeAbelianGroup.map_add]
       exact lift.add' f _ _
 #align free_abelian_group.seq_add_group_hom FreeAbelianGroup.seqAddGroupHom
+-/
 
+/- warning: free_abelian_group.seq_zero -> FreeAbelianGroup.seq_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.zero.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasZero.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.1978 : Unit) => OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} β) 0 (Zero.toOfNat0.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toZero.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_zero FreeAbelianGroup.seq_zeroₓ'. -/
 @[simp]
 theorem seq_zero (f : FreeAbelianGroup (α → β)) : f <*> 0 = 0 :=
   (seqAddGroupHom f).map_zero
 #align free_abelian_group.seq_zero FreeAbelianGroup.seq_zero
 
+/- warning: free_abelian_group.seq_add -> FreeAbelianGroup.seq_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2011 : Unit) => HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHAdd.{u1} (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) x y)) (HAdd.hAdd.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHAdd.{u1} (FreeAbelianGroup.{u1} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2026 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2036 : Unit) => y)))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_add FreeAbelianGroup.seq_addₓ'. -/
 @[simp]
 theorem seq_add (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
     f <*> x + y = (f <*> x) + (f <*> y) :=
   (seqAddGroupHom f).map_add x y
 #align free_abelian_group.seq_add FreeAbelianGroup.seq_add
 
+/- warning: free_abelian_group.seq_neg -> FreeAbelianGroup.seq_neg is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasNeg.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2068 : Unit) => Neg.neg.{u1} (FreeAbelianGroup.{u1} α) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} α) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} α) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) x)) (Neg.neg.{u1} (FreeAbelianGroup.{u1} β) (NegZeroClass.toNeg.{u1} (FreeAbelianGroup.{u1} β) (SubNegZeroMonoid.toNegZeroClass.{u1} (FreeAbelianGroup.{u1} β) (SubtractionMonoid.toSubNegZeroMonoid.{u1} (FreeAbelianGroup.{u1} β) (SubtractionCommMonoid.toSubtractionMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toDivisionAddCommMonoid.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β)))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2082 : Unit) => x)))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_neg FreeAbelianGroup.seq_negₓ'. -/
 @[simp]
 theorem seq_neg (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : f <*> -x = -(f <*> x) :=
   (seqAddGroupHom f).map_neg x
 #align free_abelian_group.seq_neg FreeAbelianGroup.seq_neg
 
+/- warning: free_abelian_group.seq_sub -> FreeAbelianGroup.seq_sub is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toHasSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.monad.{u1})) α β f y))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : FreeAbelianGroup.{u1} (α -> β)) (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} β) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2115 : Unit) => HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHSub.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) x y)) (HSub.hSub.{u1, u1, u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.{u1} β) (instHSub.{u1} (FreeAbelianGroup.{u1} β) (SubNegMonoid.toSub.{u1} (FreeAbelianGroup.{u1} β) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} β) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} β) (FreeAbelianGroup.addCommGroup.{u1} β))))) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2130 : Unit) => x)) (Seq.seq.{u1, u1} FreeAbelianGroup.{u1} (Applicative.toSeq.{u1, u1} FreeAbelianGroup.{u1} (Monad.toApplicative.{u1, u1} FreeAbelianGroup.{u1} FreeAbelianGroup.instMonadFreeAbelianGroup.{u1})) α β f (fun (x._@.Mathlib.GroupTheory.FreeAbelianGroup._hyg.2140 : Unit) => y)))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.seq_sub FreeAbelianGroup.seq_subₓ'. -/
 @[simp]
 theorem seq_sub (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
     f <*> x - y = (f <*> x) - (f <*> y) :=
@@ -355,12 +535,20 @@ universe w
 
 variable {β : Type v} {γ : Type w}
 
+#print FreeAbelianGroup.map /-
 /-- The additive group homomorphism `free_abelian_group α →+ free_abelian_group β` induced from a
   map `α → β` -/
 def map (f : α → β) : FreeAbelianGroup α →+ FreeAbelianGroup β :=
   lift (of ∘ f)
 #align free_abelian_group.map FreeAbelianGroup.map
+-/
 
+/- warning: free_abelian_group.lift_comp -> FreeAbelianGroup.lift_comp is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : AddCommGroup.{u3} γ] (f : α -> β) (g : β -> γ) (x : FreeAbelianGroup.{u1} α), Eq.{succ u3} γ (coeFn.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) (fun (_x : AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) => (FreeAbelianGroup.{u1} α) -> γ) (AddMonoidHom.hasCoeToFun.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) (coeFn.{max 1 (max (max (succ u1) (succ u3)) (succ u3) (succ u1)) (max (succ u3) (succ u1)) (succ u1) (succ u3), max (max (succ u1) (succ u3)) (succ u3) (succ u1)} (Equiv.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (fun (_x : Equiv.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) => (α -> γ) -> (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (α -> γ) (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) γ (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (FreeAbelianGroup.lift.{u1, u3} α γ _inst_1) (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x) (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) (fun (_x : AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) => (FreeAbelianGroup.{u2} β) -> γ) (AddMonoidHom.hasCoeToFun.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1))))) (coeFn.{max 1 (max (max (succ u2) (succ u3)) (succ u3) (succ u2)) (max (succ u3) (succ u2)) (succ u2) (succ u3), max (max (succ u2) (succ u3)) (succ u3) (succ u2)} (Equiv.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (fun (_x : Equiv.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) => (β -> γ) -> (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (Equiv.hasCoeToFun.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} γ (SubNegMonoid.toAddMonoid.{u3} γ (AddGroup.toSubNegMonoid.{u3} γ (AddCommGroup.toAddGroup.{u3} γ _inst_1)))))) (FreeAbelianGroup.lift.{u2, u3} β γ _inst_1) g) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u2} β)) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.map.{u1, u2} α β f) x))
+but is expected to have type
+  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : AddCommGroup.{u1} γ] (f : α -> β) (g : β -> γ) (x : FreeAbelianGroup.{u3} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => γ) x) (FunLike.coe.{max (succ u1) (succ u3), succ u3, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => γ) _x) (AddHomClass.toFunLike.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) (FreeAbelianGroup.{u3} α) γ (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u3, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u3), max (succ u1) (succ u3), max (succ u1) (succ u3)} (Equiv.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (α -> γ) (fun (_x : α -> γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> γ) => AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (α -> γ) (AddMonoidHom.{u3, u1} (FreeAbelianGroup.{u3} α) γ (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (FreeAbelianGroup.lift.{u3, u1} α γ _inst_1) (Function.comp.{succ u3, succ u2, succ u1} α β γ g f)) x) (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) g) (FreeAbelianGroup.{u2} β) (fun (_x : FreeAbelianGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} β) => γ) _x) (AddHomClass.toFunLike.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) g) (FreeAbelianGroup.{u2} β) γ (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddZeroClass.toAdd.{u1} γ (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) g) (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (β -> γ) (fun (_x : β -> γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β -> γ) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (β -> γ) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} β) γ (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u1} γ (SubNegMonoid.toAddMonoid.{u1} γ (AddGroup.toSubNegMonoid.{u1} γ (AddCommGroup.toAddGroup.{u1} γ _inst_1)))))) (FreeAbelianGroup.lift.{u2, u1} β γ _inst_1) g) (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u3} α) (fun (_x : FreeAbelianGroup.{u3} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u3} α) => FreeAbelianGroup.{u2} β) _x) (AddHomClass.toFunLike.{max u3 u2, u3, u2} (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} α) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α)))))) (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddMonoidHomClass.toAddHomClass.{max u3 u2, u3, u2} (AddMonoidHom.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoidHom.addMonoidHomClass.{u3, u2} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} α) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} α) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} α) (FreeAbelianGroup.addCommGroup.{u3} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))))) (FreeAbelianGroup.map.{u3, u2} α β f) x))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_comp FreeAbelianGroup.lift_compₓ'. -/
 theorem lift_comp {α} {β} {γ} [AddCommGroup γ] (f : α → β) (g : β → γ) (x : FreeAbelianGroup α) :
     lift (g ∘ f) x = lift g (map f x) :=
   by
@@ -374,27 +562,49 @@ theorem lift_comp {α} {β} {γ} [AddCommGroup γ] (f : α → β) (g : β → 
     simp only [h₁, h₂, AddMonoidHom.map_add]
 #align free_abelian_group.lift_comp FreeAbelianGroup.lift_comp
 
+#print FreeAbelianGroup.map_id /-
 theorem map_id : map id = AddMonoidHom.id (FreeAbelianGroup α) :=
   Eq.symm <|
     lift.ext _ _ fun x => lift.unique of (AddMonoidHom.id _) fun y => AddMonoidHom.id_apply _ _
 #align free_abelian_group.map_id FreeAbelianGroup.map_id
+-/
 
+/- warning: free_abelian_group.map_id_apply -> FreeAbelianGroup.map_id_apply is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (coeFn.{succ u1, succ u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (_x : AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.hasCoeToFun.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
+but is expected to have type
+  forall {α : Type.{u1}} (x : FreeAbelianGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) _x) (AddHomClass.toFunLike.{u1, u1, u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FreeAbelianGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_id_apply FreeAbelianGroup.map_id_applyₓ'. -/
 theorem map_id_apply (x : FreeAbelianGroup α) : map id x = x :=
   by
   rw [map_id]
   rfl
 #align free_abelian_group.map_id_apply FreeAbelianGroup.map_id_apply
 
+#print FreeAbelianGroup.map_comp /-
 theorem map_comp {f : α → β} {g : β → γ} : map (g ∘ f) = (map g).comp (map f) :=
   Eq.symm <| lift.ext _ _ fun x => Eq.symm <| lift_comp _ _ _
 #align free_abelian_group.map_comp FreeAbelianGroup.map_comp
+-/
 
+/- warning: free_abelian_group.map_comp_apply -> FreeAbelianGroup.map_comp_apply is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {g : β -> γ} (x : FreeAbelianGroup.{u1} α), Eq.{succ u3} (FreeAbelianGroup.{u3} γ) (coeFn.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (fun (_x : AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u3} γ)) (AddMonoidHom.hasCoeToFun.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x) (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (fun (_x : AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) => (FreeAbelianGroup.{u2} β) -> (FreeAbelianGroup.{u3} γ)) (AddMonoidHom.hasCoeToFun.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.map.{u2, u3} β γ g) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u2} β)) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.map.{u1, u2} α β f) x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {g : β -> γ} (x : FreeAbelianGroup.{u1} α), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u3} γ) x) (FunLike.coe.{max (succ u1) (succ u3), succ u1, succ u3} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u3} γ) _x) (AddHomClass.toFunLike.{max u1 u3, u1, u3} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (AddMonoidHomClass.toAddHomClass.{max u1 u3, u1, u3} (AddMonoidHom.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ))))) (AddMonoidHom.addMonoidHomClass.{u1, u3} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))))) (FreeAbelianGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x) (FunLike.coe.{max (succ u2) (succ u3), succ u2, succ u3} (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.{u2} β) (fun (_x : FreeAbelianGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} β) => FreeAbelianGroup.{u3} γ) _x) (AddHomClass.toFunLike.{max u2 u3, u2, u3} (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddZeroClass.toAdd.{u3} (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (AddMonoidHomClass.toAddHomClass.{max u2 u3, u2, u3} (AddMonoidHom.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))) (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ))))) (AddMonoidHom.addMonoidHomClass.{u2, u3} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.{u3} γ) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoid.toAddZeroClass.{u3} (FreeAbelianGroup.{u3} γ) (SubNegMonoid.toAddMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddGroup.toSubNegMonoid.{u3} (FreeAbelianGroup.{u3} γ) (AddCommGroup.toAddGroup.{u3} (FreeAbelianGroup.{u3} γ) (FreeAbelianGroup.addCommGroup.{u3} γ)))))))) (FreeAbelianGroup.map.{u2, u3} β γ g) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u2} β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))))) (FreeAbelianGroup.map.{u1, u2} α β f) x))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_comp_apply FreeAbelianGroup.map_comp_applyₓ'. -/
 theorem map_comp_apply {f : α → β} {g : β → γ} (x : FreeAbelianGroup α) :
     map (g ∘ f) x = (map g) ((map f) x) := by
   rw [map_comp]
   rfl
 #align free_abelian_group.map_comp_apply FreeAbelianGroup.map_comp_apply
 
+/- warning: free_abelian_group.map_of_apply -> FreeAbelianGroup.map_of_apply is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (a : α), Eq.{succ u2} (FreeAbelianGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u2} β)) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.map.{u1, u2} α β f) (FreeAbelianGroup.of.{u1} α a)) (FreeAbelianGroup.of.{u2} β (f a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (a : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u2} β) (FreeAbelianGroup.of.{u1} α a)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u2} β) _x) (AddHomClass.toFunLike.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (AddMonoidHomClass.toAddHomClass.{max u1 u2, u1, u2} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β))))) (AddMonoidHom.addMonoidHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))))) (FreeAbelianGroup.map.{u1, u2} α β f) (FreeAbelianGroup.of.{u1} α a)) (FreeAbelianGroup.of.{u2} β (f a))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.map_of_apply FreeAbelianGroup.map_of_applyₓ'. -/
 -- version of map_of which uses `map`
 @[simp]
 theorem map_of_apply {f : α → β} (a : α) : map f (of a) = of (f a) :=
@@ -412,16 +622,34 @@ instance : Mul (FreeAbelianGroup α) :=
 
 variable {α}
 
+/- warning: free_abelian_group.mul_def -> FreeAbelianGroup.mul_def is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.hasMul.{u1} α _inst_1)) x y) (coeFn.{succ u1, succ u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (_x : AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.hasCoeToFun.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (fun (_x : Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) => (α -> (FreeAbelianGroup.{u1} α)) -> (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₂ : α) => coeFn.{succ u1, succ u1} (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (_x : AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) => (FreeAbelianGroup.{u1} α) -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.hasCoeToFun.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (fun (_x : Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) => (α -> (FreeAbelianGroup.{u1} α)) -> (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) y)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : FreeAbelianGroup.{u1} α) (y : FreeAbelianGroup.{u1} α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.mul.{u1} α _inst_1)) x y) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (a : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) a) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (a : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) _x) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (a : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) a) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (a : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (a : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) a) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (a : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) (fun (_x : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (SubNegMonoid.toAddMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddGroup.toSubNegMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (AddCommGroup.toAddGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) x) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₂ : α) => FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (fun (_x : FreeAbelianGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u1} α) => FreeAbelianGroup.{u1} α) _x) (AddHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (α -> (FreeAbelianGroup.{u1} α)) (fun (_x : α -> (FreeAbelianGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeAbelianGroup.{u1} α)) => AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeAbelianGroup.{u1} α)) (AddMonoidHom.{u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))))) (FreeAbelianGroup.lift.{u1, u1} α (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)) (fun (x₁ : α) => FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x₁ x₂))) x)) y)
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.mul_def FreeAbelianGroup.mul_defₓ'. -/
 theorem mul_def (x y : FreeAbelianGroup α) :
     x * y = lift (fun x₂ => lift (fun x₁ => of (x₁ * x₂)) x) y :=
   rfl
 #align free_abelian_group.mul_def FreeAbelianGroup.mul_def
 
+/- warning: free_abelian_group.of_mul_of -> FreeAbelianGroup.of_mul_of is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : α) (y : α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.hasMul.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α x) (FreeAbelianGroup.of.{u1} α y)) (FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x y))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : α) (y : α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.mul.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α x) (FreeAbelianGroup.of.{u1} α y)) (FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x y))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.of_mul_of FreeAbelianGroup.of_mul_ofₓ'. -/
 @[simp]
 theorem of_mul_of (x y : α) : of x * of y = of (x * y) :=
   rfl
 #align free_abelian_group.of_mul_of FreeAbelianGroup.of_mul_of
 
+/- warning: free_abelian_group.of_mul -> FreeAbelianGroup.of_mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : α) (y : α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x y)) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.hasMul.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α x) (FreeAbelianGroup.of.{u1} α y))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] (x : α) (y : α), Eq.{succ u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.of.{u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) x y)) (HMul.hMul.{u1, u1, u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u1} α) (instHMul.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.mul.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α x) (FreeAbelianGroup.of.{u1} α y))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.of_mul FreeAbelianGroup.of_mulₓ'. -/
 theorem of_mul (x y : α) : of (x * y) = of x * of y :=
   rfl
 #align free_abelian_group.of_mul FreeAbelianGroup.of_mul
@@ -501,18 +729,27 @@ instance : Ring (FreeAbelianGroup α) :=
 
 variable {α}
 
+#print FreeAbelianGroup.ofMulHom /-
 /-- `free_abelian_group.of` is a `monoid_hom` when `α` is a `monoid`. -/
 def ofMulHom : α →* FreeAbelianGroup α where
   toFun := of
   map_one' := rfl
   map_mul' := of_mul
 #align free_abelian_group.of_mul_hom FreeAbelianGroup.ofMulHom
+-/
 
+/- warning: free_abelian_group.of_mul_hom_coe -> FreeAbelianGroup.ofMulHom_coe is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} ((fun (_x : MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) => α -> (FreeAbelianGroup.{u1} α)) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (fun (_x : MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) => α -> (FreeAbelianGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => FreeAbelianGroup.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => FreeAbelianGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (FreeAbelianGroup.{u1} α) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toMul.{u1} (FreeAbelianGroup.{u1} α) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))) α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))))) (MonoidHom.monoidHomClass.{u1, u1} α (FreeAbelianGroup.{u1} α) (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocSemiring.toMulZeroOneClass.{u1} (FreeAbelianGroup.{u1} α) (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1)))))))) (FreeAbelianGroup.ofMulHom.{u1} α _inst_1)) (FreeAbelianGroup.of.{u1} α)
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.of_mul_hom_coe FreeAbelianGroup.ofMulHom_coeₓ'. -/
 @[simp]
 theorem ofMulHom_coe : (ofMulHom : α → FreeAbelianGroup α) = of :=
   rfl
 #align free_abelian_group.of_mul_hom_coe FreeAbelianGroup.ofMulHom_coe
 
+#print FreeAbelianGroup.liftMonoid /-
 /-- If `f` preserves multiplication, then so does `lift f`. -/
 def liftMonoid : (α →* R) ≃ (FreeAbelianGroup α →+* R)
     where
@@ -542,26 +779,57 @@ def liftMonoid : (α →* R) ≃ (FreeAbelianGroup α →+* R)
   right_inv F :=
     RingHom.coe_addMonoidHom_injective <| lift.apply_symm_apply (↑F : FreeAbelianGroup α →+ R)
 #align free_abelian_group.lift_monoid FreeAbelianGroup.liftMonoid
+-/
 
+/- warning: free_abelian_group.lift_monoid_coe_add_monoid_hom -> FreeAbelianGroup.liftMonoid_coe_addMonoidHom is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Ring.{u2} R] (f : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))), Eq.{max (succ u2) (succ u1)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u2) (succ u1)} a b] => self.0) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (AddMonoidHom.hasCoeT.{u1, u2, max u1 u2} (FreeAbelianGroup.{u1} α) R (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) (RingHomClass.toAddMonoidHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)) (RingHom.ringHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) (coeFn.{max 1 (max (max (succ u2) (succ u1)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u2) (succ u1), max (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) => (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) -> (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u1, u2} α R _inst_1 _inst_2) f)) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) => (α -> R) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (FreeAbelianGroup.lift.{u1, u2} α R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (fun (_x : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) => α -> R) (MonoidHom.hasCoeToFun.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) f))
+but is expected to have type
+  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))), Eq.{max (succ u2) (succ u1)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) f)) (AddMonoidHomClass.toAddMonoidHom.{u2, u1, max u2 u1} (FreeAbelianGroup.{u2} α) R ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) f) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))) (RingHomClass.toAddMonoidHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (fun (_x : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) f))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_coe_add_monoid_hom FreeAbelianGroup.liftMonoid_coe_addMonoidHomₓ'. -/
 @[simp]
 theorem liftMonoid_coe_addMonoidHom (f : α →* R) : ↑(liftMonoid f) = lift f :=
   rfl
 #align free_abelian_group.lift_monoid_coe_add_monoid_hom FreeAbelianGroup.liftMonoid_coe_addMonoidHom
 
+/- warning: free_abelian_group.lift_monoid_coe -> FreeAbelianGroup.liftMonoid_coe is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Ring.{u2} R] (f : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))), Eq.{max (succ u1) (succ u2)} ((FreeAbelianGroup.{u1} α) -> R) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (fun (_x : RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) => (FreeAbelianGroup.{u1} α) -> R) (RingHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (coeFn.{max 1 (max (max (succ u2) (succ u1)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u2) (succ u1), max (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) => (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) -> (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u1, u2} α R _inst_1 _inst_2) f)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (fun (_x : AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) => (FreeAbelianGroup.{u1} α) -> R) (AddMonoidHom.hasCoeToFun.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) => (α -> R) -> (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))))) (FreeAbelianGroup.lift.{u1, u2} α R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (fun (_x : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) => α -> R) (MonoidHom.hasCoeToFun.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) f)))
+but is expected to have type
+  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : FreeAbelianGroup.{u2} α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeAbelianGroup.{u2} α) => R) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeAbelianGroup.{u2} α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonUnitalNonAssocSemiring.toMul.{u2} (FreeAbelianGroup.{u2} α) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))))) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (NonUnitalRingHomClass.toMulHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1)))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (RingHomClass.toNonUnitalRingHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) f) (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (fun (_x : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) => RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2) f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) (fun (_x : FreeAbelianGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : FreeAbelianGroup.{u2} α) => R) _x) (AddHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) R (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} α) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α)))))) (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (AddMonoidHomClass.toAddHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) a) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) f)) (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))) (AddMonoidHom.addMonoidHomClass.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (α -> R) (fun (_x : α -> R) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> R) => AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2))))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) f)))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_coe FreeAbelianGroup.liftMonoid_coeₓ'. -/
 @[simp]
 theorem liftMonoid_coe (f : α →* R) : ⇑(liftMonoid f) = lift f :=
   rfl
 #align free_abelian_group.lift_monoid_coe FreeAbelianGroup.liftMonoid_coe
 
+/- warning: free_abelian_group.lift_monoid_symm_coe -> FreeAbelianGroup.liftMonoid_symm_coe is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {R : Type.{u2}} [_inst_1 : Monoid.{u1} α] [_inst_2 : Ring.{u2} R] (f : RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))), Eq.{max (succ u1) (succ u2)} (α -> R) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (fun (_x : MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) => α -> R) (MonoidHom.hasCoeToFun.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) => (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) -> (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))) (Equiv.symm.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} α R (Monoid.toMulOneClass.{u1} α _inst_1) (MulZeroOneClass.toMulOneClass.{u2} R (NonAssocSemiring.toMulZeroOneClass.{u2} R (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (FreeAbelianGroup.liftMonoid.{u1, u2} α R _inst_1 _inst_2)) f)) (coeFn.{max 1 (max (max (succ u2) (succ u1)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u2) (succ u1), max (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (α -> R)) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (α -> R)) => (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) -> α -> R) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (α -> R)) (Equiv.symm.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> R) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (FreeAbelianGroup.lift.{u1, u2} α R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u2) (succ u1)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u2) (succ u1)} a b] => self.0) (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoidHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)))))))) (AddMonoidHom.hasCoeT.{u1, u2, max u1 u2} (FreeAbelianGroup.{u1} α) R (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α))))) (AddMonoid.toAddZeroClass.{u2} R (SubNegMonoid.toAddMonoid.{u2} R (AddGroup.toSubNegMonoid.{u2} R (AddCommGroup.toAddGroup.{u2} R (NonUnitalNonAssocRing.toAddCommGroup.{u2} R (NonAssocRing.toNonUnitalNonAssocRing.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) (RingHomClass.toAddMonoidHomClass.{max u1 u2, u1, u2} (RingHom.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))) (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2)) (RingHom.ringHomClass.{u1, u2} (FreeAbelianGroup.{u1} α) R (NonAssocRing.toNonAssocSemiring.{u1} (FreeAbelianGroup.{u1} α) (Ring.toNonAssocRing.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.ring.{u1} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u2} R (Ring.toNonAssocRing.{u2} R _inst_2))))))) f))
+but is expected to have type
+  forall {α : Type.{u2}} {R : Type.{u1}} [_inst_1 : Monoid.{u2} α] [_inst_2 : Ring.{u1} R] (f : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) f) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => R) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) f) α R (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α _inst_1)) (MulOneClass.toMul.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) f) α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) (MonoidHom.monoidHomClass.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))))) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (fun (_x : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) => MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))))) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MonoidHom.{u2, u1} α R (Monoid.toMulOneClass.{u2} α _inst_1) (MulZeroOneClass.toMulOneClass.{u1} R (NonAssocSemiring.toMulZeroOneClass.{u1} R (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))))) (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (FreeAbelianGroup.liftMonoid.{u2, u1} α R _inst_1 _inst_2)) f)) (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (α -> R)) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (fun (_x : AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) => α -> R) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (α -> R)) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> R) (AddMonoidHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.addCommGroup.{u2} α))))) (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (Ring.toAddCommGroup.{u1} R _inst_2)))))) (FreeAbelianGroup.lift.{u2, u1} α R (Ring.toAddCommGroup.{u1} R _inst_2))) (AddMonoidHomClass.toAddMonoidHom.{u2, u1, max u2 u1} (FreeAbelianGroup.{u2} α) R (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} α) (AddMonoidWithOne.toAddMonoid.{u2} (FreeAbelianGroup.{u2} α) (AddGroupWithOne.toAddMonoidWithOne.{u2} (FreeAbelianGroup.{u2} α) (Ring.toAddGroupWithOne.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))))) (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_2)))) (RingHomClass.toAddMonoidHomClass.{max u2 u1, u2, u1} (RingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2))) (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)) (RingHom.instRingHomClassRingHom.{u2, u1} (FreeAbelianGroup.{u2} α) R (NonAssocRing.toNonAssocSemiring.{u2} (FreeAbelianGroup.{u2} α) (Ring.toNonAssocRing.{u2} (FreeAbelianGroup.{u2} α) (FreeAbelianGroup.ring.{u2} α _inst_1))) (NonAssocRing.toNonAssocSemiring.{u1} R (Ring.toNonAssocRing.{u1} R _inst_2)))) f))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.lift_monoid_symm_coe FreeAbelianGroup.liftMonoid_symm_coeₓ'. -/
 @[simp]
 theorem liftMonoid_symm_coe (f : FreeAbelianGroup α →+* R) : ⇑(liftMonoid.symm f) = lift.symm ↑f :=
   rfl
 #align free_abelian_group.lift_monoid_symm_coe FreeAbelianGroup.liftMonoid_symm_coe
 
+/- warning: free_abelian_group.one_def -> FreeAbelianGroup.one_def is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (FreeAbelianGroup.{u1} α) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 1 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 1 (One.one.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.hasOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (FreeAbelianGroup.of.{u1} α (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (FreeAbelianGroup.{u1} α) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 1 (One.toOfNat1.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.one.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (FreeAbelianGroup.of.{u1} α (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1))))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.one_def FreeAbelianGroup.one_defₓ'. -/
 theorem one_def : (1 : FreeAbelianGroup α) = of 1 :=
   rfl
 #align free_abelian_group.one_def FreeAbelianGroup.one_def
 
+/- warning: free_abelian_group.of_one -> FreeAbelianGroup.of_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.of.{u1} α (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 1 (OfNat.mk.{u1} (FreeAbelianGroup.{u1} α) 1 (One.one.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.hasOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.of.{u1} α (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (FreeAbelianGroup.{u1} α) 1 (One.toOfNat1.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.one.{u1} α (Monoid.toOne.{u1} α _inst_1))))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.of_one FreeAbelianGroup.of_oneₓ'. -/
 theorem of_one : (of 1 : FreeAbelianGroup α) = 1 :=
   rfl
 #align free_abelian_group.of_one FreeAbelianGroup.of_one
@@ -589,6 +857,7 @@ instance [CommMonoid α] : CommRing (FreeAbelianGroup α) :=
       · intro x1 x2 ih1 ih2
         rw [add_mul, mul_add, ih1, ih2] }
 
+#print FreeAbelianGroup.pemptyUnique /-
 instance pemptyUnique : Unique (FreeAbelianGroup PEmpty)
     where
   default := 0
@@ -598,7 +867,14 @@ instance pemptyUnique : Unique (FreeAbelianGroup PEmpty)
         rintro - - rfl rfl
         simp)
 #align free_abelian_group.pempty_unique FreeAbelianGroup.pemptyUnique
+-/
 
+/- warning: free_abelian_group.punit_equiv -> FreeAbelianGroup.punitEquiv is a dubious translation:
+lean 3 declaration is
+  forall (T : Type.{u1}) [_inst_1 : Unique.{succ u1} T], AddEquiv.{u1, 0} (FreeAbelianGroup.{u1} T) Int (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} T) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} T) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} T) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} T) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} T) (FreeAbelianGroup.addCommGroup.{u1} T)))))) Int.hasAdd
+but is expected to have type
+  forall (T : Type.{u1}) [_inst_1 : Unique.{succ u1} T], AddEquiv.{u1, 0} (FreeAbelianGroup.{u1} T) Int (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} T) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} T) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} T) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} T) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} T) (FreeAbelianGroup.addCommGroup.{u1} T)))))) Int.instAddInt
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.punit_equiv FreeAbelianGroup.punitEquivₓ'. -/
 /-- The free abelian group on a type with one term is isomorphic to `ℤ`. -/
 def punitEquiv (T : Type _) [Unique T] : FreeAbelianGroup T ≃+ ℤ
     where
@@ -616,6 +892,12 @@ def punitEquiv (T : Type _) [Unique T] : FreeAbelianGroup T ≃+ ℤ
   map_add' := AddMonoidHom.map_add _
 #align free_abelian_group.punit_equiv FreeAbelianGroup.punitEquiv
 
+/- warning: free_abelian_group.equiv_of_equiv -> FreeAbelianGroup.equivOfEquiv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}}, (Equiv.{succ u1, succ u2} α β) -> (AddEquiv.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddZeroClass.toHasAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toHasAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}}, (Equiv.{succ u1, succ u2} α β) -> (AddEquiv.{u1, u2} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.{u2} β) (AddZeroClass.toAdd.{u1} (FreeAbelianGroup.{u1} α) (AddMonoid.toAddZeroClass.{u1} (FreeAbelianGroup.{u1} α) (SubNegMonoid.toAddMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddGroup.toSubNegMonoid.{u1} (FreeAbelianGroup.{u1} α) (AddCommGroup.toAddGroup.{u1} (FreeAbelianGroup.{u1} α) (FreeAbelianGroup.addCommGroup.{u1} α)))))) (AddZeroClass.toAdd.{u2} (FreeAbelianGroup.{u2} β) (AddMonoid.toAddZeroClass.{u2} (FreeAbelianGroup.{u2} β) (SubNegMonoid.toAddMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddGroup.toSubNegMonoid.{u2} (FreeAbelianGroup.{u2} β) (AddCommGroup.toAddGroup.{u2} (FreeAbelianGroup.{u2} β) (FreeAbelianGroup.addCommGroup.{u2} β)))))))
+Case conversion may be inaccurate. Consider using '#align free_abelian_group.equiv_of_equiv FreeAbelianGroup.equivOfEquivₓ'. -/
 /-- Isomorphic types have isomorphic free abelian groups. -/
 def equivOfEquiv {α β : Type _} (f : α ≃ β) : FreeAbelianGroup α ≃+ FreeAbelianGroup β
     where

70fd9563

bump to nightly-2023-03-11-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

cd44fb92

Diff

@@ -522,8 +522,12 @@ def liftMonoid : (α →* R) ≃ (FreeAbelianGroup α →+* R)
       map_one' := (lift.of f _).trans f.map_one
       map_mul' := fun x y =>
         by
-        refine' FreeAbelianGroup.induction_on y (mul_zero _).symm (fun L2 => _) (fun L2 ih => _) _
-        · refine' FreeAbelianGroup.induction_on x (zero_mul _).symm (fun L1 => _) (fun L1 ih => _) _
+        refine'
+          FreeAbelianGroup.induction_on y (MulZeroClass.mul_zero _).symm (fun L2 => _)
+            (fun L2 ih => _) _
+        · refine'
+            FreeAbelianGroup.induction_on x (MulZeroClass.zero_mul _).symm (fun L1 => _)
+              (fun L1 ih => _) _
           · simp_rw [of_mul_of, lift.of]
             exact f.map_mul _ _
           · simp_rw [neg_mul, map_neg, neg_mul]
@@ -568,9 +572,9 @@ instance [CommMonoid α] : CommRing (FreeAbelianGroup α) :=
   { FreeAbelianGroup.ring α with
     mul_comm := fun x y =>
       by
-      refine' FreeAbelianGroup.induction_on x (zero_mul y) _ _ _
+      refine' FreeAbelianGroup.induction_on x (MulZeroClass.zero_mul y) _ _ _
       · intro s
-        refine' FreeAbelianGroup.induction_on y (zero_mul _).symm _ _ _
+        refine' FreeAbelianGroup.induction_on y (MulZeroClass.zero_mul _).symm _ _ _
         · intro t
           unfold Mul.mul Semigroup.mul Ring.mul
           iterate 4 rw [lift.of]

70fd9563

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

dc6c365e

chore: split Algebra.Module.Basic (#12501)

Similar to #12486, which did this for Algebra.Algebra.Basic.

Splits Algebra.Module.Defs off Algebra.Module.Basic. Most imports only need the Defs file, which has significantly smaller imports. The remaining Algebra.Module.Basic is now a grab-bag of unrelated results, and should probably be split further or rehomed.

This is mostly motivated by the wasted effort during minimization upon encountering Algebra.Module.Basic.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com>

7d5102df

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
 -/
 import Mathlib.Algebra.Group.Pi.Lemmas
-import Mathlib.Algebra.Module.Basic
+import Mathlib.Algebra.Module.Defs
 import Mathlib.GroupTheory.Abelianization
 import Mathlib.GroupTheory.FreeGroup.Basic

dc6c365e

chore: scope open Classical (#11199)

We remove all but one open Classicals, instead preferring to use open scoped Classical. The only real side-effect this led to is moving a couple declarations to use Exists.choose instead of Classical.choose.

The first few commits are explicitly labelled regex replaces for ease of review.

c747be0a

Diff

@@ -139,7 +139,7 @@ end lift
 
 section
 
-open Classical
+open scoped Classical
 
 theorem of_injective : Function.Injective (of : α → FreeAbelianGroup α) :=
   fun x y hoxy ↦ Classical.by_contradiction fun hxy : x ≠ y ↦

dc6c365e

chore: classify dsimp cannot prove this porting notes (#10676)

Classifies by adding issue number (#10675) to porting notes claiming dsimp cannot prove this.

90d86d7c

Diff

@@ -202,7 +202,7 @@ protected theorem induction_on' {C : FreeAbelianGroup α → Prop} (z : FreeAbel
   FreeAbelianGroup.induction_on z C0 C1 Cn Cp
 #align free_abelian_group.induction_on' FreeAbelianGroup.induction_on'
 
-@[simp, nolint simpNF] -- Porting note: dsimp can not prove this
+@[simp, nolint simpNF] -- Porting note (#10675): dsimp can not prove this
 theorem map_pure (f : α → β) (x : α) : f <$> (pure x : FreeAbelianGroup α) = pure (f x) :=
   rfl
 #align free_abelian_group.map_pure FreeAbelianGroup.map_pure

dc6c365e

chore: classify simp can do this porting notes (#10619)

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to simp can prove this or simp can simplify this.

de765f60

Diff

@@ -234,7 +234,7 @@ theorem map_of (f : α → β) (y : α) : f <$> of y = of (f y) :=
   rfl
 #align free_abelian_group.map_of FreeAbelianGroup.map_of
 
--- @[simp] -- Porting note: simp can prove this
+-- @[simp] -- Porting note (#10618): simp can prove this
 theorem pure_bind (f : α → FreeAbelianGroup β) (x) : pure x >>= f = f x :=
   lift.of _ _
 #align free_abelian_group.pure_bind FreeAbelianGroup.pure_bind

dc6c365e

move: Algebraic pi instances (#10693)

Rename

Data.Pi.Algebra to Algebra.Group.Pi.Basic
Algebra.Group.Pi to Algebra.Group.Pi.Lemmas

Move a few instances from the latter to the former, the goal being that Algebra.Group.Pi.Basic is about all the pi instances of the classes defined in Algebra.Group.Defs. Algebra.Group.Pi.Lemmas will need further rearranging.

c76aa9d6

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2018 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
 -/
-import Mathlib.Algebra.Group.Pi
-import Mathlib.GroupTheory.FreeGroup.Basic
-import Mathlib.GroupTheory.Abelianization
+import Mathlib.Algebra.Group.Pi.Lemmas
 import Mathlib.Algebra.Module.Basic
+import Mathlib.GroupTheory.Abelianization
+import Mathlib.GroupTheory.FreeGroup.Basic
 
 #align_import group_theory.free_abelian_group from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"

dc6c365e

chore(*): rename FunLike to DFunLike (#9785)

This prepares for the introduction of a non-dependent synonym of FunLike, which helps a lot with keeping #8386 readable.

This is entirely search-and-replace in 680197f combined with manual fixes in 4145626, e900597 and b8428f8. The commands that generated this change:

sed -i 's/\bFunLike\b/DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoFunLike\b/toDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/import Mathlib.Data.DFunLike/import Mathlib.Data.FunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bHom_FunLike\b/Hom_DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean     
sed -i 's/\binstFunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bfunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoo many metavariables to apply `fun_like.has_coe_to_fun`/too many metavariables to apply `DFunLike.hasCoeToFun`/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean

Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

82656743

Diff

@@ -117,7 +117,7 @@ protected theorem of (x : α) : lift f (of x) = f x := by
 
 protected theorem unique (g : FreeAbelianGroup α →+ β) (hg : ∀ x, g (of x) = f x) {x} :
     g x = lift f x :=
-  FunLike.congr_fun (lift.symm_apply_eq.mp (funext hg : g ∘ of = f)) _
+  DFunLike.congr_fun (lift.symm_apply_eq.mp (funext hg : g ∘ of = f)) _
 #align free_abelian_group.lift.unique FreeAbelianGroup.lift.unique
 
 /-- See note [partially-applied ext lemmas]. -/

dc6c365e

chore: Replace (· op ·) a by (a op ·) (#8843)

I used the regex $\(· (.) ·$ (.)\), replacing with ($2 $1 ·).

d14658b4

Diff

@@ -291,7 +291,7 @@ theorem sub_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
 /-- If `f : FreeAbelianGroup (α → β)`, then `f <*>` is an additive morphism
 `FreeAbelianGroup α →+ FreeAbelianGroup β`. -/
 def seqAddGroupHom (f : FreeAbelianGroup (α → β)) : FreeAbelianGroup α →+ FreeAbelianGroup β :=
-  AddMonoidHom.mk' ((· <*> ·) f) fun x y ↦
+  AddMonoidHom.mk' (f <*> ·) fun x y ↦
     show lift (· <$> (x + y)) _ = _ by
       simp only [FreeAbelianGroup.map_add]
       exact lift.add' f _ _

dc6c365e

chore: add some Unique instances (#8500)

The aim is to remove some extraneous Nonempty assumptions in Algebra/DirectLimit.

Co-authored-by: Junyan Xu <junyanxu.math@gmail.com> Co-authored-by: Jujian Zhang <jujian.zhang1998@outlook.com>

9a4ae4a9

Diff

@@ -84,6 +84,8 @@ instance FreeAbelianGroup.addCommGroup : AddCommGroup (FreeAbelianGroup α) :=
 instance : Inhabited (FreeAbelianGroup α) :=
   ⟨0⟩
 
+instance [IsEmpty α] : Unique (FreeAbelianGroup α) := by unfold FreeAbelianGroup; infer_instance
+
 variable {α}
 
 namespace FreeAbelianGroup

dc6c365e

refactor: Create FreeGroup folder in GroupTheory (#7334)

7916792c

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
 -/
 import Mathlib.Algebra.Group.Pi
-import Mathlib.GroupTheory.FreeGroup
+import Mathlib.GroupTheory.FreeGroup.Basic
 import Mathlib.GroupTheory.Abelianization
 import Mathlib.Algebra.Module.Basic

dc6c365e

perf: remove overspecified fields (#6965)

This removes redundant field values of the form add := add for smaller terms and less unfolding during unification.

A list of all files containing a structure instance of the form { a1, ... with x1 := val, ... } where some xi is a field of some aj was generated by modifying the structure instance elaboration algorithm to print such overlaps to stdout in a custom toolchain.

Using that toolchain, I went through each file on the list and attempted to remove algebraic fields that overlapped and were redundant, eg add := add and not toFun (though some other ones did creep in). If things broke (which was the case in a couple of cases), I did not push further and reverted.

It is possible that pushing harder and trying to remove all redundant overlaps will yield further improvements.

12150475

Diff

@@ -439,7 +439,6 @@ instance one [One α] : One (FreeAbelianGroup α) :=
 
 instance nonUnitalRing [Semigroup α] : NonUnitalRing (FreeAbelianGroup α) :=
   { FreeAbelianGroup.nonUnitalNonAssocRing with
-    mul := (· * ·)
     mul_assoc := fun x y z ↦ by
       refine' FreeAbelianGroup.induction_on z (by simp only [mul_zero])
           (fun L3 ↦ _) (fun L3 ih ↦ _) fun z₁ z₂ ih₁ ih₂ ↦ _
@@ -462,7 +461,6 @@ variable {R : Type*} [Monoid α] [Ring R]
 instance ring : Ring (FreeAbelianGroup α) :=
   { FreeAbelianGroup.nonUnitalRing _,
     FreeAbelianGroup.one _ with
-    mul := (· * ·)
     mul_one := fun x ↦ by
       dsimp only [(· * ·), Mul.mul, OfNat.ofNat, One.one]
       rw [lift.of]

dc6c365e

chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

32de3f67

Diff

@@ -27,7 +27,7 @@ file, but the category-theoretic adjunction statement is in
 
 ## Main definitions
 
-Here we use the following variables: `(α β : Type _) (A : Type _) [AddCommGroup A]`
+Here we use the following variables: `(α β : Type*) (A : Type*) [AddCommGroup A]`
 
 * `FreeAbelianGroup α` : the free abelian group on a type `α`. As an abelian
 group it is `α →₀ ℤ`, the functions from `α` to `ℤ` such that all but finitely
@@ -457,7 +457,7 @@ instance nonUnitalRing [Semigroup α] : NonUnitalRing (FreeAbelianGroup α) :=
 
 section Monoid
 
-variable {R : Type _} [Monoid α] [Ring R]
+variable {R : Type*} [Monoid α] [Ring R]
 
 instance ring : Ring (FreeAbelianGroup α) :=
   { FreeAbelianGroup.nonUnitalRing _,
@@ -583,7 +583,7 @@ instance pemptyUnique : Unique (FreeAbelianGroup PEmpty) where
 #align free_abelian_group.pempty_unique FreeAbelianGroup.pemptyUnique
 
 /-- The free abelian group on a type with one term is isomorphic to `ℤ`. -/
-def punitEquiv (T : Type _) [Unique T] : FreeAbelianGroup T ≃+ ℤ where
+def punitEquiv (T : Type*) [Unique T] : FreeAbelianGroup T ≃+ ℤ where
   toFun := FreeAbelianGroup.lift fun _ ↦ (1 : ℤ)
   invFun n := n • of Inhabited.default
   left_inv z := FreeAbelianGroup.induction_on z
@@ -599,7 +599,7 @@ def punitEquiv (T : Type _) [Unique T] : FreeAbelianGroup T ≃+ ℤ where
 #align free_abelian_group.punit_equiv FreeAbelianGroup.punitEquiv
 
 /-- Isomorphic types have isomorphic free abelian groups. -/
-def equivOfEquiv {α β : Type _} (f : α ≃ β) : FreeAbelianGroup α ≃+ FreeAbelianGroup β where
+def equivOfEquiv {α β : Type*} (f : α ≃ β) : FreeAbelianGroup α ≃+ FreeAbelianGroup β where
   toFun := map f
   invFun := map f.symm
   left_inv := by

dc6c365e

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2018 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
-
-! This file was ported from Lean 3 source module group_theory.free_abelian_group
-! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Group.Pi
 import Mathlib.GroupTheory.FreeGroup
 import Mathlib.GroupTheory.Abelianization
 import Mathlib.Algebra.Module.Basic
 
+#align_import group_theory.free_abelian_group from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
+
 /-!
 # Free abelian groups

dc6c365e

chore: reenable eta, bump to nightly 2023-05-16 (#3414)

Now that leanprover/lean4#2210 has been merged, this PR:

removes all the set_option synthInstance.etaExperiment true commands (and some etaExperiment% term elaborators)
removes many but not quite all set_option maxHeartbeats commands
makes various other changes required to cope with leanprover/lean4#2210.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Matthew Ballard <matt@mrb.email>

a6e1045f

Diff

@@ -79,6 +79,8 @@ def FreeAbelianGroup : Type u :=
   Additive <| Abelianization <| FreeGroup α
 #align free_abelian_group FreeAbelianGroup
 
+-- FIXME: this is super broken, because the functions have type `Additive .. → ..`
+-- instead of `FreeAbelianGroup α → ..` and those are not defeq!
 instance FreeAbelianGroup.addCommGroup : AddCommGroup (FreeAbelianGroup α) :=
   @Additive.addCommGroup _ <| Abelianization.commGroup _
 
@@ -421,8 +423,7 @@ theorem of_mul (x y : α) : of (x * y) = of x * of y :=
 #align free_abelian_group.of_mul FreeAbelianGroup.of_mul
 
 instance distrib : Distrib (FreeAbelianGroup α) :=
-  { FreeAbelianGroup.mul _ with
-    add := (· + ·)
+  { FreeAbelianGroup.mul α, FreeAbelianGroup.addCommGroup α with
     left_distrib := fun x y z ↦ (lift _).map_add _ _
     right_distrib := fun x y z ↦ by simp only [(· * ·), Mul.mul, map_add, ← Pi.add_def, lift.add'] }

dc6c365e

feat: port GroupTheory.FreeAbelianGroupFinsupp (#3441)

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

0a4bbecc

Diff

@@ -120,7 +120,7 @@ protected theorem unique (g : FreeAbelianGroup α →+ β) (hg : ∀ x, g (of x)
 #align free_abelian_group.lift.unique FreeAbelianGroup.lift.unique
 
 /-- See note [partially-applied ext lemmas]. -/
-@[ext]
+@[ext high]
 protected theorem ext (g h : FreeAbelianGroup α →+ β) (H : ∀ x, g (of x) = h (of x)) : g = h :=
   lift.symm.injective <| funext H
 #align free_abelian_group.lift.ext FreeAbelianGroup.lift.ext

dc6c365e

feat: port GroupTheory.FreeAbelianGroup (#2247)

Co-authored-by: David Renshaw <dwrenshaw@gmail.com>

0eb23819

`group_theory.free_abelian_group` ⟷ `Mathlib.GroupTheory.FreeAbelianGroup`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 348

group_theory.free_abelian_group ⟷ Mathlib.GroupTheory.FreeAbelianGroup

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 348

`group_theory.free_abelian_group` ⟷ `Mathlib.GroupTheory.FreeAbelianGroup`