group_theory.free_group ⟷ Mathlib.GroupTheory.FreeGroup.Basic

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

@@ -401,7 +401,7 @@ theorem red_iff_irreducible {x1 b1 x2 b2} (h : (x1, b1) ≠ (x2, b2)) :
   generalize eq : [(x1, not b1), (x2, b2)] = L'
   intro L h'
   cases h'
-  simp [List.cons_eq_append_iff, List.nil_eq_append] at eq
+  simp [List.cons_eq_append, List.nil_eq_append] at eq
   rcases Eq with ⟨rfl, ⟨rfl, rfl⟩, ⟨rfl, rfl⟩, rfl⟩; subst_vars
   simp at h
   contradiction

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

@@ -180,7 +180,7 @@ theorem not_step_nil : ¬Step [] L := by
   generalize h' : [] = L'
   intro h
   cases' h with L₁ L₂
-  simp [List.nil_eq_append] at h' 
+  simp [List.nil_eq_append] at h'
   contradiction
 #align free_group.red.not_step_nil FreeGroup.Red.not_step_nil
 #align free_add_group.red.not_step_nil FreeAddGroup.Red.not_step_nil
@@ -194,8 +194,8 @@ theorem Step.cons_left_iff {a : α} {b : Bool} :
   constructor
   · generalize hL : ((a, b) :: L₁ : List _) = L
     rintro @⟨_ | ⟨p, s'⟩, e, a', b'⟩
-    · simp at hL ; simp [*]
-    · simp at hL 
+    · simp at hL; simp [*]
+    · simp at hL
       rcases hL with ⟨rfl, rfl⟩
       refine' Or.inl ⟨s' ++ e, step.bnot, _⟩
       simp
@@ -307,7 +307,7 @@ theorem cons_cons_iff (p) : Red (p :: L₁) (p :: L₂) ↔ Red L₁ L₂ :=
       · subst_vars; cases eq₂; constructor
       · subst_vars
         cases' p with a b
-        rw [step.cons_left_iff] at h₁₂ 
+        rw [step.cons_left_iff] at h₁₂
         rcases h₁₂ with (⟨L, h₁₂, rfl⟩ | rfl)
         · exact (ih rfl rfl).headI h₁₂
         · exact (cons_cons h).tail step.cons_bnot_rev)
@@ -386,7 +386,7 @@ theorem cons_nil_iff_singleton {x b} : Red ((x, b) :: L) [] ↔ Red L [(x, not b
       have h₁ : Red ((x, not b) :: (x, b) :: L) [(x, not b)] := cons_cons h
       have h₂ : Red ((x, not b) :: (x, b) :: L) L := ReflTransGen.single Step.cons_not_rev
       let ⟨L', h₁, h₂⟩ := church_rosser h₁ h₂
-      rw [singleton_iff] at h₁  <;> subst L' <;> assumption)
+      rw [singleton_iff] at h₁ <;> subst L' <;> assumption)
     fun h => (cons_cons h).tail Step.cons_not
 #align free_group.red.cons_nil_iff_singleton FreeGroup.Red.cons_nil_iff_singleton
 #align free_add_group.red.cons_nil_iff_singleton FreeAddGroup.Red.cons_nil_iff_singleton
@@ -401,9 +401,9 @@ theorem red_iff_irreducible {x1 b1 x2 b2} (h : (x1, b1) ≠ (x2, b2)) :
   generalize eq : [(x1, not b1), (x2, b2)] = L'
   intro L h'
   cases h'
-  simp [List.cons_eq_append_iff, List.nil_eq_append] at eq 
+  simp [List.cons_eq_append_iff, List.nil_eq_append] at eq
   rcases Eq with ⟨rfl, ⟨rfl, rfl⟩, ⟨rfl, rfl⟩, rfl⟩; subst_vars
-  simp at h 
+  simp at h
   contradiction
 #align free_group.red.red_iff_irreducible FreeGroup.Red.red_iff_irreducible
 #align free_add_group.red.red_iff_irreducible FreeAddGroup.Red.red_iff_irreducible
@@ -419,15 +419,15 @@ theorem inv_of_red_of_ne {x1 b1 x2 b2} (H1 : (x1, b1) ≠ (x2, b2))
   by
   have : red ((x1, b1) :: L₁) ([(x2, b2)] ++ L₂) := H2
   rcases to_append_iff.1 this with ⟨_ | ⟨p, L₃⟩, L₄, eq, h₁, h₂⟩
-  · simp [nil_iff] at h₁ ; contradiction
+  · simp [nil_iff] at h₁; contradiction
   · cases Eq
     show red (L₃ ++ L₄) ([(x1, not b1), (x2, b2)] ++ L₂)
     apply append_append _ h₂
     have h₁ : red ((x1, not b1) :: (x1, b1) :: L₃) [(x1, not b1), (x2, b2)] := cons_cons h₁
     have h₂ : red ((x1, not b1) :: (x1, b1) :: L₃) L₃ := step.cons_bnot_rev.to_red
     rcases church_rosser h₁ h₂ with ⟨L', h₁, h₂⟩
-    rw [red_iff_irreducible H1] at h₁ 
-    rwa [h₁] at h₂ 
+    rw [red_iff_irreducible H1] at h₁
+    rwa [h₁] at h₂
 #align free_group.red.inv_of_red_of_ne FreeGroup.Red.inv_of_red_of_ne
 #align free_add_group.red.neg_of_red_of_ne FreeAddGroup.Red.neg_of_red_of_ne
 -/
@@ -779,7 +779,7 @@ theorem Red.exact : mk L₁ = mk L₂ ↔ Join Red L₁ L₂ :=
 theorem of_injective : Function.Injective (@of α) := fun _ _ H =>
   by
   let ⟨L₁, hx, hy⟩ := Red.exact.1 H
-  simp [red.singleton_iff] at hx hy  <;> cc
+  simp [red.singleton_iff] at hx hy <;> cc
 #align free_group.of_injective FreeGroup.of_injective
 #align free_add_group.of_injective FreeAddGroup.of_injective
 -/
@@ -1175,8 +1175,8 @@ def freeGroupUnitEquivInt : FreeGroup Unit ≃ ℤ
     refine' List.recOn L rfl _
     exact fun ⟨⟨⟩, b⟩ tl ih => by cases b <;> simp [zpow_add] at ih ⊢ <;> rw [ih] <;> rfl
   right_inv x :=
-    Int.induction_on x (by simp) (fun i ih => by simp at ih  <;> simp [zpow_add, ih]) fun i ih => by
-      simp at ih  <;> simp [zpow_add, ih, sub_eq_add_neg, -Int.add_neg_one]
+    Int.induction_on x (by simp) (fun i ih => by simp at ih <;> simp [zpow_add, ih]) fun i ih => by
+      simp at ih <;> simp [zpow_add, ih, sub_eq_add_neg, -Int.add_neg_one]
 #align free_group.free_group_unit_equiv_int FreeGroup.freeGroupUnitEquivInt
 -/
 
@@ -1349,16 +1349,16 @@ theorem reduce.not {p : Prop} :
     cases r : reduce L1
     · dsimp; intro h
       have := congr_arg List.length h
-      simp [-add_comm] at this 
+      simp [-add_comm] at this
       exact absurd this (by decide)
     cases' hd with y c
     dsimp only
     split_ifs with h <;> intro H
-    · rw [H] at r 
+    · rw [H] at r
       exact @reduce.not L1 ((y, c) :: L2) L3 x' b' r
     rcases L2 with (_ | ⟨a, L2⟩)
     · injections; subst_vars
-      simp at h ; cc
+      simp at h; cc
     · refine' @reduce.not L1 L2 L3 x' b' _
       injection H with _ H
       rw [r, H]; rfl
@@ -1559,7 +1559,7 @@ theorem reduce_invRev {w : List (α × Bool)} : reduce (invRev w) = invRev (redu
   rw [← red_inv_rev_iff, inv_rev_inv_rev]
   apply red.reduce_left
   have : red (inv_rev (inv_rev w)) (inv_rev (reduce (inv_rev w))) := reduce.red.inv_rev
-  rwa [inv_rev_inv_rev] at this 
+  rwa [inv_rev_inv_rev] at this
 #align free_group.reduce_inv_rev FreeGroup.reduce_invRev
 #align free_add_group.reduce_neg_rev FreeAddGroup.reduce_negRev
 -/

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

@@ -937,7 +937,7 @@ theorem map.mk : map f (mk L) = mk (L.map fun x => (f x.1, x.2)) :=
 
 #print FreeGroup.map.id /-
 @[simp, to_additive]
-theorem map.id (x : FreeGroup α) : map id x = x := by rcases x with ⟨L⟩ <;> simp [List.map_id']
+theorem map.id (x : FreeGroup α) : map id x = x := by rcases x with ⟨L⟩ <;> simp [List.map_id'']
 #align free_group.map.id FreeGroup.map.id
 #align free_add_group.map.id FreeAddGroup.map.id
 -/

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

@@ -3,9 +3,9 @@ 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.Data.Fintype.Basic
-import Mathbin.Data.List.Sublists
-import Mathbin.GroupTheory.Subgroup.Basic
+import Data.Fintype.Basic
+import Data.List.Sublists
+import GroupTheory.Subgroup.Basic
 
 #align_import group_theory.free_group from "leanprover-community/mathlib"@"fac369018417f980cec5fcdafc766a69f88d8cfe"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

@@ -1415,10 +1415,10 @@ theorem reduce.eq_of_red (H : Red L₁ L₂) : reduce L₁ = reduce L₂ :=
 #align free_add_group.reduce.eq_of_red FreeAddGroup.reduce.eq_of_red
 -/
 
-alias reduce.eq_of_red ← red.reduce_eq
+alias red.reduce_eq := reduce.eq_of_red
 #align free_group.red.reduce_eq FreeGroup.red.reduce_eq
 
-alias FreeAddGroup.reduce.eq_of_red ← free_add_group.red.reduce_eq
+alias free_add_group.red.reduce_eq := FreeAddGroup.reduce.eq_of_red
 #align free_group.free_add_group.red.reduce_eq FreeGroup.freeAddGroup.red.reduce_eq
 
 #print FreeGroup.Red.reduce_right /-

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

@@ -746,7 +746,7 @@ instance : Group (FreeGroup α) where
   mul_assoc := by rintro ⟨L₁⟩ ⟨L₂⟩ ⟨L₃⟩ <;> simp
   one_mul := by rintro ⟨L⟩ <;> rfl
   mul_one := by rintro ⟨L⟩ <;> simp [one_eq_mk]
-  mul_left_inv := by
+  hMul_left_inv := by
     rintro ⟨L⟩ <;>
       exact
         List.recOn L rfl fun ⟨x, b⟩ tl ih =>
@@ -1126,7 +1126,7 @@ theorem sum.of {x : α} : sum (of x) = x :=
 -- these manually
 @[simp]
 theorem sum.map_mul : sum (x * y) = sum x + sum y :=
-  (@prod (Multiplicative _) _).map_mul _ _
+  (@prod (Multiplicative _) _).map_hMul _ _
 #align free_group.sum.map_mul FreeGroup.sum.map_mul
 -/
 
@@ -1220,7 +1220,7 @@ theorem map_one (f : α → β) : f <$> (1 : FreeGroup α) = 1 :=
 #print FreeGroup.map_mul /-
 @[simp, to_additive]
 theorem map_mul (f : α → β) (x y : FreeGroup α) : f <$> (x * y) = f <$> x * f <$> y :=
-  (map f).map_mul x y
+  (map f).map_hMul x y
 #align free_group.map_mul FreeGroup.map_mul
 #align free_add_group.map_add FreeAddGroup.map_add
 -/
@@ -1252,7 +1252,7 @@ theorem one_bind (f : α → FreeGroup β) : 1 >>= f = 1 :=
 #print FreeGroup.mul_bind /-
 @[simp, to_additive]
 theorem mul_bind (f : α → FreeGroup β) (x y : FreeGroup α) : x * y >>= f = (x >>= f) * (y >>= f) :=
-  (lift f).map_mul _ _
+  (lift f).map_hMul _ _
 #align free_group.mul_bind FreeGroup.mul_bind
 #align free_add_group.add_bind FreeAddGroup.add_bind
 -/

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

@@ -2,16 +2,13 @@
 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_group
-! leanprover-community/mathlib commit fac369018417f980cec5fcdafc766a69f88d8cfe
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Fintype.Basic
 import Mathbin.Data.List.Sublists
 import Mathbin.GroupTheory.Subgroup.Basic
 
+#align_import group_theory.free_group from "leanprover-community/mathlib"@"fac369018417f980cec5fcdafc766a69f88d8cfe"
+
 /-!
 # Free groups
 

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

@@ -1279,7 +1279,7 @@ instance : LawfulMonad FreeGroup.{u}
     FreeGroup.induction_on x (by iterate 3 rw [one_bind]) (fun x => by iterate 2 rw [pure_bind])
       (fun x ih => by iterate 3 rw [inv_bind] <;> rw [ih]) fun x y ihx ihy => by
       iterate 3 rw [mul_bind] <;> rw [ihx, ihy]
-  bind_pure_comp_eq_map α β f x :=
+  bind_pure_comp α β f x :=
     FreeGroup.induction_on x (by rw [one_bind, map_one]) (fun x => by rw [pure_bind, map_pure])
       (fun x ih => by rw [inv_bind, map_inv, ih]) fun x y ihx ihy => by
       rw [mul_bind, map_mul, ihx, ihy]

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

@@ -462,6 +462,7 @@ theorem length_le (h : Red L₁ L₂) : L₂.length ≤ L₁.length :=
 #align free_add_group.red.length_le FreeAddGroup.Red.length_le
 -/
 
+#print FreeGroup.Red.sizeof_of_step /-
 @[to_additive]
 theorem sizeof_of_step : ∀ {L₁ L₂ : List (α × Bool)}, Step L₁ L₂ → L₂.sizeOf < L₁.sizeOf
   | _, _, @step.bnot _ L1 L2 x b => by
@@ -479,6 +480,7 @@ theorem sizeof_of_step : ∀ {L₁ L₂ : List (α × Bool)}, Step L₁ L₂ →
       exact Nat.add_lt_add_left ih _
 #align free_group.red.sizeof_of_step FreeGroup.Red.sizeof_of_step
 #align free_add_group.red.sizeof_of_step FreeAddGroup.Red.sizeof_of_step
+-/
 
 #print FreeGroup.Red.length /-
 @[to_additive]
@@ -807,6 +809,7 @@ theorem Red.Step.lift {f : α → β} (H : Red.Step L₁ L₂) : Lift.aux f L₁
 #align free_add_group.red.step.lift FreeAddGroup.Red.Step.lift
 -/
 
+#print FreeGroup.lift /-
 /-- If `β` is a group, then any function from `α` to `β`
 extends uniquely to a group homomorphism from
 the free group over `α` to `β` -/
@@ -832,27 +835,35 @@ def lift : (α → β) ≃ (FreeGroup α →* β)
           simpa [lift.aux] using ih
 #align free_group.lift FreeGroup.lift
 #align free_add_group.lift FreeAddGroup.lift
+-/
 
 variable {f}
 
+#print FreeGroup.lift.mk /-
 @[simp, to_additive]
 theorem lift.mk : lift f (mk L) = List.prod (L.map fun x => cond x.2 (f x.1) (f x.1)⁻¹) :=
   rfl
 #align free_group.lift.mk FreeGroup.lift.mk
 #align free_add_group.lift.mk FreeAddGroup.lift.mk
+-/
 
+#print FreeGroup.lift.of /-
 @[simp, to_additive]
 theorem lift.of {x} : lift f (of x) = f x :=
   one_mul _
 #align free_group.lift.of FreeGroup.lift.of
 #align free_add_group.lift.of FreeAddGroup.lift.of
+-/
 
+#print FreeGroup.lift.unique /-
 @[to_additive]
 theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (of x) = f x) : ∀ {x}, g x = lift f x :=
   MonoidHom.congr_fun <| lift.symm_apply_eq.mp (funext hg : g ∘ of = f)
 #align free_group.lift.unique FreeGroup.lift.unique
 #align free_add_group.lift.unique FreeAddGroup.lift.unique
+-/
 
+#print FreeGroup.ext_hom /-
 /-- Two homomorphisms out of a free group are equal if they are equal on generators.
 
 See note [partially-applied ext lemmas]. -/
@@ -864,13 +875,17 @@ theorem ext_hom {G : Type _} [Group G] (f g : FreeGroup α →* G) (h : ∀ a, f
   lift.symm.Injective <| funext h
 #align free_group.ext_hom FreeGroup.ext_hom
 #align free_add_group.ext_hom FreeAddGroup.ext_hom
+-/
 
+#print FreeGroup.lift.of_eq /-
 @[to_additive]
 theorem lift.of_eq (x : FreeGroup α) : lift of x = x :=
   MonoidHom.congr_fun (lift.apply_symm_apply (MonoidHom.id _)) x
 #align free_group.lift.of_eq FreeGroup.lift.of_eq
 #align free_add_group.lift.of_eq FreeAddGroup.lift.of_eq
+-/
 
+#print FreeGroup.lift.range_le /-
 @[to_additive]
 theorem lift.range_le {s : Subgroup β} (H : Set.range f ⊆ s) : (lift f).range ≤ s := by
   rintro _ ⟨⟨L⟩, rfl⟩ <;>
@@ -880,6 +895,7 @@ theorem lift.range_le {s : Subgroup β} (H : Set.range f ⊆ s) : (lift f).range
           (by simp at ih ⊢ <;> exact s.mul_mem (H ⟨x, rfl⟩) ih)
 #align free_group.lift.range_le FreeGroup.lift.range_le
 #align free_add_group.lift.range_le FreeAddGroup.lift.range_le
+-/
 
 #print FreeGroup.lift.range_eq_closure /-
 @[to_additive]
@@ -899,6 +915,7 @@ section Map
 
 variable {β : Type v} (f : α → β) {x y : FreeGroup α}
 
+#print FreeGroup.map /-
 /-- Any function from `α` to `β` extends uniquely
 to a group homomorphism from the free group
 over `α` to the free group over `β`. -/
@@ -909,38 +926,50 @@ def map : FreeGroup α →* FreeGroup β :=
     (by rintro ⟨L₁⟩ ⟨L₂⟩; simp)
 #align free_group.map FreeGroup.map
 #align free_add_group.map FreeAddGroup.map
+-/
 
 variable {f}
 
+#print FreeGroup.map.mk /-
 @[simp, to_additive]
 theorem map.mk : map f (mk L) = mk (L.map fun x => (f x.1, x.2)) :=
   rfl
 #align free_group.map.mk FreeGroup.map.mk
 #align free_add_group.map.mk FreeAddGroup.map.mk
+-/
 
+#print FreeGroup.map.id /-
 @[simp, to_additive]
 theorem map.id (x : FreeGroup α) : map id x = x := by rcases x with ⟨L⟩ <;> simp [List.map_id']
 #align free_group.map.id FreeGroup.map.id
 #align free_add_group.map.id FreeAddGroup.map.id
+-/
 
+#print FreeGroup.map.id' /-
 @[simp, to_additive]
 theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x :=
   map.id x
 #align free_group.map.id' FreeGroup.map.id'
 #align free_add_group.map.id' FreeAddGroup.map.id'
+-/
 
+#print FreeGroup.map.comp /-
 @[to_additive]
 theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) : map g (map f x) = map (g ∘ f) x := by
   rcases x with ⟨L⟩ <;> simp
 #align free_group.map.comp FreeGroup.map.comp
 #align free_add_group.map.comp FreeAddGroup.map.comp
+-/
 
+#print FreeGroup.map.of /-
 @[simp, to_additive]
 theorem map.of {x} : map f (of x) = of (f x) :=
   rfl
 #align free_group.map.of FreeGroup.map.of
 #align free_add_group.map.of FreeAddGroup.map.of
+-/
 
+#print FreeGroup.map.unique /-
 @[to_additive]
 theorem map.unique (g : FreeGroup α →* FreeGroup β) (hg : ∀ x, g (of x) = of (f x)) :
     ∀ {x}, g x = map f x := by
@@ -953,12 +982,15 @@ theorem map.unique (g : FreeGroup α →* FreeGroup β) (hg : ∀ x, g (of x) =
           (show g (of x * mk t) = map f (of x * mk t) by simp [g.map_mul, hg, ih])
 #align free_group.map.unique FreeGroup.map.unique
 #align free_add_group.map.unique FreeAddGroup.map.unique
+-/
 
+#print FreeGroup.map_eq_lift /-
 @[to_additive]
 theorem map_eq_lift : map f x = lift (of ∘ f) x :=
   Eq.symm <| map.unique _ fun x => by simp
 #align free_group.map_eq_lift FreeGroup.map_eq_lift
 #align free_add_group.map_eq_lift FreeAddGroup.map_eq_lift
+-/
 
 #print FreeGroup.freeGroupCongr /-
 /-- Equivalent types give rise to multiplicatively equivalent free groups.
@@ -987,18 +1019,22 @@ theorem freeGroupCongr_refl : freeGroupCongr (Equiv.refl α) = MulEquiv.refl _ :
 #align free_add_group.free_add_group_congr_refl FreeAddGroup.freeAddGroupCongr_refl
 -/
 
+#print FreeGroup.freeGroupCongr_symm /-
 @[simp, to_additive]
 theorem freeGroupCongr_symm {α β} (e : α ≃ β) : (freeGroupCongr e).symm = freeGroupCongr e.symm :=
   rfl
 #align free_group.free_group_congr_symm FreeGroup.freeGroupCongr_symm
 #align free_add_group.free_add_group_congr_symm FreeAddGroup.freeAddGroupCongr_symm
+-/
 
+#print FreeGroup.freeGroupCongr_trans /-
 @[to_additive]
 theorem freeGroupCongr_trans {α β γ} (e : α ≃ β) (f : β ≃ γ) :
     (freeGroupCongr e).trans (freeGroupCongr f) = freeGroupCongr (e.trans f) :=
   MulEquiv.ext <| map.comp _ _
 #align free_group.free_group_congr_trans FreeGroup.freeGroupCongr_trans
 #align free_add_group.free_add_group_congr_trans FreeAddGroup.freeAddGroupCongr_trans
+-/
 
 end Map
 
@@ -1006,6 +1042,7 @@ section Prod
 
 variable [Group α] (x y : FreeGroup α)
 
+#print FreeGroup.prod /-
 /-- If `α` is a group, then any function from `α` to `α`
 extends uniquely to a homomorphism from the
 free group over `α` to `α`. This is the multiplicative
@@ -1016,29 +1053,37 @@ def prod : FreeGroup α →* α :=
   lift id
 #align free_group.prod FreeGroup.prod
 #align free_add_group.sum FreeAddGroup.sum
+-/
 
 variable {x y}
 
+#print FreeGroup.prod_mk /-
 @[simp, to_additive]
 theorem prod_mk : prod (mk L) = List.prod (L.map fun x => cond x.2 x.1 x.1⁻¹) :=
   rfl
 #align free_group.prod_mk FreeGroup.prod_mk
 #align free_add_group.sum_mk FreeAddGroup.sum_mk
+-/
 
+#print FreeGroup.prod.of /-
 @[simp, to_additive]
 theorem prod.of {x : α} : prod (of x) = x :=
   lift.of
 #align free_group.prod.of FreeGroup.prod.of
 #align free_add_group.sum.of FreeAddGroup.sum.of
+-/
 
+#print FreeGroup.prod.unique /-
 @[to_additive]
 theorem prod.unique (g : FreeGroup α →* α) (hg : ∀ x, g (of x) = x) {x} : g x = prod x :=
   lift.unique g hg
 #align free_group.prod.unique FreeGroup.prod.unique
 #align free_add_group.sum.unique FreeAddGroup.sum.unique
+-/
 
 end Prod
 
+#print FreeGroup.lift_eq_prod_map /-
 @[to_additive]
 theorem lift_eq_prod_map {β : Type v} [Group β] {f : α → β} {x} : lift f x = prod (map f x) :=
   by
@@ -1047,6 +1092,7 @@ theorem lift_eq_prod_map {β : Type v} [Group β] {f : α → β} {x} : lift f x
   · simp
 #align free_group.lift_eq_prod_map FreeGroup.lift_eq_prod_map
 #align free_add_group.lift_eq_sum_map FreeAddGroup.lift_eq_sum_map
+-/
 
 section Sum
 
@@ -1064,10 +1110,12 @@ def sum : α :=
 
 variable {x y}
 
+#print FreeGroup.sum_mk /-
 @[simp]
 theorem sum_mk : sum (mk L) = List.sum (L.map fun x => cond x.2 x.1 (-x.1)) :=
   rfl
 #align free_group.sum_mk FreeGroup.sum_mk
+-/
 
 #print FreeGroup.sum.of /-
 @[simp]
@@ -1076,22 +1124,28 @@ theorem sum.of {x : α} : sum (of x) = x :=
 #align free_group.sum.of FreeGroup.sum.of
 -/
 
+#print FreeGroup.sum.map_mul /-
 -- note: there are no bundled homs with different notation in the domain and codomain, so we copy
 -- these manually
 @[simp]
 theorem sum.map_mul : sum (x * y) = sum x + sum y :=
   (@prod (Multiplicative _) _).map_mul _ _
 #align free_group.sum.map_mul FreeGroup.sum.map_mul
+-/
 
+#print FreeGroup.sum.map_one /-
 @[simp]
 theorem sum.map_one : sum (1 : FreeGroup α) = 0 :=
   (@prod (Multiplicative _) _).map_one
 #align free_group.sum.map_one FreeGroup.sum.map_one
+-/
 
+#print FreeGroup.sum.map_inv /-
 @[simp]
 theorem sum.map_inv : sum x⁻¹ = -sum x :=
   (prod : FreeGroup (Multiplicative α) →* Multiplicative α).map_inv _
 #align free_group.sum.map_inv FreeGroup.sum.map_inv
+-/
 
 end Sum
 
@@ -1139,6 +1193,7 @@ instance : Monad FreeGroup.{u} where
   map α β f := map f
   bind α β x f := lift f x
 
+#print FreeGroup.induction_on /-
 @[elab_as_elim, to_additive]
 protected theorem induction_on {C : FreeGroup α → Prop} (z : FreeGroup α) (C1 : C 1)
     (Cp : ∀ x, C <| pure x) (Ci : ∀ x, C (pure x) → C (pure x)⁻¹)
@@ -1147,54 +1202,71 @@ protected theorem induction_on {C : FreeGroup α → Prop} (z : FreeGroup α) (C
     List.recOn L C1 fun ⟨x, b⟩ tl ih => Bool.recOn b (Cm _ _ (Ci _ <| Cp x) ih) (Cm _ _ (Cp x) ih)
 #align free_group.induction_on FreeGroup.induction_on
 #align free_add_group.induction_on FreeAddGroup.induction_on
+-/
 
+#print FreeGroup.map_pure /-
 @[simp, to_additive]
 theorem map_pure (f : α → β) (x : α) : f <$> (pure x : FreeGroup α) = pure (f x) :=
   map.of
 #align free_group.map_pure FreeGroup.map_pure
 #align free_add_group.map_pure FreeAddGroup.map_pure
+-/
 
+#print FreeGroup.map_one /-
 @[simp, to_additive]
 theorem map_one (f : α → β) : f <$> (1 : FreeGroup α) = 1 :=
   (map f).map_one
 #align free_group.map_one FreeGroup.map_one
 #align free_add_group.map_zero FreeAddGroup.map_zero
+-/
 
+#print FreeGroup.map_mul /-
 @[simp, to_additive]
 theorem map_mul (f : α → β) (x y : FreeGroup α) : f <$> (x * y) = f <$> x * f <$> y :=
   (map f).map_mul x y
 #align free_group.map_mul FreeGroup.map_mul
 #align free_add_group.map_add FreeAddGroup.map_add
+-/
 
+#print FreeGroup.map_inv /-
 @[simp, to_additive]
 theorem map_inv (f : α → β) (x : FreeGroup α) : f <$> x⁻¹ = (f <$> x)⁻¹ :=
   (map f).map_inv x
 #align free_group.map_inv FreeGroup.map_inv
 #align free_add_group.map_neg FreeAddGroup.map_neg
+-/
 
+#print FreeGroup.pure_bind /-
 @[simp, to_additive]
 theorem pure_bind (f : α → FreeGroup β) (x) : pure x >>= f = f x :=
   lift.of
 #align free_group.pure_bind FreeGroup.pure_bind
 #align free_add_group.pure_bind FreeAddGroup.pure_bind
+-/
 
+#print FreeGroup.one_bind /-
 @[simp, to_additive]
 theorem one_bind (f : α → FreeGroup β) : 1 >>= f = 1 :=
   (lift f).map_one
 #align free_group.one_bind FreeGroup.one_bind
 #align free_add_group.zero_bind FreeAddGroup.zero_bind
+-/
 
+#print FreeGroup.mul_bind /-
 @[simp, to_additive]
 theorem mul_bind (f : α → FreeGroup β) (x y : FreeGroup α) : x * y >>= f = (x >>= f) * (y >>= f) :=
   (lift f).map_mul _ _
 #align free_group.mul_bind FreeGroup.mul_bind
 #align free_add_group.add_bind FreeAddGroup.add_bind
+-/
 
+#print FreeGroup.inv_bind /-
 @[simp, to_additive]
 theorem inv_bind (f : α → FreeGroup β) (x : FreeGroup α) : x⁻¹ >>= f = (x >>= f)⁻¹ :=
   (lift f).map_inv _
 #align free_group.inv_bind FreeGroup.inv_bind
 #align free_add_group.neg_bind FreeAddGroup.neg_bind
+-/
 
 @[to_additive]
 instance : LawfulMonad FreeGroup.{u}

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

@@ -770,7 +770,6 @@ theorem Red.exact : mk L₁ = mk L₂ ↔ Join Red L₁ L₂ :=
   calc
     mk L₁ = mk L₂ ↔ EqvGen Red.Step L₁ L₂ := Iff.intro (Quot.exact _) Quot.EqvGen_sound
     _ ↔ Join Red L₁ L₂ := eqvGen_step_iff_join_red
-    
 #align free_group.red.exact FreeGroup.Red.exact
 #align free_add_group.red.exact FreeAddGroup.Red.exact
 -/
@@ -1618,7 +1617,6 @@ theorem norm_mul_le (x y : FreeGroup α) : norm (x * y) ≤ norm x + norm y :=
     norm (x * y) = norm (mk (x.toWord ++ y.toWord)) := by rw [← mul_mk, mk_to_word, mk_to_word]
     _ ≤ (x.toWord ++ y.toWord).length := norm_mk_le
     _ = norm x + norm y := List.length_append _ _
-    
 #align free_group.norm_mul_le FreeGroup.norm_mul_le
 #align free_add_group.norm_add_le FreeAddGroup.norm_add_le
 -/

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

@@ -305,8 +305,8 @@ theorem cons_cons_iff (p) : Red (p :: L₁) (p :: L₂) ↔ Red L₁ L₂ :=
       generalize eq₁ : (p :: L₁ : List _) = LL₁
       generalize eq₂ : (p :: L₂ : List _) = LL₂
       intro h
-      induction' h using Relation.ReflTransGen.head_induction_on with L₁ L₂ h₁₂ h ih generalizing
-        L₁ L₂
+      induction' h using Relation.ReflTransGen.head_induction_on with L₁ L₂ h₁₂ h ih generalizing L₁
+        L₂
       · subst_vars; cases eq₂; constructor
       · subst_vars
         cases' p with a b

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

@@ -183,7 +183,7 @@ theorem not_step_nil : ¬Step [] L := by
   generalize h' : [] = L'
   intro h
   cases' h with L₁ L₂
-  simp [List.nil_eq_append] at h'
+  simp [List.nil_eq_append] at h' 
   contradiction
 #align free_group.red.not_step_nil FreeGroup.Red.not_step_nil
 #align free_add_group.red.not_step_nil FreeAddGroup.Red.not_step_nil
@@ -197,8 +197,8 @@ theorem Step.cons_left_iff {a : α} {b : Bool} :
   constructor
   · generalize hL : ((a, b) :: L₁ : List _) = L
     rintro @⟨_ | ⟨p, s'⟩, e, a', b'⟩
-    · simp at hL; simp [*]
-    · simp at hL
+    · simp at hL ; simp [*]
+    · simp at hL 
       rcases hL with ⟨rfl, rfl⟩
       refine' Or.inl ⟨s' ++ e, step.bnot, _⟩
       simp
@@ -310,7 +310,7 @@ theorem cons_cons_iff (p) : Red (p :: L₁) (p :: L₂) ↔ Red L₁ L₂ :=
       · subst_vars; cases eq₂; constructor
       · subst_vars
         cases' p with a b
-        rw [step.cons_left_iff] at h₁₂
+        rw [step.cons_left_iff] at h₁₂ 
         rcases h₁₂ with (⟨L, h₁₂, rfl⟩ | rfl)
         · exact (ih rfl rfl).headI h₁₂
         · exact (cons_cons h).tail step.cons_bnot_rev)
@@ -389,7 +389,7 @@ theorem cons_nil_iff_singleton {x b} : Red ((x, b) :: L) [] ↔ Red L [(x, not b
       have h₁ : Red ((x, not b) :: (x, b) :: L) [(x, not b)] := cons_cons h
       have h₂ : Red ((x, not b) :: (x, b) :: L) L := ReflTransGen.single Step.cons_not_rev
       let ⟨L', h₁, h₂⟩ := church_rosser h₁ h₂
-      rw [singleton_iff] at h₁ <;> subst L' <;> assumption)
+      rw [singleton_iff] at h₁  <;> subst L' <;> assumption)
     fun h => (cons_cons h).tail Step.cons_not
 #align free_group.red.cons_nil_iff_singleton FreeGroup.Red.cons_nil_iff_singleton
 #align free_add_group.red.cons_nil_iff_singleton FreeAddGroup.Red.cons_nil_iff_singleton
@@ -404,9 +404,9 @@ theorem red_iff_irreducible {x1 b1 x2 b2} (h : (x1, b1) ≠ (x2, b2)) :
   generalize eq : [(x1, not b1), (x2, b2)] = L'
   intro L h'
   cases h'
-  simp [List.cons_eq_append_iff, List.nil_eq_append] at eq
+  simp [List.cons_eq_append_iff, List.nil_eq_append] at eq 
   rcases Eq with ⟨rfl, ⟨rfl, rfl⟩, ⟨rfl, rfl⟩, rfl⟩; subst_vars
-  simp at h
+  simp at h 
   contradiction
 #align free_group.red.red_iff_irreducible FreeGroup.Red.red_iff_irreducible
 #align free_add_group.red.red_iff_irreducible FreeAddGroup.Red.red_iff_irreducible
@@ -422,15 +422,15 @@ theorem inv_of_red_of_ne {x1 b1 x2 b2} (H1 : (x1, b1) ≠ (x2, b2))
   by
   have : red ((x1, b1) :: L₁) ([(x2, b2)] ++ L₂) := H2
   rcases to_append_iff.1 this with ⟨_ | ⟨p, L₃⟩, L₄, eq, h₁, h₂⟩
-  · simp [nil_iff] at h₁; contradiction
+  · simp [nil_iff] at h₁ ; contradiction
   · cases Eq
     show red (L₃ ++ L₄) ([(x1, not b1), (x2, b2)] ++ L₂)
     apply append_append _ h₂
     have h₁ : red ((x1, not b1) :: (x1, b1) :: L₃) [(x1, not b1), (x2, b2)] := cons_cons h₁
     have h₂ : red ((x1, not b1) :: (x1, b1) :: L₃) L₃ := step.cons_bnot_rev.to_red
     rcases church_rosser h₁ h₂ with ⟨L', h₁, h₂⟩
-    rw [red_iff_irreducible H1] at h₁
-    rwa [h₁] at h₂
+    rw [red_iff_irreducible H1] at h₁ 
+    rwa [h₁] at h₂ 
 #align free_group.red.inv_of_red_of_ne FreeGroup.Red.inv_of_red_of_ne
 #align free_add_group.red.neg_of_red_of_ne FreeAddGroup.Red.neg_of_red_of_ne
 -/
@@ -781,7 +781,7 @@ theorem Red.exact : mk L₁ = mk L₂ ↔ Join Red L₁ L₂ :=
 theorem of_injective : Function.Injective (@of α) := fun _ _ H =>
   by
   let ⟨L₁, hx, hy⟩ := Red.exact.1 H
-  simp [red.singleton_iff] at hx hy <;> cc
+  simp [red.singleton_iff] at hx hy  <;> cc
 #align free_group.of_injective FreeGroup.of_injective
 #align free_add_group.of_injective FreeAddGroup.of_injective
 -/
@@ -877,8 +877,8 @@ theorem lift.range_le {s : Subgroup β} (H : Set.range f ⊆ s) : (lift f).range
   rintro _ ⟨⟨L⟩, rfl⟩ <;>
     exact
       List.recOn L s.one_mem fun ⟨x, b⟩ tl ih =>
-        Bool.recOn b (by simp at ih⊢ <;> exact s.mul_mem (s.inv_mem <| H ⟨x, rfl⟩) ih)
-          (by simp at ih⊢ <;> exact s.mul_mem (H ⟨x, rfl⟩) ih)
+        Bool.recOn b (by simp at ih ⊢ <;> exact s.mul_mem (s.inv_mem <| H ⟨x, rfl⟩) ih)
+          (by simp at ih ⊢ <;> exact s.mul_mem (H ⟨x, rfl⟩) ih)
 #align free_group.lift.range_le FreeGroup.lift.range_le
 #align free_add_group.lift.range_le FreeAddGroup.lift.range_le
 
@@ -1123,10 +1123,10 @@ def freeGroupUnitEquivInt : FreeGroup Unit ≃ ℤ
   left_inv := by
     rintro ⟨L⟩
     refine' List.recOn L rfl _
-    exact fun ⟨⟨⟩, b⟩ tl ih => by cases b <;> simp [zpow_add] at ih⊢ <;> rw [ih] <;> rfl
+    exact fun ⟨⟨⟩, b⟩ tl ih => by cases b <;> simp [zpow_add] at ih ⊢ <;> rw [ih] <;> rfl
   right_inv x :=
-    Int.induction_on x (by simp) (fun i ih => by simp at ih <;> simp [zpow_add, ih]) fun i ih => by
-      simp at ih <;> simp [zpow_add, ih, sub_eq_add_neg, -Int.add_neg_one]
+    Int.induction_on x (by simp) (fun i ih => by simp at ih  <;> simp [zpow_add, ih]) fun i ih => by
+      simp at ih  <;> simp [zpow_add, ih, sub_eq_add_neg, -Int.add_neg_one]
 #align free_group.free_group_unit_equiv_int FreeGroup.freeGroupUnitEquivInt
 -/
 
@@ -1281,16 +1281,16 @@ theorem reduce.not {p : Prop} :
     cases r : reduce L1
     · dsimp; intro h
       have := congr_arg List.length h
-      simp [-add_comm] at this
+      simp [-add_comm] at this 
       exact absurd this (by decide)
     cases' hd with y c
     dsimp only
     split_ifs with h <;> intro H
-    · rw [H] at r
+    · rw [H] at r 
       exact @reduce.not L1 ((y, c) :: L2) L3 x' b' r
     rcases L2 with (_ | ⟨a, L2⟩)
     · injections; subst_vars
-      simp at h; cc
+      simp at h ; cc
     · refine' @reduce.not L1 L2 L3 x' b' _
       injection H with _ H
       rw [r, H]; rfl
@@ -1491,7 +1491,7 @@ theorem reduce_invRev {w : List (α × Bool)} : reduce (invRev w) = invRev (redu
   rw [← red_inv_rev_iff, inv_rev_inv_rev]
   apply red.reduce_left
   have : red (inv_rev (inv_rev w)) (inv_rev (reduce (inv_rev w))) := reduce.red.inv_rev
-  rwa [inv_rev_inv_rev] at this
+  rwa [inv_rev_inv_rev] at this 
 #align free_group.reduce_inv_rev FreeGroup.reduce_invRev
 #align free_add_group.reduce_neg_rev FreeAddGroup.reduce_negRev
 -/

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

@@ -462,12 +462,6 @@ theorem length_le (h : Red L₁ L₂) : L₂.length ≤ L₁.length :=
 #align free_add_group.red.length_le FreeAddGroup.Red.length_le
 -/
 
-/- warning: free_group.red.sizeof_of_step -> FreeGroup.Red.sizeof_of_step is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {L₁ : List.{u1} (Prod.{u1, 0} α Bool)} {L₂ : List.{u1} (Prod.{u1, 0} α Bool)}, (FreeGroup.Red.Step.{u1} α L₁ L₂) -> (LT.lt.{0} Nat Nat.hasLt (List.sizeof.{u1} (Prod.{u1, 0} α Bool) (Prod.hasSizeof.{u1, 0} α Bool (defaultHasSizeof.{succ u1} α) Bool.hasSizeof) L₂) (List.sizeof.{u1} (Prod.{u1, 0} α Bool) (Prod.hasSizeof.{u1, 0} α Bool (defaultHasSizeof.{succ u1} α) Bool.hasSizeof) L₁))
-but is expected to have type
-  forall {α : Type.{u1}} {L₁ : List.{u1} (Prod.{u1, 0} α Bool)} {L₂ : List.{u1} (Prod.{u1, 0} α Bool)}, (FreeGroup.Red.Step.{u1} α L₁ L₂) -> (LT.lt.{0} Nat instLTNat (SizeOf.sizeOf.{succ u1} (List.{u1} (Prod.{u1, 0} α Bool)) (List._sizeOf_inst.{u1} (Prod.{u1, 0} α Bool) (Prod._sizeOf_inst.{u1, 0} α Bool (instSizeOf.{succ u1} α) Bool._sizeOf_inst)) L₂) (SizeOf.sizeOf.{succ u1} (List.{u1} (Prod.{u1, 0} α Bool)) (List._sizeOf_inst.{u1} (Prod.{u1, 0} α Bool) (Prod._sizeOf_inst.{u1, 0} α Bool (instSizeOf.{succ u1} α) Bool._sizeOf_inst)) L₁))
-Case conversion may be inaccurate. Consider using '#align free_group.red.sizeof_of_step FreeGroup.Red.sizeof_of_stepₓ'. -/
 @[to_additive]
 theorem sizeof_of_step : ∀ {L₁ L₂ : List (α × Bool)}, Step L₁ L₂ → L₂.sizeOf < L₁.sizeOf
   | _, _, @step.bnot _ L1 L2 x b => by
@@ -814,12 +808,6 @@ theorem Red.Step.lift {f : α → β} (H : Red.Step L₁ L₂) : Lift.aux f L₁
 #align free_add_group.red.step.lift FreeAddGroup.Red.Step.lift
 -/
 
-/- warning: free_group.lift -> FreeGroup.lift is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β], Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β], Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))
-Case conversion may be inaccurate. Consider using '#align free_group.lift FreeGroup.liftₓ'. -/
 /-- If `β` is a group, then any function from `α` to `β`
 extends uniquely to a group homomorphism from
 the free group over `α` to `β` -/
@@ -848,45 +836,24 @@ def lift : (α → β) ≃ (FreeGroup α →* β)
 
 variable {f}
 
-/- warning: free_group.lift.mk -> FreeGroup.lift.mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.mk.{u1} α L)) (List.prod.{u2} β (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MulOneClass.toHasOne.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (List.map.{u1, u2} (Prod.{u1, 0} α Bool) β (fun (x : Prod.{u1, 0} α Bool) => cond.{u2} β (Prod.snd.{u1, 0} α Bool x) (f (Prod.fst.{u1, 0} α Bool x)) (Inv.inv.{u2} β (DivInvMonoid.toHasInv.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)) (f (Prod.fst.{u1, 0} α Bool x)))) L))
-but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.mk.{u1} α L)) (List.prod.{u2} β (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (InvOneClass.toOne.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (List.map.{u1, u2} (Prod.{u1, 0} α Bool) β (fun (x : Prod.{u1, 0} α Bool) => cond.{u2} β (Prod.snd.{u1, 0} α Bool x) (f (Prod.fst.{u1, 0} α Bool x)) (Inv.inv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (f (Prod.fst.{u1, 0} α Bool x)))) L))
-Case conversion may be inaccurate. Consider using '#align free_group.lift.mk FreeGroup.lift.mkₓ'. -/
 @[simp, to_additive]
 theorem lift.mk : lift f (mk L) = List.prod (L.map fun x => cond x.2 (f x.1) (f x.1)⁻¹) :=
   rfl
 #align free_group.lift.mk FreeGroup.lift.mk
 #align free_add_group.lift.mk FreeAddGroup.lift.mk
 
-/- warning: free_group.lift.of -> FreeGroup.lift.of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.of.{u1} α x)) (f x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.of.{u1} α x)) (f x)
-Case conversion may be inaccurate. Consider using '#align free_group.lift.of FreeGroup.lift.ofₓ'. -/
 @[simp, to_additive]
 theorem lift.of {x} : lift f (of x) = f x :=
   one_mul _
 #align free_group.lift.of FreeGroup.lift.of
 #align free_add_group.lift.of FreeAddGroup.lift.of
 
-/- warning: free_group.lift.unique -> FreeGroup.lift.unique is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_group.lift.unique FreeGroup.lift.uniqueₓ'. -/
 @[to_additive]
 theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (of x) = f x) : ∀ {x}, g x = lift f x :=
   MonoidHom.congr_fun <| lift.symm_apply_eq.mp (funext hg : g ∘ of = f)
 #align free_group.lift.unique FreeGroup.lift.unique
 #align free_add_group.lift.unique FreeAddGroup.lift.unique
 
-/- warning: free_group.ext_hom -> FreeGroup.ext_hom is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {G : Type.{u2}} [_inst_2 : Group.{u2} G] (f : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))), (forall (a : α), Eq.{succ u2} G (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) => (FreeGroup.{u1} α) -> G) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) f (FreeGroup.of.{u1} α a)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) => (FreeGroup.{u1} α) -> G) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) g (FreeGroup.of.{u1} α a))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) f g)
-but is expected to have type
-  forall {α : Type.{u2}} {G : Type.{u1}} [_inst_2 : Group.{u1} G] (f : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (g : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))), (forall (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u2} α) => G) (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) f (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) g (FreeGroup.of.{u2} α a))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) f g)
-Case conversion may be inaccurate. Consider using '#align free_group.ext_hom FreeGroup.ext_homₓ'. -/
 /-- Two homomorphisms out of a free group are equal if they are equal on generators.
 
 See note [partially-applied ext lemmas]. -/
@@ -899,24 +866,12 @@ theorem ext_hom {G : Type _} [Group G] (f g : FreeGroup α →* G) (h : ∀ a, f
 #align free_group.ext_hom FreeGroup.ext_hom
 #align free_add_group.ext_hom FreeAddGroup.ext_hom
 
-/- warning: free_group.lift.of_eq -> FreeGroup.lift.of_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) (fun (_x : Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) => (α -> (FreeGroup.{u1} α)) -> (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) (FreeGroup.lift.{u1, u1} α (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)) (FreeGroup.of.{u1} α)) x) x
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (α -> (FreeGroup.{u1} α)) (fun (_x : α -> (FreeGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (FreeGroup.lift.{u1, u1} α (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)) (FreeGroup.of.{u1} α)) x) x
-Case conversion may be inaccurate. Consider using '#align free_group.lift.of_eq FreeGroup.lift.of_eqₓ'. -/
 @[to_additive]
 theorem lift.of_eq (x : FreeGroup α) : lift of x = x :=
   MonoidHom.congr_fun (lift.apply_symm_apply (MonoidHom.id _)) x
 #align free_group.lift.of_eq FreeGroup.lift.of_eq
 #align free_add_group.lift.of_eq FreeAddGroup.lift.of_eq
 
-/- warning: free_group.lift.range_le -> FreeGroup.lift.range_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {s : Subgroup.{u2} β _inst_1}, (HasSubset.Subset.{u2} (Set.{u2} β) (Set.hasSubset.{u2} β) (Set.range.{u2, succ u1} β α f) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Subgroup.{u2} β _inst_1) (Set.{u2} β) (HasLiftT.mk.{succ u2, succ u2} (Subgroup.{u2} β _inst_1) (Set.{u2} β) (CoeTCₓ.coe.{succ u2, succ u2} (Subgroup.{u2} β _inst_1) (Set.{u2} β) (SetLike.Set.hasCoeT.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.setLike.{u2} β _inst_1)))) s)) -> (LE.le.{u2} (Subgroup.{u2} β _inst_1) (Preorder.toHasLe.{u2} (Subgroup.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} (Subgroup.{u2} β _inst_1) (SetLike.partialOrder.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.setLike.{u2} β _inst_1)))) (MonoidHom.range.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.group.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f)) s)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {s : Subgroup.{u2} β _inst_1}, (HasSubset.Subset.{u2} (Set.{u2} β) (Set.instHasSubsetSet.{u2} β) (Set.range.{u2, succ u1} β α f) (SetLike.coe.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.instSetLikeSubgroup.{u2} β _inst_1) s)) -> (LE.le.{u2} (Subgroup.{u2} β _inst_1) (Preorder.toLE.{u2} (Subgroup.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} (Subgroup.{u2} β _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u2} (Subgroup.{u2} β _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Subgroup.{u2} β _inst_1) (Subgroup.instCompleteLatticeSubgroup.{u2} β _inst_1))))) (MonoidHom.range.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α) β _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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f)) s)
-Case conversion may be inaccurate. Consider using '#align free_group.lift.range_le FreeGroup.lift.range_leₓ'. -/
 @[to_additive]
 theorem lift.range_le {s : Subgroup β} (H : Set.range f ⊆ s) : (lift f).range ≤ s := by
   rintro _ ⟨⟨L⟩, rfl⟩ <;>
@@ -945,12 +900,6 @@ section Map
 
 variable {β : Type v} (f : α → β) {x y : FreeGroup α}
 
-/- warning: free_group.map -> FreeGroup.map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}}, (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}}, (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))
-Case conversion may be inaccurate. Consider using '#align free_group.map FreeGroup.mapₓ'. -/
 /-- Any function from `α` to `β` extends uniquely
 to a group homomorphism from the free group
 over `α` to the free group over `β`. -/
@@ -964,65 +913,35 @@ def map : FreeGroup α →* FreeGroup β :=
 
 variable {f}
 
-/- warning: free_group.map.mk -> FreeGroup.map.mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} {f : α -> β}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.mk.{u1} α L)) (FreeGroup.mk.{u2} β (List.map.{u1, u2} (Prod.{u1, 0} α Bool) (Prod.{u2, 0} β Bool) (fun (x : Prod.{u1, 0} α Bool) => Prod.mk.{u2, 0} β Bool (f (Prod.fst.{u1, 0} α Bool x)) (Prod.snd.{u1, 0} α Bool x)) L))
-but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.mk.{u1} α L)) (FreeGroup.mk.{u2} β (List.map.{u1, u2} (Prod.{u1, 0} α Bool) (Prod.{u2, 0} β Bool) (fun (x : Prod.{u1, 0} α Bool) => Prod.mk.{u2, 0} β Bool (f (Prod.fst.{u1, 0} α Bool x)) (Prod.snd.{u1, 0} α Bool x)) L))
-Case conversion may be inaccurate. Consider using '#align free_group.map.mk FreeGroup.map.mkₓ'. -/
 @[simp, to_additive]
 theorem map.mk : map f (mk L) = mk (L.map fun x => (f x.1, x.2)) :=
   rfl
 #align free_group.map.mk FreeGroup.map.mk
 #align free_add_group.map.mk FreeAddGroup.map.mk
 
-/- warning: free_group.map.id -> FreeGroup.map.id is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (FreeGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
-Case conversion may be inaccurate. Consider using '#align free_group.map.id FreeGroup.map.idₓ'. -/
 @[simp, to_additive]
 theorem map.id (x : FreeGroup α) : map id x = x := by rcases x with ⟨L⟩ <;> simp [List.map_id']
 #align free_group.map.id FreeGroup.map.id
 #align free_add_group.map.id FreeAddGroup.map.id
 
-/- warning: free_group.map.id' -> FreeGroup.map.id' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (FreeGroup.map.{u1, u1} α α (fun (z : α) => z)) x) x
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (fun (z : α) => z)) x) x
-Case conversion may be inaccurate. Consider using '#align free_group.map.id' FreeGroup.map.id'ₓ'. -/
 @[simp, to_additive]
 theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x :=
   map.id x
 #align free_group.map.id' FreeGroup.map.id'
 #align free_add_group.map.id' FreeAddGroup.map.id'
 
-/- warning: free_group.map.comp -> FreeGroup.map.comp is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_group.map.comp FreeGroup.map.compₓ'. -/
 @[to_additive]
 theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) : map g (map f x) = map (g ∘ f) x := by
   rcases x with ⟨L⟩ <;> simp
 #align free_group.map.comp FreeGroup.map.comp
 #align free_add_group.map.comp FreeAddGroup.map.comp
 
-/- warning: free_group.map.of -> FreeGroup.map.of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : α}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))
-Case conversion may be inaccurate. Consider using '#align free_group.map.of FreeGroup.map.ofₓ'. -/
 @[simp, to_additive]
 theorem map.of {x} : map f (of x) = of (f x) :=
   rfl
 #align free_group.map.of FreeGroup.map.of
 #align free_add_group.map.of FreeAddGroup.map.of
 
-/- warning: free_group.map.unique -> FreeGroup.map.unique is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_group.map.unique FreeGroup.map.uniqueₓ'. -/
 @[to_additive]
 theorem map.unique (g : FreeGroup α →* FreeGroup β) (hg : ∀ x, g (of x) = of (f x)) :
     ∀ {x}, g x = map f x := by
@@ -1036,9 +955,6 @@ theorem map.unique (g : FreeGroup α →* FreeGroup β) (hg : ∀ x, g (of x) =
 #align free_group.map.unique FreeGroup.map.unique
 #align free_add_group.map.unique FreeAddGroup.map.unique
 
-/- warning: free_group.map_eq_lift -> FreeGroup.map_eq_lift is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_group.map_eq_lift FreeGroup.map_eq_liftₓ'. -/
 @[to_additive]
 theorem map_eq_lift : map f x = lift (of ∘ f) x :=
   Eq.symm <| map.unique _ fun x => by simp
@@ -1072,24 +988,12 @@ theorem freeGroupCongr_refl : freeGroupCongr (Equiv.refl α) = MulEquiv.refl _ :
 #align free_add_group.free_add_group_congr_refl FreeAddGroup.freeAddGroupCongr_refl
 -/
 
-/- warning: free_group.free_group_congr_symm -> FreeGroup.freeGroupCongr_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (e : Equiv.{succ u1, succ u2} α β), Eq.{max (succ u2) (succ u1)} (MulEquiv.{u2, u1} (FreeGroup.{u2} β) (FreeGroup.{u1} α) (FreeGroup.hasMul.{u2} β) (FreeGroup.hasMul.{u1} α)) (MulEquiv.symm.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (FreeGroup.hasMul.{u1} α) (FreeGroup.hasMul.{u2} β) (FreeGroup.freeGroupCongr.{u1, u2} α β e)) (FreeGroup.freeGroupCongr.{u2, u1} β α (Equiv.symm.{succ u1, succ u2} α β e))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (e : Equiv.{succ u2, succ u1} α β), Eq.{max (succ u1) (succ u2)} (MulEquiv.{u1, u2} (FreeGroup.{u1} β) (FreeGroup.{u2} α) (FreeGroup.instMulFreeGroup.{u1} β) (FreeGroup.instMulFreeGroup.{u2} α)) (MulEquiv.symm.{u2, u1} (FreeGroup.{u2} α) (FreeGroup.{u1} β) (FreeGroup.instMulFreeGroup.{u2} α) (FreeGroup.instMulFreeGroup.{u1} β) (FreeGroup.freeGroupCongr.{u2, u1} α β e)) (FreeGroup.freeGroupCongr.{u1, u2} β α (Equiv.symm.{succ u2, succ u1} α β e))
-Case conversion may be inaccurate. Consider using '#align free_group.free_group_congr_symm FreeGroup.freeGroupCongr_symmₓ'. -/
 @[simp, to_additive]
 theorem freeGroupCongr_symm {α β} (e : α ≃ β) : (freeGroupCongr e).symm = freeGroupCongr e.symm :=
   rfl
 #align free_group.free_group_congr_symm FreeGroup.freeGroupCongr_symm
 #align free_add_group.free_add_group_congr_symm FreeAddGroup.freeAddGroupCongr_symm
 
-/- warning: free_group.free_group_congr_trans -> FreeGroup.freeGroupCongr_trans is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (e : Equiv.{succ u1, succ u2} α β) (f : Equiv.{succ u2, succ u3} β γ), Eq.{max (succ u1) (succ u3)} (MulEquiv.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (FreeGroup.hasMul.{u1} α) (FreeGroup.hasMul.{u3} γ)) (MulEquiv.trans.{u1, u2, u3} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (FreeGroup.hasMul.{u1} α) (FreeGroup.hasMul.{u2} β) (FreeGroup.hasMul.{u3} γ) (FreeGroup.freeGroupCongr.{u1, u2} α β e) (FreeGroup.freeGroupCongr.{u2, u3} β γ f)) (FreeGroup.freeGroupCongr.{u1, u3} α γ (Equiv.trans.{succ u1, succ u2, succ u3} α β γ e f))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} (e : Equiv.{succ u3, succ u2} α β) (f : Equiv.{succ u2, succ u1} β γ), Eq.{max (succ u3) (succ u1)} (MulEquiv.{u3, u1} (FreeGroup.{u3} α) (FreeGroup.{u1} γ) (FreeGroup.instMulFreeGroup.{u3} α) (FreeGroup.instMulFreeGroup.{u1} γ)) (MulEquiv.trans.{u3, u2, u1} (FreeGroup.{u3} α) (FreeGroup.{u2} β) (FreeGroup.{u1} γ) (FreeGroup.instMulFreeGroup.{u3} α) (FreeGroup.instMulFreeGroup.{u2} β) (FreeGroup.instMulFreeGroup.{u1} γ) (FreeGroup.freeGroupCongr.{u3, u2} α β e) (FreeGroup.freeGroupCongr.{u2, u1} β γ f)) (FreeGroup.freeGroupCongr.{u3, u1} α γ (Equiv.trans.{succ u3, succ u2, succ u1} α β γ e f))
-Case conversion may be inaccurate. Consider using '#align free_group.free_group_congr_trans FreeGroup.freeGroupCongr_transₓ'. -/
 @[to_additive]
 theorem freeGroupCongr_trans {α β γ} (e : α ≃ β) (f : β ≃ γ) :
     (freeGroupCongr e).trans (freeGroupCongr f) = freeGroupCongr (e.trans f) :=
@@ -1103,12 +1007,6 @@ section Prod
 
 variable [Group α] (x y : FreeGroup α)
 
-/- warning: free_group.prod -> FreeGroup.prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α], MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α], MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align free_group.prod FreeGroup.prodₓ'. -/
 /-- If `α` is a group, then any function from `α` to `α`
 extends uniquely to a homomorphism from the
 free group over `α` to `α`. This is the multiplicative
@@ -1122,33 +1020,18 @@ def prod : FreeGroup α →* α :=
 
 variable {x y}
 
-/- warning: free_group.prod_mk -> FreeGroup.prod_mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : Group.{u1} α], Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.mk.{u1} α L)) (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Prod.fst.{u1, 0} α Bool x))) L))
-but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : Group.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.mk.{u1} α L)) (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (Prod.fst.{u1, 0} α Bool x))) L))
-Case conversion may be inaccurate. Consider using '#align free_group.prod_mk FreeGroup.prod_mkₓ'. -/
 @[simp, to_additive]
 theorem prod_mk : prod (mk L) = List.prod (L.map fun x => cond x.2 x.1 x.1⁻¹) :=
   rfl
 #align free_group.prod_mk FreeGroup.prod_mk
 #align free_add_group.sum_mk FreeAddGroup.sum_mk
 
-/- warning: free_group.prod.of -> FreeGroup.prod.of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.of.{u1} α x)) x
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.of.{u1} α x)) x
-Case conversion may be inaccurate. Consider using '#align free_group.prod.of FreeGroup.prod.ofₓ'. -/
 @[simp, to_additive]
 theorem prod.of {x : α} : prod (of x) = x :=
   lift.of
 #align free_group.prod.of FreeGroup.prod.of
 #align free_add_group.sum.of FreeAddGroup.sum.of
 
-/- warning: free_group.prod.unique -> FreeGroup.prod.unique is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_group.prod.unique FreeGroup.prod.uniqueₓ'. -/
 @[to_additive]
 theorem prod.unique (g : FreeGroup α →* α) (hg : ∀ x, g (of x) = x) {x} : g x = prod x :=
   lift.unique g hg
@@ -1157,9 +1040,6 @@ theorem prod.unique (g : FreeGroup α →* α) (hg : ∀ x, g (of x) = x) {x} :
 
 end Prod
 
-/- warning: free_group.lift_eq_prod_map -> FreeGroup.lift_eq_prod_map is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align free_group.lift_eq_prod_map FreeGroup.lift_eq_prod_mapₓ'. -/
 @[to_additive]
 theorem lift_eq_prod_map {β : Type v} [Group β] {f : α → β} {x} : lift f x = prod (map f x) :=
   by
@@ -1185,12 +1065,6 @@ def sum : α :=
 
 variable {x y}
 
-/- warning: free_group.sum_mk -> FreeGroup.sum_mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : AddGroup.{u1} α], Eq.{succ u1} α (FreeGroup.sum.{u1} α _inst_1 (FreeGroup.mk.{u1} α L)) (List.sum.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) (Prod.fst.{u1, 0} α Bool x))) L))
-but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : AddGroup.{u1} α], Eq.{succ u1} α (FreeGroup.sum.{u1} α _inst_1 (FreeGroup.mk.{u1} α L)) (List.sum.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))) (Prod.fst.{u1, 0} α Bool x))) L))
-Case conversion may be inaccurate. Consider using '#align free_group.sum_mk FreeGroup.sum_mkₓ'. -/
 @[simp]
 theorem sum_mk : sum (mk L) = List.sum (L.map fun x => cond x.2 x.1 (-x.1)) :=
   rfl
@@ -1203,12 +1077,6 @@ theorem sum.of {x : α} : sum (of x) = x :=
 #align free_group.sum.of FreeGroup.sum.of
 -/
 
-/- warning: free_group.sum.map_mul -> FreeGroup.sum.map_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] {x : FreeGroup.{u1} α} {y : FreeGroup.{u1} α}, Eq.{succ u1} α (FreeGroup.sum.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (instHMul.{u1} (FreeGroup.{u1} α) (FreeGroup.hasMul.{u1} α)) x y)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) (FreeGroup.sum.{u1} α _inst_1 x) (FreeGroup.sum.{u1} α _inst_1 y))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] {x : FreeGroup.{u1} α} {y : FreeGroup.{u1} α}, Eq.{succ u1} α (FreeGroup.sum.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (instHMul.{u1} (FreeGroup.{u1} α) (FreeGroup.instMulFreeGroup.{u1} α)) x y)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) (FreeGroup.sum.{u1} α _inst_1 x) (FreeGroup.sum.{u1} α _inst_1 y))
-Case conversion may be inaccurate. Consider using '#align free_group.sum.map_mul FreeGroup.sum.map_mulₓ'. -/
 -- note: there are no bundled homs with different notation in the domain and codomain, so we copy
 -- these manually
 @[simp]
@@ -1216,23 +1084,11 @@ theorem sum.map_mul : sum (x * y) = sum x + sum y :=
   (@prod (Multiplicative _) _).map_mul _ _
 #align free_group.sum.map_mul FreeGroup.sum.map_mul
 
-/- warning: free_group.sum.map_one -> FreeGroup.sum.map_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α], Eq.{succ u1} α (FreeGroup.sum.{u1} α _inst_1 (OfNat.ofNat.{u1} (FreeGroup.{u1} α) 1 (OfNat.mk.{u1} (FreeGroup.{u1} α) 1 (One.one.{u1} (FreeGroup.{u1} α) (FreeGroup.hasOne.{u1} α))))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α], Eq.{succ u1} α (FreeGroup.sum.{u1} α _inst_1 (OfNat.ofNat.{u1} (FreeGroup.{u1} α) 1 (One.toOfNat1.{u1} (FreeGroup.{u1} α) (FreeGroup.instOneFreeGroup.{u1} α)))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align free_group.sum.map_one FreeGroup.sum.map_oneₓ'. -/
 @[simp]
 theorem sum.map_one : sum (1 : FreeGroup α) = 0 :=
   (@prod (Multiplicative _) _).map_one
 #align free_group.sum.map_one FreeGroup.sum.map_one
 
-/- warning: free_group.sum.map_inv -> FreeGroup.sum.map_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] {x : FreeGroup.{u1} α}, Eq.{succ u1} α (FreeGroup.sum.{u1} α _inst_1 (Inv.inv.{u1} (FreeGroup.{u1} α) (FreeGroup.hasInv.{u1} α) x)) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) (FreeGroup.sum.{u1} α _inst_1 x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] {x : FreeGroup.{u1} α}, Eq.{succ u1} α (FreeGroup.sum.{u1} α _inst_1 (Inv.inv.{u1} (FreeGroup.{u1} α) (FreeGroup.instInvFreeGroup.{u1} α) x)) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))) (FreeGroup.sum.{u1} α _inst_1 x))
-Case conversion may be inaccurate. Consider using '#align free_group.sum.map_inv FreeGroup.sum.map_invₓ'. -/
 @[simp]
 theorem sum.map_inv : sum x⁻¹ = -sum x :=
   (prod : FreeGroup (Multiplicative α) →* Multiplicative α).map_inv _
@@ -1284,12 +1140,6 @@ instance : Monad FreeGroup.{u} where
   map α β f := map f
   bind α β x f := lift f x
 
-/- warning: free_group.induction_on -> FreeGroup.induction_on is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {C : (FreeGroup.{u1} α) -> Prop} (z : FreeGroup.{u1} α), (C (OfNat.ofNat.{u1} (FreeGroup.{u1} α) 1 (OfNat.mk.{u1} (FreeGroup.{u1} α) 1 (One.one.{u1} (FreeGroup.{u1} α) (FreeGroup.hasOne.{u1} α))))) -> (forall (x : α), C (Pure.pure.{u1, u1} FreeGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1})) α x)) -> (forall (x : α), (C (Pure.pure.{u1, u1} FreeGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1})) α x)) -> (C (Inv.inv.{u1} (FreeGroup.{u1} α) (FreeGroup.hasInv.{u1} α) (Pure.pure.{u1, u1} FreeGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1})) α x)))) -> (forall (x : FreeGroup.{u1} α) (y : FreeGroup.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (instHMul.{u1} (FreeGroup.{u1} α) (FreeGroup.hasMul.{u1} α)) x y))) -> (C z)
-but is expected to have type
-  forall {α : Type.{u1}} {C : (FreeGroup.{u1} α) -> Prop} (z : FreeGroup.{u1} α), (C (OfNat.ofNat.{u1} (FreeGroup.{u1} α) 1 (One.toOfNat1.{u1} (FreeGroup.{u1} α) (FreeGroup.instOneFreeGroup.{u1} α)))) -> (forall (x : α), C (Pure.pure.{u1, u1} FreeGroup.{u1} (Applicative.toPure.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) α x)) -> (forall (x : α), (C (Pure.pure.{u1, u1} FreeGroup.{u1} (Applicative.toPure.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) α x)) -> (C (Inv.inv.{u1} (FreeGroup.{u1} α) (FreeGroup.instInvFreeGroup.{u1} α) (Pure.pure.{u1, u1} FreeGroup.{u1} (Applicative.toPure.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) α x)))) -> (forall (x : FreeGroup.{u1} α) (y : FreeGroup.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (instHMul.{u1} (FreeGroup.{u1} α) (FreeGroup.instMulFreeGroup.{u1} α)) x y))) -> (C z)
-Case conversion may be inaccurate. Consider using '#align free_group.induction_on FreeGroup.induction_onₓ'. -/
 @[elab_as_elim, to_additive]
 protected theorem induction_on {C : FreeGroup α → Prop} (z : FreeGroup α) (C1 : C 1)
     (Cp : ∀ x, C <| pure x) (Ci : ∀ x, C (pure x) → C (pure x)⁻¹)
@@ -1299,96 +1149,48 @@ protected theorem induction_on {C : FreeGroup α → Prop} (z : FreeGroup α) (C
 #align free_group.induction_on FreeGroup.induction_on
 #align free_add_group.induction_on FreeAddGroup.induction_on
 
-/- warning: free_group.map_pure -> FreeGroup.map_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : α), Eq.{succ u1} (FreeGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeGroup.{u1} α) FreeGroup.monad.{u1})) α β f (Pure.pure.{u1, u1} FreeGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1})) α x)) (Pure.pure.{u1, u1} FreeGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1})) β (f x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : α), Eq.{succ u1} (FreeGroup.{u1} β) (Functor.map.{u1, u1} FreeGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) α β f (Pure.pure.{u1, u1} FreeGroup.{u1} (Applicative.toPure.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) α x)) (Pure.pure.{u1, u1} FreeGroup.{u1} (Applicative.toPure.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) β (f x))
-Case conversion may be inaccurate. Consider using '#align free_group.map_pure FreeGroup.map_pureₓ'. -/
 @[simp, to_additive]
 theorem map_pure (f : α → β) (x : α) : f <$> (pure x : FreeGroup α) = pure (f x) :=
   map.of
 #align free_group.map_pure FreeGroup.map_pure
 #align free_add_group.map_pure FreeAddGroup.map_pure
 
-/- warning: free_group.map_one -> FreeGroup.map_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β), Eq.{succ u1} (FreeGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeGroup.{u1} α) FreeGroup.monad.{u1})) α β f (OfNat.ofNat.{u1} (FreeGroup.{u1} α) 1 (OfNat.mk.{u1} (FreeGroup.{u1} α) 1 (One.one.{u1} (FreeGroup.{u1} α) (FreeGroup.hasOne.{u1} α))))) (OfNat.ofNat.{u1} (FreeGroup.{u1} β) 1 (OfNat.mk.{u1} (FreeGroup.{u1} β) 1 (One.one.{u1} (FreeGroup.{u1} β) (FreeGroup.hasOne.{u1} β))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β), Eq.{succ u1} (FreeGroup.{u1} β) (Functor.map.{u1, u1} FreeGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) α β f (OfNat.ofNat.{u1} (FreeGroup.{u1} α) 1 (One.toOfNat1.{u1} (FreeGroup.{u1} α) (FreeGroup.instOneFreeGroup.{u1} α)))) (OfNat.ofNat.{u1} (FreeGroup.{u1} β) 1 (One.toOfNat1.{u1} (FreeGroup.{u1} β) (FreeGroup.instOneFreeGroup.{u1} β)))
-Case conversion may be inaccurate. Consider using '#align free_group.map_one FreeGroup.map_oneₓ'. -/
 @[simp, to_additive]
 theorem map_one (f : α → β) : f <$> (1 : FreeGroup α) = 1 :=
   (map f).map_one
 #align free_group.map_one FreeGroup.map_one
 #align free_add_group.map_zero FreeAddGroup.map_zero
 
-/- warning: free_group.map_mul -> FreeGroup.map_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeGroup.{u1} α) (y : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeGroup.{u1} α) FreeGroup.monad.{u1})) α β f (HMul.hMul.{u1, u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (instHMul.{u1} (FreeGroup.{u1} α) (FreeGroup.hasMul.{u1} α)) x y)) (HMul.hMul.{u1, u1, u1} (FreeGroup.{u1} β) (FreeGroup.{u1} β) (FreeGroup.{u1} β) (instHMul.{u1} (FreeGroup.{u1} β) (FreeGroup.hasMul.{u1} β)) (Functor.map.{u1, u1} FreeGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1})) α β f x) (Functor.map.{u1, u1} FreeGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1})) α β f y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeGroup.{u1} α) (y : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} β) (Functor.map.{u1, u1} FreeGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) α β f (HMul.hMul.{u1, u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (instHMul.{u1} (FreeGroup.{u1} α) (FreeGroup.instMulFreeGroup.{u1} α)) x y)) (HMul.hMul.{u1, u1, u1} (FreeGroup.{u1} β) (FreeGroup.{u1} β) (FreeGroup.{u1} β) (instHMul.{u1} (FreeGroup.{u1} β) (FreeGroup.instMulFreeGroup.{u1} β)) (Functor.map.{u1, u1} FreeGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) α β f x) (Functor.map.{u1, u1} FreeGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) α β f y))
-Case conversion may be inaccurate. Consider using '#align free_group.map_mul FreeGroup.map_mulₓ'. -/
 @[simp, to_additive]
 theorem map_mul (f : α → β) (x y : FreeGroup α) : f <$> (x * y) = f <$> x * f <$> y :=
   (map f).map_mul x y
 #align free_group.map_mul FreeGroup.map_mul
 #align free_add_group.map_add FreeAddGroup.map_add
 
-/- warning: free_group.map_inv -> FreeGroup.map_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeGroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeGroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeGroup.{u1} α) FreeGroup.monad.{u1})) α β f (Inv.inv.{u1} (FreeGroup.{u1} α) (FreeGroup.hasInv.{u1} α) x)) (Inv.inv.{u1} (FreeGroup.{u1} β) (FreeGroup.hasInv.{u1} β) (Functor.map.{u1, u1} FreeGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1})) α β f x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} β) (Functor.map.{u1, u1} FreeGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) α β f (Inv.inv.{u1} (FreeGroup.{u1} α) (FreeGroup.instInvFreeGroup.{u1} α) x)) (Inv.inv.{u1} (FreeGroup.{u1} β) (FreeGroup.instInvFreeGroup.{u1} β) (Functor.map.{u1, u1} FreeGroup.{u1} (Applicative.toFunctor.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) α β f x))
-Case conversion may be inaccurate. Consider using '#align free_group.map_inv FreeGroup.map_invₓ'. -/
 @[simp, to_additive]
 theorem map_inv (f : α → β) (x : FreeGroup α) : f <$> x⁻¹ = (f <$> x)⁻¹ :=
   (map f).map_inv x
 #align free_group.map_inv FreeGroup.map_inv
 #align free_add_group.map_neg FreeAddGroup.map_neg
 
-/- warning: free_group.pure_bind -> FreeGroup.pure_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeGroup.{u1} β)) (x : α), Eq.{succ u1} (FreeGroup.{u1} β) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toHasBind.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1}) α β (Pure.pure.{u1, u1} FreeGroup.{u1} (Applicative.toHasPure.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1})) α x) f) (f x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeGroup.{u1} β)) (x : α), Eq.{succ u1} (FreeGroup.{u1} β) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toBind.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1}) α β (Pure.pure.{u1, u1} FreeGroup.{u1} (Applicative.toPure.{u1, u1} FreeGroup.{u1} (Monad.toApplicative.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1})) α x) f) (f x)
-Case conversion may be inaccurate. Consider using '#align free_group.pure_bind FreeGroup.pure_bindₓ'. -/
 @[simp, to_additive]
 theorem pure_bind (f : α → FreeGroup β) (x) : pure x >>= f = f x :=
   lift.of
 #align free_group.pure_bind FreeGroup.pure_bind
 #align free_add_group.pure_bind FreeAddGroup.pure_bind
 
-/- warning: free_group.one_bind -> FreeGroup.one_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeGroup.{u1} β)), Eq.{succ u1} (FreeGroup.{u1} β) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toHasBind.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1}) α β (OfNat.ofNat.{u1} (FreeGroup.{u1} α) 1 (OfNat.mk.{u1} (FreeGroup.{u1} α) 1 (One.one.{u1} (FreeGroup.{u1} α) (FreeGroup.hasOne.{u1} α)))) f) (OfNat.ofNat.{u1} (FreeGroup.{u1} β) 1 (OfNat.mk.{u1} (FreeGroup.{u1} β) 1 (One.one.{u1} (FreeGroup.{u1} β) (FreeGroup.hasOne.{u1} β))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeGroup.{u1} β)), Eq.{succ u1} (FreeGroup.{u1} β) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toBind.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1}) α β (OfNat.ofNat.{u1} (FreeGroup.{u1} α) 1 (One.toOfNat1.{u1} (FreeGroup.{u1} α) (FreeGroup.instOneFreeGroup.{u1} α))) f) (OfNat.ofNat.{u1} (FreeGroup.{u1} β) 1 (One.toOfNat1.{u1} (FreeGroup.{u1} β) (FreeGroup.instOneFreeGroup.{u1} β)))
-Case conversion may be inaccurate. Consider using '#align free_group.one_bind FreeGroup.one_bindₓ'. -/
 @[simp, to_additive]
 theorem one_bind (f : α → FreeGroup β) : 1 >>= f = 1 :=
   (lift f).map_one
 #align free_group.one_bind FreeGroup.one_bind
 #align free_add_group.zero_bind FreeAddGroup.zero_bind
 
-/- warning: free_group.mul_bind -> FreeGroup.mul_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeGroup.{u1} β)) (x : FreeGroup.{u1} α) (y : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} β) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toHasBind.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1}) α β (HMul.hMul.{u1, u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (instHMul.{u1} (FreeGroup.{u1} α) (FreeGroup.hasMul.{u1} α)) x y) f) (HMul.hMul.{u1, u1, u1} (FreeGroup.{u1} β) (FreeGroup.{u1} β) (FreeGroup.{u1} β) (instHMul.{u1} (FreeGroup.{u1} β) (FreeGroup.hasMul.{u1} β)) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toHasBind.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1}) α β x f) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toHasBind.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1}) α β y f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeGroup.{u1} β)) (x : FreeGroup.{u1} α) (y : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} β) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toBind.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1}) α β (HMul.hMul.{u1, u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (instHMul.{u1} (FreeGroup.{u1} α) (FreeGroup.instMulFreeGroup.{u1} α)) x y) f) (HMul.hMul.{u1, u1, u1} (FreeGroup.{u1} β) (FreeGroup.{u1} β) (FreeGroup.{u1} β) (instHMul.{u1} (FreeGroup.{u1} β) (FreeGroup.instMulFreeGroup.{u1} β)) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toBind.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1}) α β x f) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toBind.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1}) α β y f))
-Case conversion may be inaccurate. Consider using '#align free_group.mul_bind FreeGroup.mul_bindₓ'. -/
 @[simp, to_additive]
 theorem mul_bind (f : α → FreeGroup β) (x y : FreeGroup α) : x * y >>= f = (x >>= f) * (y >>= f) :=
   (lift f).map_mul _ _
 #align free_group.mul_bind FreeGroup.mul_bind
 #align free_add_group.add_bind FreeAddGroup.add_bind
 
-/- warning: free_group.inv_bind -> FreeGroup.inv_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeGroup.{u1} β)) (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} β) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toHasBind.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1}) α β (Inv.inv.{u1} (FreeGroup.{u1} α) (FreeGroup.hasInv.{u1} α) x) f) (Inv.inv.{u1} (FreeGroup.{u1} β) (FreeGroup.hasInv.{u1} β) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toHasBind.{u1, u1} FreeGroup.{u1} FreeGroup.monad.{u1}) α β x f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeGroup.{u1} β)) (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} β) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toBind.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1}) α β (Inv.inv.{u1} (FreeGroup.{u1} α) (FreeGroup.instInvFreeGroup.{u1} α) x) f) (Inv.inv.{u1} (FreeGroup.{u1} β) (FreeGroup.instInvFreeGroup.{u1} β) (Bind.bind.{u1, u1} FreeGroup.{u1} (Monad.toBind.{u1, u1} FreeGroup.{u1} FreeGroup.instMonadFreeGroup.{u1}) α β x f))
-Case conversion may be inaccurate. Consider using '#align free_group.inv_bind FreeGroup.inv_bindₓ'. -/
 @[simp, to_additive]
 theorem inv_bind (f : α → FreeGroup β) (x : FreeGroup α) : x⁻¹ >>= f = (x >>= f)⁻¹ :=
   (lift f).map_inv _

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

@@ -197,8 +197,7 @@ theorem Step.cons_left_iff {a : α} {b : Bool} :
   constructor
   · generalize hL : ((a, b) :: L₁ : List _) = L
     rintro @⟨_ | ⟨p, s'⟩, e, a', b'⟩
-    · simp at hL
-      simp [*]
+    · simp at hL; simp [*]
     · simp at hL
       rcases hL with ⟨rfl, rfl⟩
       refine' Or.inl ⟨s' ++ e, step.bnot, _⟩
@@ -308,9 +307,7 @@ theorem cons_cons_iff (p) : Red (p :: L₁) (p :: L₂) ↔ Red L₁ L₂ :=
       intro h
       induction' h using Relation.ReflTransGen.head_induction_on with L₁ L₂ h₁₂ h ih generalizing
         L₁ L₂
-      · subst_vars
-        cases eq₂
-        constructor
+      · subst_vars; cases eq₂; constructor
       · subst_vars
         cases' p with a b
         rw [step.cons_left_iff] at h₁₂
@@ -425,8 +422,7 @@ theorem inv_of_red_of_ne {x1 b1 x2 b2} (H1 : (x1, b1) ≠ (x2, b2))
   by
   have : red ((x1, b1) :: L₁) ([(x2, b2)] ++ L₂) := H2
   rcases to_append_iff.1 this with ⟨_ | ⟨p, L₃⟩, L₄, eq, h₁, h₂⟩
-  · simp [nil_iff] at h₁
-    contradiction
+  · simp [nil_iff] at h₁; contradiction
   · cases Eq
     show red (L₃ ++ L₄) ([(x1, not b1), (x2, b2)] ++ L₂)
     apply append_append _ h₂
@@ -704,11 +700,7 @@ theorem invRev_bijective : Function.Bijective (@invRev α) :=
 
 @[to_additive]
 instance : Inv (FreeGroup α) :=
-  ⟨Quot.map invRev
-      (by
-        intro a b h
-        cases h
-        simp [inv_rev])⟩
+  ⟨Quot.map invRev (by intro a b h; cases h; simp [inv_rev])⟩
 
 #print FreeGroup.inv_mk /-
 @[simp, to_additive]
@@ -966,9 +958,7 @@ over `α` to the free group over `β`. -/
       "Any function from `α` to `β` extends uniquely to an additive group homomorphism\nfrom the additive free group over `α` to the additive free group over `β`."]
 def map : FreeGroup α →* FreeGroup β :=
   MonoidHom.mk' (Quot.map (List.map fun x => (f x.1, x.2)) fun L₁ L₂ H => by cases H <;> simp)
-    (by
-      rintro ⟨L₁⟩ ⟨L₂⟩
-      simp)
+    (by rintro ⟨L₁⟩ ⟨L₂⟩; simp)
 #align free_group.map FreeGroup.map
 #align free_add_group.map FreeAddGroup.map
 
@@ -1471,11 +1461,8 @@ theorem reduce.red : Red L (reduce L) :=
       split_ifs with h
       · trans
         · exact red.cons_cons ih
-        · cases hd1
-          cases hd2
-          cases h
-          dsimp at *
-          subst_vars
+        · cases hd1; cases hd2; cases h
+          dsimp at *; subst_vars
           exact red.step.cons_bnot_rev.to_red
       · exact red.cons_cons ih
 #align free_group.reduce.red FreeGroup.reduce.red
@@ -1490,8 +1477,7 @@ theorem reduce.not {p : Prop} :
   | (x, b) :: L1, L2, L3, x', b' => by
     dsimp
     cases r : reduce L1
-    · dsimp
-      intro h
+    · dsimp; intro h
       have := congr_arg List.length h
       simp [-add_comm] at this
       exact absurd this (by decide)
@@ -1501,14 +1487,11 @@ theorem reduce.not {p : Prop} :
     · rw [H] at r
       exact @reduce.not L1 ((y, c) :: L2) L3 x' b' r
     rcases L2 with (_ | ⟨a, L2⟩)
-    · injections
-      subst_vars
-      simp at h
-      cc
+    · injections; subst_vars
+      simp at h; cc
     · refine' @reduce.not L1 L2 L3 x' b' _
       injection H with _ H
-      rw [r, H]
-      rfl
+      rw [r, H]; rfl
 #align free_group.reduce.not FreeGroup.reduce.not
 #align free_add_group.reduce.not FreeAddGroup.reduce.not
 -/
@@ -1676,9 +1659,7 @@ theorem toWord_mk : (mk L₁).toWord = reduce L₁ :=
 
 #print FreeGroup.reduce_toWord /-
 @[simp, to_additive]
-theorem reduce_toWord : ∀ x : FreeGroup α, reduce (toWord x) = toWord x :=
-  by
-  rintro ⟨L⟩
+theorem reduce_toWord : ∀ x : FreeGroup α, reduce (toWord x) = toWord x := by rintro ⟨L⟩;
   exact reduce.idem
 #align free_group.reduce_to_word FreeGroup.reduce_toWord
 #align free_add_group.reduce_to_word FreeAddGroup.reduce_toWord

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

@@ -881,10 +881,7 @@ theorem lift.of {x} : lift f (of x) = f x :=
 #align free_add_group.lift.of FreeAddGroup.lift.of
 
 /- warning: free_group.lift.unique -> FreeGroup.lift.unique is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))), (forall (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) g (FreeGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) g x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g (FreeGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_group.lift.unique FreeGroup.lift.uniqueₓ'. -/
 @[to_additive]
 theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (of x) = f x) : ∀ {x}, g x = lift f x :=
@@ -1013,10 +1010,7 @@ theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x :=
 #align free_add_group.map.id' FreeAddGroup.map.id'
 
 /- warning: free_group.map.comp -> FreeGroup.map.comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (f : α -> β) (g : β -> γ) (x : FreeGroup.{u1} α), Eq.{succ u3} (FreeGroup.{u3} γ) (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (fun (_x : MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) => (FreeGroup.{u2} β) -> (FreeGroup.{u3} γ)) (MonoidHom.hasCoeToFun.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (FreeGroup.map.{u2, u3} β γ g) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x)) (coeFn.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (fun (_x : MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u3} γ)) (MonoidHom.hasCoeToFun.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (FreeGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (f : α -> β) (g : β -> γ) (x : FreeGroup.{u1} α), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (a : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u2) (succ u3), succ u2, succ u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u2, u3} β γ g) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u1) (succ u3), succ u1, succ u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x)
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_group.map.comp FreeGroup.map.compₓ'. -/
 @[to_additive]
 theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) : map g (map f x) = map (g ∘ f) x := by
@@ -1037,10 +1031,7 @@ theorem map.of {x} : map f (of x) = of (f x) :=
 #align free_add_group.map.of FreeAddGroup.map.of
 
 /- warning: free_group.map.unique -> FreeGroup.map.unique is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))), (forall (x : α), Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) g (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) g x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_group.map.unique FreeGroup.map.uniqueₓ'. -/
 @[to_additive]
 theorem map.unique (g : FreeGroup α →* FreeGroup β) (hg : ∀ x, g (of x) = of (f x)) :
@@ -1056,10 +1047,7 @@ theorem map.unique (g : FreeGroup α →* FreeGroup β) (hg : ∀ x, g (of x) =
 #align free_add_group.map.unique FreeAddGroup.map.unique
 
 /- warning: free_group.map_eq_lift -> FreeGroup.map_eq_lift is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (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)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) => (α -> (FreeGroup.{u2} β)) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) (FreeGroup.lift.{u1, u2} α (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (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)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (α -> (FreeGroup.{u2} β)) (fun (_x : α -> (FreeGroup.{u2} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (FreeGroup.lift.{u1, u2} α (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) x)
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_group.map_eq_lift FreeGroup.map_eq_liftₓ'. -/
 @[to_additive]
 theorem map_eq_lift : map f x = lift (of ∘ f) x :=
@@ -1169,10 +1157,7 @@ theorem prod.of {x : α} : prod (of x) = x :=
 #align free_add_group.sum.of FreeAddGroup.sum.of
 
 /- warning: free_group.prod.unique -> FreeGroup.prod.unique is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (g : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))), (forall (x : α), Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) g (FreeGroup.of.{u1} α x)) x) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) g x) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.prod.{u1} α _inst_1) x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (g : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))), (forall (x : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g (FreeGroup.of.{u1} α x)) x) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) x))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_group.prod.unique FreeGroup.prod.uniqueₓ'. -/
 @[to_additive]
 theorem prod.unique (g : FreeGroup α →* α) (hg : ∀ x, g (of x) = x) {x} : g x = prod x :=
@@ -1183,10 +1168,7 @@ theorem prod.unique (g : FreeGroup α →* α) (hg : ∀ x, g (of x) = x) {x} :
 end Prod
 
 /- warning: free_group.lift_eq_prod_map -> FreeGroup.lift_eq_prod_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x) (coeFn.{succ u2, succ u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u2} β) -> β) (MonoidHom.hasCoeToFun.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.prod.{u2} β _inst_1) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x) (FunLike.coe.{succ u2, succ u2, succ u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u2} β) => β) _x) (MulHomClass.toFunLike.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) (FreeGroup.prod.{u2} β _inst_1) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
+<too large>
 Case conversion may be inaccurate. Consider using '#align free_group.lift_eq_prod_map FreeGroup.lift_eq_prod_mapₓ'. -/
 @[to_additive]
 theorem lift_eq_prod_map {β : Type v} [Group β] {f : α → β} {x} : lift f x = prod (map f x) :=

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

@@ -860,7 +860,7 @@ variable {f}
 lean 3 declaration is
   forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.mk.{u1} α L)) (List.prod.{u2} β (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MulOneClass.toHasOne.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (List.map.{u1, u2} (Prod.{u1, 0} α Bool) β (fun (x : Prod.{u1, 0} α Bool) => cond.{u2} β (Prod.snd.{u1, 0} α Bool x) (f (Prod.fst.{u1, 0} α Bool x)) (Inv.inv.{u2} β (DivInvMonoid.toHasInv.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)) (f (Prod.fst.{u1, 0} α Bool x)))) L))
 but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.mk.{u1} α L)) (List.prod.{u2} β (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (InvOneClass.toOne.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (List.map.{u1, u2} (Prod.{u1, 0} α Bool) β (fun (x : Prod.{u1, 0} α Bool) => cond.{u2} β (Prod.snd.{u1, 0} α Bool x) (f (Prod.fst.{u1, 0} α Bool x)) (Inv.inv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (f (Prod.fst.{u1, 0} α Bool x)))) L))
+  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.mk.{u1} α L)) (List.prod.{u2} β (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (InvOneClass.toOne.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (List.map.{u1, u2} (Prod.{u1, 0} α Bool) β (fun (x : Prod.{u1, 0} α Bool) => cond.{u2} β (Prod.snd.{u1, 0} α Bool x) (f (Prod.fst.{u1, 0} α Bool x)) (Inv.inv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (f (Prod.fst.{u1, 0} α Bool x)))) L))
 Case conversion may be inaccurate. Consider using '#align free_group.lift.mk FreeGroup.lift.mkₓ'. -/
 @[simp, to_additive]
 theorem lift.mk : lift f (mk L) = List.prod (L.map fun x => cond x.2 (f x.1) (f x.1)⁻¹) :=
@@ -872,7 +872,7 @@ theorem lift.mk : lift f (mk L) = List.prod (L.map fun x => cond x.2 (f x.1) (f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_group.lift.of FreeGroup.lift.ofₓ'. -/
 @[simp, to_additive]
 theorem lift.of {x} : lift f (of x) = f x :=
@@ -884,7 +884,7 @@ theorem lift.of {x} : lift f (of x) = f x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))), (forall (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) g (FreeGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) g x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g (FreeGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g (FreeGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x))
 Case conversion may be inaccurate. Consider using '#align free_group.lift.unique FreeGroup.lift.uniqueₓ'. -/
 @[to_additive]
 theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (of x) = f x) : ∀ {x}, g x = lift f x :=
@@ -896,7 +896,7 @@ theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (of x) = f x) : 
 lean 3 declaration is
   forall {α : Type.{u1}} {G : Type.{u2}} [_inst_2 : Group.{u2} G] (f : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))), (forall (a : α), Eq.{succ u2} G (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) => (FreeGroup.{u1} α) -> G) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) f (FreeGroup.of.{u1} α a)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) => (FreeGroup.{u1} α) -> G) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) g (FreeGroup.of.{u1} α a))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) f g)
 but is expected to have type
-  forall {α : Type.{u2}} {G : Type.{u1}} [_inst_2 : Group.{u1} G] (f : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (g : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))), (forall (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u2} α) => G) (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) f (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) g (FreeGroup.of.{u2} α a))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) f g)
+  forall {α : Type.{u2}} {G : Type.{u1}} [_inst_2 : Group.{u1} G] (f : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (g : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))), (forall (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u2} α) => G) (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) f (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) g (FreeGroup.of.{u2} α a))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) f g)
 Case conversion may be inaccurate. Consider using '#align free_group.ext_hom FreeGroup.ext_homₓ'. -/
 /-- Two homomorphisms out of a free group are equal if they are equal on generators.
 
@@ -914,7 +914,7 @@ theorem ext_hom {G : Type _} [Group G] (f g : FreeGroup α →* G) (h : ∀ a, f
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) (fun (_x : Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) => (α -> (FreeGroup.{u1} α)) -> (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) (FreeGroup.lift.{u1, u1} α (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)) (FreeGroup.of.{u1} α)) x) x
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (α -> (FreeGroup.{u1} α)) (fun (_x : α -> (FreeGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (FreeGroup.lift.{u1, u1} α (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)) (FreeGroup.of.{u1} α)) x) x
+  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (α -> (FreeGroup.{u1} α)) (fun (_x : α -> (FreeGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (FreeGroup.lift.{u1, u1} α (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)) (FreeGroup.of.{u1} α)) x) x
 Case conversion may be inaccurate. Consider using '#align free_group.lift.of_eq FreeGroup.lift.of_eqₓ'. -/
 @[to_additive]
 theorem lift.of_eq (x : FreeGroup α) : lift of x = x :=
@@ -926,7 +926,7 @@ theorem lift.of_eq (x : FreeGroup α) : lift of x = x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {s : Subgroup.{u2} β _inst_1}, (HasSubset.Subset.{u2} (Set.{u2} β) (Set.hasSubset.{u2} β) (Set.range.{u2, succ u1} β α f) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Subgroup.{u2} β _inst_1) (Set.{u2} β) (HasLiftT.mk.{succ u2, succ u2} (Subgroup.{u2} β _inst_1) (Set.{u2} β) (CoeTCₓ.coe.{succ u2, succ u2} (Subgroup.{u2} β _inst_1) (Set.{u2} β) (SetLike.Set.hasCoeT.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.setLike.{u2} β _inst_1)))) s)) -> (LE.le.{u2} (Subgroup.{u2} β _inst_1) (Preorder.toHasLe.{u2} (Subgroup.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} (Subgroup.{u2} β _inst_1) (SetLike.partialOrder.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.setLike.{u2} β _inst_1)))) (MonoidHom.range.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.group.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f)) s)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {s : Subgroup.{u2} β _inst_1}, (HasSubset.Subset.{u2} (Set.{u2} β) (Set.instHasSubsetSet.{u2} β) (Set.range.{u2, succ u1} β α f) (SetLike.coe.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.instSetLikeSubgroup.{u2} β _inst_1) s)) -> (LE.le.{u2} (Subgroup.{u2} β _inst_1) (Preorder.toLE.{u2} (Subgroup.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} (Subgroup.{u2} β _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u2} (Subgroup.{u2} β _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Subgroup.{u2} β _inst_1) (Subgroup.instCompleteLatticeSubgroup.{u2} β _inst_1))))) (MonoidHom.range.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α) β _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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f)) s)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {s : Subgroup.{u2} β _inst_1}, (HasSubset.Subset.{u2} (Set.{u2} β) (Set.instHasSubsetSet.{u2} β) (Set.range.{u2, succ u1} β α f) (SetLike.coe.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.instSetLikeSubgroup.{u2} β _inst_1) s)) -> (LE.le.{u2} (Subgroup.{u2} β _inst_1) (Preorder.toLE.{u2} (Subgroup.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} (Subgroup.{u2} β _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u2} (Subgroup.{u2} β _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Subgroup.{u2} β _inst_1) (Subgroup.instCompleteLatticeSubgroup.{u2} β _inst_1))))) (MonoidHom.range.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α) β _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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f)) s)
 Case conversion may be inaccurate. Consider using '#align free_group.lift.range_le FreeGroup.lift.range_leₓ'. -/
 @[to_additive]
 theorem lift.range_le {s : Subgroup β} (H : Set.range f ⊆ s) : (lift f).range ≤ s := by
@@ -981,7 +981,7 @@ variable {f}
 lean 3 declaration is
   forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} {f : α -> β}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.mk.{u1} α L)) (FreeGroup.mk.{u2} β (List.map.{u1, u2} (Prod.{u1, 0} α Bool) (Prod.{u2, 0} β Bool) (fun (x : Prod.{u1, 0} α Bool) => Prod.mk.{u2, 0} β Bool (f (Prod.fst.{u1, 0} α Bool x)) (Prod.snd.{u1, 0} α Bool x)) L))
 but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.mk.{u1} α L)) (FreeGroup.mk.{u2} β (List.map.{u1, u2} (Prod.{u1, 0} α Bool) (Prod.{u2, 0} β Bool) (fun (x : Prod.{u1, 0} α Bool) => Prod.mk.{u2, 0} β Bool (f (Prod.fst.{u1, 0} α Bool x)) (Prod.snd.{u1, 0} α Bool x)) L))
+  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.mk.{u1} α L)) (FreeGroup.mk.{u2} β (List.map.{u1, u2} (Prod.{u1, 0} α Bool) (Prod.{u2, 0} β Bool) (fun (x : Prod.{u1, 0} α Bool) => Prod.mk.{u2, 0} β Bool (f (Prod.fst.{u1, 0} α Bool x)) (Prod.snd.{u1, 0} α Bool x)) L))
 Case conversion may be inaccurate. Consider using '#align free_group.map.mk FreeGroup.map.mkₓ'. -/
 @[simp, to_additive]
 theorem map.mk : map f (mk L) = mk (L.map fun x => (f x.1, x.2)) :=
@@ -993,7 +993,7 @@ theorem map.mk : map f (mk L) = mk (L.map fun x => (f x.1, x.2)) :=
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (FreeGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
+  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
 Case conversion may be inaccurate. Consider using '#align free_group.map.id FreeGroup.map.idₓ'. -/
 @[simp, to_additive]
 theorem map.id (x : FreeGroup α) : map id x = x := by rcases x with ⟨L⟩ <;> simp [List.map_id']
@@ -1004,7 +1004,7 @@ theorem map.id (x : FreeGroup α) : map id x = x := by rcases x with ⟨L⟩ <;>
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (FreeGroup.map.{u1, u1} α α (fun (z : α) => z)) x) x
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (fun (z : α) => z)) x) x
+  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (fun (z : α) => z)) x) x
 Case conversion may be inaccurate. Consider using '#align free_group.map.id' FreeGroup.map.id'ₓ'. -/
 @[simp, to_additive]
 theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x :=
@@ -1016,7 +1016,7 @@ theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (f : α -> β) (g : β -> γ) (x : FreeGroup.{u1} α), Eq.{succ u3} (FreeGroup.{u3} γ) (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (fun (_x : MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) => (FreeGroup.{u2} β) -> (FreeGroup.{u3} γ)) (MonoidHom.hasCoeToFun.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (FreeGroup.map.{u2, u3} β γ g) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x)) (coeFn.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (fun (_x : MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u3} γ)) (MonoidHom.hasCoeToFun.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (FreeGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (f : α -> β) (g : β -> γ) (x : FreeGroup.{u1} α), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (a : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u2) (succ u3), succ u2, succ u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u2, u3} β γ g) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u1) (succ u3), succ u1, succ u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x)
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (f : α -> β) (g : β -> γ) (x : FreeGroup.{u1} α), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (a : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u2) (succ u3), succ u2, succ u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u2, u3} β γ g) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u1) (succ u3), succ u1, succ u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x)
 Case conversion may be inaccurate. Consider using '#align free_group.map.comp FreeGroup.map.compₓ'. -/
 @[to_additive]
 theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) : map g (map f x) = map (g ∘ f) x := by
@@ -1028,7 +1028,7 @@ theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) : map g (map
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : α}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))
 Case conversion may be inaccurate. Consider using '#align free_group.map.of FreeGroup.map.ofₓ'. -/
 @[simp, to_additive]
 theorem map.of {x} : map f (of x) = of (f x) :=
@@ -1040,7 +1040,7 @@ theorem map.of {x} : map f (of x) = of (f x) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))), (forall (x : α), Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) g (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) g x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
 Case conversion may be inaccurate. Consider using '#align free_group.map.unique FreeGroup.map.uniqueₓ'. -/
 @[to_additive]
 theorem map.unique (g : FreeGroup α →* FreeGroup β) (hg : ∀ x, g (of x) = of (f x)) :
@@ -1059,7 +1059,7 @@ theorem map.unique (g : FreeGroup α →* FreeGroup β) (hg : ∀ x, g (of x) =
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (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)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) => (α -> (FreeGroup.{u2} β)) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) (FreeGroup.lift.{u1, u2} α (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (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)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (α -> (FreeGroup.{u2} β)) (fun (_x : α -> (FreeGroup.{u2} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (FreeGroup.lift.{u1, u2} α (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) x)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (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)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (α -> (FreeGroup.{u2} β)) (fun (_x : α -> (FreeGroup.{u2} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (FreeGroup.lift.{u1, u2} α (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) x)
 Case conversion may be inaccurate. Consider using '#align free_group.map_eq_lift FreeGroup.map_eq_liftₓ'. -/
 @[to_additive]
 theorem map_eq_lift : map f x = lift (of ∘ f) x :=
@@ -1148,7 +1148,7 @@ variable {x y}
 lean 3 declaration is
   forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : Group.{u1} α], Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.mk.{u1} α L)) (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Prod.fst.{u1, 0} α Bool x))) L))
 but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : Group.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.mk.{u1} α L)) (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (Prod.fst.{u1, 0} α Bool x))) L))
+  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : Group.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.mk.{u1} α L)) (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (Prod.fst.{u1, 0} α Bool x))) L))
 Case conversion may be inaccurate. Consider using '#align free_group.prod_mk FreeGroup.prod_mkₓ'. -/
 @[simp, to_additive]
 theorem prod_mk : prod (mk L) = List.prod (L.map fun x => cond x.2 x.1 x.1⁻¹) :=
@@ -1160,7 +1160,7 @@ theorem prod_mk : prod (mk L) = List.prod (L.map fun x => cond x.2 x.1 x.1⁻¹)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.of.{u1} α x)) x
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.of.{u1} α x)) x
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.of.{u1} α x)) x
 Case conversion may be inaccurate. Consider using '#align free_group.prod.of FreeGroup.prod.ofₓ'. -/
 @[simp, to_additive]
 theorem prod.of {x : α} : prod (of x) = x :=
@@ -1172,7 +1172,7 @@ theorem prod.of {x : α} : prod (of x) = x :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (g : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))), (forall (x : α), Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) g (FreeGroup.of.{u1} α x)) x) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) g x) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.prod.{u1} α _inst_1) x))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (g : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))), (forall (x : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g (FreeGroup.of.{u1} α x)) x) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) x))
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (g : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))), (forall (x : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g (FreeGroup.of.{u1} α x)) x) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) x))
 Case conversion may be inaccurate. Consider using '#align free_group.prod.unique FreeGroup.prod.uniqueₓ'. -/
 @[to_additive]
 theorem prod.unique (g : FreeGroup α →* α) (hg : ∀ x, g (of x) = x) {x} : g x = prod x :=
@@ -1186,7 +1186,7 @@ end Prod
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x) (coeFn.{succ u2, succ u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u2} β) -> β) (MonoidHom.hasCoeToFun.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.prod.{u2} β _inst_1) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x) (FunLike.coe.{succ u2, succ u2, succ u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u2} β) => β) _x) (MulHomClass.toFunLike.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) (FreeGroup.prod.{u2} β _inst_1) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x) (FunLike.coe.{succ u2, succ u2, succ u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u2} β) => β) _x) (MulHomClass.toFunLike.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) (FreeGroup.prod.{u2} β _inst_1) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
 Case conversion may be inaccurate. Consider using '#align free_group.lift_eq_prod_map FreeGroup.lift_eq_prod_mapₓ'. -/
 @[to_additive]
 theorem lift_eq_prod_map {β : Type v} [Group β] {f : α → β} {x} : lift f x = prod (map f x) :=

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

@@ -924,7 +924,7 @@ theorem lift.of_eq (x : FreeGroup α) : lift of x = x :=
 
 /- warning: free_group.lift.range_le -> FreeGroup.lift.range_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {s : Subgroup.{u2} β _inst_1}, (HasSubset.Subset.{u2} (Set.{u2} β) (Set.hasSubset.{u2} β) (Set.range.{u2, succ u1} β α f) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Subgroup.{u2} β _inst_1) (Set.{u2} β) (HasLiftT.mk.{succ u2, succ u2} (Subgroup.{u2} β _inst_1) (Set.{u2} β) (CoeTCₓ.coe.{succ u2, succ u2} (Subgroup.{u2} β _inst_1) (Set.{u2} β) (SetLike.Set.hasCoeT.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.setLike.{u2} β _inst_1)))) s)) -> (LE.le.{u2} (Subgroup.{u2} β _inst_1) (Preorder.toLE.{u2} (Subgroup.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} (Subgroup.{u2} β _inst_1) (SetLike.partialOrder.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.setLike.{u2} β _inst_1)))) (MonoidHom.range.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.group.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f)) s)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {s : Subgroup.{u2} β _inst_1}, (HasSubset.Subset.{u2} (Set.{u2} β) (Set.hasSubset.{u2} β) (Set.range.{u2, succ u1} β α f) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Subgroup.{u2} β _inst_1) (Set.{u2} β) (HasLiftT.mk.{succ u2, succ u2} (Subgroup.{u2} β _inst_1) (Set.{u2} β) (CoeTCₓ.coe.{succ u2, succ u2} (Subgroup.{u2} β _inst_1) (Set.{u2} β) (SetLike.Set.hasCoeT.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.setLike.{u2} β _inst_1)))) s)) -> (LE.le.{u2} (Subgroup.{u2} β _inst_1) (Preorder.toHasLe.{u2} (Subgroup.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} (Subgroup.{u2} β _inst_1) (SetLike.partialOrder.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.setLike.{u2} β _inst_1)))) (MonoidHom.range.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.group.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f)) s)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {s : Subgroup.{u2} β _inst_1}, (HasSubset.Subset.{u2} (Set.{u2} β) (Set.instHasSubsetSet.{u2} β) (Set.range.{u2, succ u1} β α f) (SetLike.coe.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.instSetLikeSubgroup.{u2} β _inst_1) s)) -> (LE.le.{u2} (Subgroup.{u2} β _inst_1) (Preorder.toLE.{u2} (Subgroup.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} (Subgroup.{u2} β _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u2} (Subgroup.{u2} β _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Subgroup.{u2} β _inst_1) (Subgroup.instCompleteLatticeSubgroup.{u2} β _inst_1))))) (MonoidHom.range.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α) β _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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f)) s)
 Case conversion may be inaccurate. Consider using '#align free_group.lift.range_le FreeGroup.lift.range_leₓ'. -/

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

@@ -860,7 +860,7 @@ variable {f}
 lean 3 declaration is
   forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.mk.{u1} α L)) (List.prod.{u2} β (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MulOneClass.toHasOne.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (List.map.{u1, u2} (Prod.{u1, 0} α Bool) β (fun (x : Prod.{u1, 0} α Bool) => cond.{u2} β (Prod.snd.{u1, 0} α Bool x) (f (Prod.fst.{u1, 0} α Bool x)) (Inv.inv.{u2} β (DivInvMonoid.toHasInv.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)) (f (Prod.fst.{u1, 0} α Bool x)))) L))
 but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.mk.{u1} α L)) (List.prod.{u2} β (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (InvOneClass.toOne.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (List.map.{u1, u2} (Prod.{u1, 0} α Bool) β (fun (x : Prod.{u1, 0} α Bool) => cond.{u2} β (Prod.snd.{u1, 0} α Bool x) (f (Prod.fst.{u1, 0} α Bool x)) (Inv.inv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (f (Prod.fst.{u1, 0} α Bool x)))) L))
+  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.mk.{u1} α L)) (List.prod.{u2} β (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (InvOneClass.toOne.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (List.map.{u1, u2} (Prod.{u1, 0} α Bool) β (fun (x : Prod.{u1, 0} α Bool) => cond.{u2} β (Prod.snd.{u1, 0} α Bool x) (f (Prod.fst.{u1, 0} α Bool x)) (Inv.inv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (f (Prod.fst.{u1, 0} α Bool x)))) L))
 Case conversion may be inaccurate. Consider using '#align free_group.lift.mk FreeGroup.lift.mkₓ'. -/
 @[simp, to_additive]
 theorem lift.mk : lift f (mk L) = List.prod (L.map fun x => cond x.2 (f x.1) (f x.1)⁻¹) :=
@@ -872,7 +872,7 @@ theorem lift.mk : lift f (mk L) = List.prod (L.map fun x => cond x.2 (f x.1) (f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_group.lift.of FreeGroup.lift.ofₓ'. -/
 @[simp, to_additive]
 theorem lift.of {x} : lift f (of x) = f x :=
@@ -884,7 +884,7 @@ theorem lift.of {x} : lift f (of x) = f x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))), (forall (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) g (FreeGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) g x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g (FreeGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g (FreeGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x))
 Case conversion may be inaccurate. Consider using '#align free_group.lift.unique FreeGroup.lift.uniqueₓ'. -/
 @[to_additive]
 theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (of x) = f x) : ∀ {x}, g x = lift f x :=
@@ -896,7 +896,7 @@ theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (of x) = f x) : 
 lean 3 declaration is
   forall {α : Type.{u1}} {G : Type.{u2}} [_inst_2 : Group.{u2} G] (f : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))), (forall (a : α), Eq.{succ u2} G (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) => (FreeGroup.{u1} α) -> G) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) f (FreeGroup.of.{u1} α a)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) => (FreeGroup.{u1} α) -> G) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) g (FreeGroup.of.{u1} α a))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) f g)
 but is expected to have type
-  forall {α : Type.{u2}} {G : Type.{u1}} [_inst_2 : Group.{u1} G] (f : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (g : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))), (forall (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u2} α) => G) (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) f (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) g (FreeGroup.of.{u2} α a))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) f g)
+  forall {α : Type.{u2}} {G : Type.{u1}} [_inst_2 : Group.{u1} G] (f : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (g : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))), (forall (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u2} α) => G) (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) f (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) g (FreeGroup.of.{u2} α a))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) f g)
 Case conversion may be inaccurate. Consider using '#align free_group.ext_hom FreeGroup.ext_homₓ'. -/
 /-- Two homomorphisms out of a free group are equal if they are equal on generators.
 
@@ -914,7 +914,7 @@ theorem ext_hom {G : Type _} [Group G] (f g : FreeGroup α →* G) (h : ∀ a, f
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) (fun (_x : Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) => (α -> (FreeGroup.{u1} α)) -> (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) (FreeGroup.lift.{u1, u1} α (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)) (FreeGroup.of.{u1} α)) x) x
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (α -> (FreeGroup.{u1} α)) (fun (_x : α -> (FreeGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (FreeGroup.lift.{u1, u1} α (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)) (FreeGroup.of.{u1} α)) x) x
+  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (α -> (FreeGroup.{u1} α)) (fun (_x : α -> (FreeGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (FreeGroup.lift.{u1, u1} α (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)) (FreeGroup.of.{u1} α)) x) x
 Case conversion may be inaccurate. Consider using '#align free_group.lift.of_eq FreeGroup.lift.of_eqₓ'. -/
 @[to_additive]
 theorem lift.of_eq (x : FreeGroup α) : lift of x = x :=
@@ -926,7 +926,7 @@ theorem lift.of_eq (x : FreeGroup α) : lift of x = x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {s : Subgroup.{u2} β _inst_1}, (HasSubset.Subset.{u2} (Set.{u2} β) (Set.hasSubset.{u2} β) (Set.range.{u2, succ u1} β α f) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Subgroup.{u2} β _inst_1) (Set.{u2} β) (HasLiftT.mk.{succ u2, succ u2} (Subgroup.{u2} β _inst_1) (Set.{u2} β) (CoeTCₓ.coe.{succ u2, succ u2} (Subgroup.{u2} β _inst_1) (Set.{u2} β) (SetLike.Set.hasCoeT.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.setLike.{u2} β _inst_1)))) s)) -> (LE.le.{u2} (Subgroup.{u2} β _inst_1) (Preorder.toLE.{u2} (Subgroup.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} (Subgroup.{u2} β _inst_1) (SetLike.partialOrder.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.setLike.{u2} β _inst_1)))) (MonoidHom.range.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.group.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f)) s)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {s : Subgroup.{u2} β _inst_1}, (HasSubset.Subset.{u2} (Set.{u2} β) (Set.instHasSubsetSet.{u2} β) (Set.range.{u2, succ u1} β α f) (SetLike.coe.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.instSetLikeSubgroup.{u2} β _inst_1) s)) -> (LE.le.{u2} (Subgroup.{u2} β _inst_1) (Preorder.toLE.{u2} (Subgroup.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} (Subgroup.{u2} β _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u2} (Subgroup.{u2} β _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Subgroup.{u2} β _inst_1) (Subgroup.instCompleteLatticeSubgroup.{u2} β _inst_1))))) (MonoidHom.range.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α) β _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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f)) s)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {s : Subgroup.{u2} β _inst_1}, (HasSubset.Subset.{u2} (Set.{u2} β) (Set.instHasSubsetSet.{u2} β) (Set.range.{u2, succ u1} β α f) (SetLike.coe.{u2, u2} (Subgroup.{u2} β _inst_1) β (Subgroup.instSetLikeSubgroup.{u2} β _inst_1) s)) -> (LE.le.{u2} (Subgroup.{u2} β _inst_1) (Preorder.toLE.{u2} (Subgroup.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} (Subgroup.{u2} β _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u2} (Subgroup.{u2} β _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Subgroup.{u2} β _inst_1) (Subgroup.instCompleteLatticeSubgroup.{u2} β _inst_1))))) (MonoidHom.range.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α) β _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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f)) s)
 Case conversion may be inaccurate. Consider using '#align free_group.lift.range_le FreeGroup.lift.range_leₓ'. -/
 @[to_additive]
 theorem lift.range_le {s : Subgroup β} (H : Set.range f ⊆ s) : (lift f).range ≤ s := by
@@ -981,7 +981,7 @@ variable {f}
 lean 3 declaration is
   forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} {f : α -> β}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.mk.{u1} α L)) (FreeGroup.mk.{u2} β (List.map.{u1, u2} (Prod.{u1, 0} α Bool) (Prod.{u2, 0} β Bool) (fun (x : Prod.{u1, 0} α Bool) => Prod.mk.{u2, 0} β Bool (f (Prod.fst.{u1, 0} α Bool x)) (Prod.snd.{u1, 0} α Bool x)) L))
 but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.mk.{u1} α L)) (FreeGroup.mk.{u2} β (List.map.{u1, u2} (Prod.{u1, 0} α Bool) (Prod.{u2, 0} β Bool) (fun (x : Prod.{u1, 0} α Bool) => Prod.mk.{u2, 0} β Bool (f (Prod.fst.{u1, 0} α Bool x)) (Prod.snd.{u1, 0} α Bool x)) L))
+  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.mk.{u1} α L)) (FreeGroup.mk.{u2} β (List.map.{u1, u2} (Prod.{u1, 0} α Bool) (Prod.{u2, 0} β Bool) (fun (x : Prod.{u1, 0} α Bool) => Prod.mk.{u2, 0} β Bool (f (Prod.fst.{u1, 0} α Bool x)) (Prod.snd.{u1, 0} α Bool x)) L))
 Case conversion may be inaccurate. Consider using '#align free_group.map.mk FreeGroup.map.mkₓ'. -/
 @[simp, to_additive]
 theorem map.mk : map f (mk L) = mk (L.map fun x => (f x.1, x.2)) :=
@@ -993,7 +993,7 @@ theorem map.mk : map f (mk L) = mk (L.map fun x => (f x.1, x.2)) :=
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (FreeGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
+  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
 Case conversion may be inaccurate. Consider using '#align free_group.map.id FreeGroup.map.idₓ'. -/
 @[simp, to_additive]
 theorem map.id (x : FreeGroup α) : map id x = x := by rcases x with ⟨L⟩ <;> simp [List.map_id']
@@ -1004,7 +1004,7 @@ theorem map.id (x : FreeGroup α) : map id x = x := by rcases x with ⟨L⟩ <;>
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (FreeGroup.map.{u1, u1} α α (fun (z : α) => z)) x) x
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (fun (z : α) => z)) x) x
+  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (fun (z : α) => z)) x) x
 Case conversion may be inaccurate. Consider using '#align free_group.map.id' FreeGroup.map.id'ₓ'. -/
 @[simp, to_additive]
 theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x :=
@@ -1016,7 +1016,7 @@ theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (f : α -> β) (g : β -> γ) (x : FreeGroup.{u1} α), Eq.{succ u3} (FreeGroup.{u3} γ) (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (fun (_x : MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) => (FreeGroup.{u2} β) -> (FreeGroup.{u3} γ)) (MonoidHom.hasCoeToFun.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (FreeGroup.map.{u2, u3} β γ g) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x)) (coeFn.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (fun (_x : MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u3} γ)) (MonoidHom.hasCoeToFun.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (FreeGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (f : α -> β) (g : β -> γ) (x : FreeGroup.{u1} α), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (a : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u2) (succ u3), succ u2, succ u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u2, u3} β γ g) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u1) (succ u3), succ u1, succ u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x)
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (f : α -> β) (g : β -> γ) (x : FreeGroup.{u1} α), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (a : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u2) (succ u3), succ u2, succ u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u2, u3} β γ g) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u1) (succ u3), succ u1, succ u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x)
 Case conversion may be inaccurate. Consider using '#align free_group.map.comp FreeGroup.map.compₓ'. -/
 @[to_additive]
 theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) : map g (map f x) = map (g ∘ f) x := by
@@ -1028,7 +1028,7 @@ theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) : map g (map
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : α}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))
 Case conversion may be inaccurate. Consider using '#align free_group.map.of FreeGroup.map.ofₓ'. -/
 @[simp, to_additive]
 theorem map.of {x} : map f (of x) = of (f x) :=
@@ -1040,7 +1040,7 @@ theorem map.of {x} : map f (of x) = of (f x) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))), (forall (x : α), Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) g (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) g x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
 Case conversion may be inaccurate. Consider using '#align free_group.map.unique FreeGroup.map.uniqueₓ'. -/
 @[to_additive]
 theorem map.unique (g : FreeGroup α →* FreeGroup β) (hg : ∀ x, g (of x) = of (f x)) :
@@ -1059,7 +1059,7 @@ theorem map.unique (g : FreeGroup α →* FreeGroup β) (hg : ∀ x, g (of x) =
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (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)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) => (α -> (FreeGroup.{u2} β)) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) (FreeGroup.lift.{u1, u2} α (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (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)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (α -> (FreeGroup.{u2} β)) (fun (_x : α -> (FreeGroup.{u2} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (FreeGroup.lift.{u1, u2} α (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) x)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (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)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (α -> (FreeGroup.{u2} β)) (fun (_x : α -> (FreeGroup.{u2} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (FreeGroup.lift.{u1, u2} α (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) x)
 Case conversion may be inaccurate. Consider using '#align free_group.map_eq_lift FreeGroup.map_eq_liftₓ'. -/
 @[to_additive]
 theorem map_eq_lift : map f x = lift (of ∘ f) x :=
@@ -1148,7 +1148,7 @@ variable {x y}
 lean 3 declaration is
   forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : Group.{u1} α], Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.mk.{u1} α L)) (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Prod.fst.{u1, 0} α Bool x))) L))
 but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : Group.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.mk.{u1} α L)) (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (Prod.fst.{u1, 0} α Bool x))) L))
+  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : Group.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.mk.{u1} α L)) (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (Prod.fst.{u1, 0} α Bool x))) L))
 Case conversion may be inaccurate. Consider using '#align free_group.prod_mk FreeGroup.prod_mkₓ'. -/
 @[simp, to_additive]
 theorem prod_mk : prod (mk L) = List.prod (L.map fun x => cond x.2 x.1 x.1⁻¹) :=
@@ -1160,7 +1160,7 @@ theorem prod_mk : prod (mk L) = List.prod (L.map fun x => cond x.2 x.1 x.1⁻¹)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.of.{u1} α x)) x
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.of.{u1} α x)) x
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.of.{u1} α x)) x
 Case conversion may be inaccurate. Consider using '#align free_group.prod.of FreeGroup.prod.ofₓ'. -/
 @[simp, to_additive]
 theorem prod.of {x : α} : prod (of x) = x :=
@@ -1172,7 +1172,7 @@ theorem prod.of {x : α} : prod (of x) = x :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (g : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))), (forall (x : α), Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) g (FreeGroup.of.{u1} α x)) x) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) g x) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.prod.{u1} α _inst_1) x))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (g : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))), (forall (x : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g (FreeGroup.of.{u1} α x)) x) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) x))
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (g : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))), (forall (x : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g (FreeGroup.of.{u1} α x)) x) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) x))
 Case conversion may be inaccurate. Consider using '#align free_group.prod.unique FreeGroup.prod.uniqueₓ'. -/
 @[to_additive]
 theorem prod.unique (g : FreeGroup α →* α) (hg : ∀ x, g (of x) = x) {x} : g x = prod x :=
@@ -1186,7 +1186,7 @@ end Prod
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x) (coeFn.{succ u2, succ u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u2} β) -> β) (MonoidHom.hasCoeToFun.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.prod.{u2} β _inst_1) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x) (FunLike.coe.{succ u2, succ u2, succ u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u2} β) => β) _x) (MulHomClass.toFunLike.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) (FreeGroup.prod.{u2} β _inst_1) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x) (FunLike.coe.{succ u2, succ u2, succ u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u2} β) => β) _x) (MulHomClass.toFunLike.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) (FreeGroup.prod.{u2} β _inst_1) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
 Case conversion may be inaccurate. Consider using '#align free_group.lift_eq_prod_map FreeGroup.lift_eq_prod_mapₓ'. -/
 @[to_additive]
 theorem lift_eq_prod_map {β : Type v} [Group β] {f : α → β} {x} : lift f x = prod (map f x) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

@@ -860,7 +860,7 @@ variable {f}
 lean 3 declaration is
   forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.mk.{u1} α L)) (List.prod.{u2} β (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MulOneClass.toHasOne.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (List.map.{u1, u2} (Prod.{u1, 0} α Bool) β (fun (x : Prod.{u1, 0} α Bool) => cond.{u2} β (Prod.snd.{u1, 0} α Bool x) (f (Prod.fst.{u1, 0} α Bool x)) (Inv.inv.{u2} β (DivInvMonoid.toHasInv.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)) (f (Prod.fst.{u1, 0} α Bool x)))) L))
 but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.mk.{u1} α L)) (List.prod.{u2} β (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (InvOneClass.toOne.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (List.map.{u1, u2} (Prod.{u1, 0} α Bool) β (fun (x : Prod.{u1, 0} α Bool) => cond.{u2} β (Prod.snd.{u1, 0} α Bool x) (f (Prod.fst.{u1, 0} α Bool x)) (Inv.inv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (f (Prod.fst.{u1, 0} α Bool x)))) L))
+  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.mk.{u1} α L)) (List.prod.{u2} β (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (InvOneClass.toOne.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (List.map.{u1, u2} (Prod.{u1, 0} α Bool) β (fun (x : Prod.{u1, 0} α Bool) => cond.{u2} β (Prod.snd.{u1, 0} α Bool x) (f (Prod.fst.{u1, 0} α Bool x)) (Inv.inv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β (Group.toDivisionMonoid.{u2} β _inst_1)))) (f (Prod.fst.{u1, 0} α Bool x)))) L))
 Case conversion may be inaccurate. Consider using '#align free_group.lift.mk FreeGroup.lift.mkₓ'. -/
 @[simp, to_additive]
 theorem lift.mk : lift f (mk L) = List.prod (L.map fun x => cond x.2 (f x.1) (f x.1)⁻¹) :=
@@ -872,7 +872,7 @@ theorem lift.mk : lift f (mk L) = List.prod (L.map fun x => cond x.2 (f x.1) (f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) (FreeGroup.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_group.lift.of FreeGroup.lift.ofₓ'. -/
 @[simp, to_additive]
 theorem lift.of {x} : lift f (of x) = f x :=
@@ -884,7 +884,7 @@ theorem lift.of {x} : lift f (of x) = f x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))), (forall (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) g (FreeGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) g x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g (FreeGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g (FreeGroup.of.{u1} α x)) (f x)) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x))
 Case conversion may be inaccurate. Consider using '#align free_group.lift.unique FreeGroup.lift.uniqueₓ'. -/
 @[to_additive]
 theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (of x) = f x) : ∀ {x}, g x = lift f x :=
@@ -896,7 +896,7 @@ theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (of x) = f x) : 
 lean 3 declaration is
   forall {α : Type.{u1}} {G : Type.{u2}} [_inst_2 : Group.{u2} G] (f : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))), (forall (a : α), Eq.{succ u2} G (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) => (FreeGroup.{u1} α) -> G) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) f (FreeGroup.of.{u1} α a)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) => (FreeGroup.{u1} α) -> G) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) g (FreeGroup.of.{u1} α a))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) G (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) f g)
 but is expected to have type
-  forall {α : Type.{u2}} {G : Type.{u1}} [_inst_2 : Group.{u1} G] (f : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (g : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))), (forall (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u2} α) => G) (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) f (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) g (FreeGroup.of.{u2} α a))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) f g)
+  forall {α : Type.{u2}} {G : Type.{u1}} [_inst_2 : Group.{u1} G] (f : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (g : MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))), (forall (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u2} α) => G) (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) f (FreeGroup.of.{u2} α a)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) (fun (_x : FreeGroup.{u2} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u2} α) => G) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (MulOneClass.toMul.{u2} (FreeGroup.{u2} α) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))) (MonoidHom.monoidHomClass.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))))) g (FreeGroup.of.{u2} α a))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (FreeGroup.{u2} α) G (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} α) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} α) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} α) (FreeGroup.instGroupFreeGroup.{u2} α)))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) f g)
 Case conversion may be inaccurate. Consider using '#align free_group.ext_hom FreeGroup.ext_homₓ'. -/
 /-- Two homomorphisms out of a free group are equal if they are equal on generators.
 
@@ -914,7 +914,7 @@ theorem ext_hom {G : Type _} [Group G] (f g : FreeGroup α →* G) (h : ∀ a, f
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) (fun (_x : Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) => (α -> (FreeGroup.{u1} α)) -> (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))))) (FreeGroup.lift.{u1, u1} α (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)) (FreeGroup.of.{u1} α)) x) x
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (α -> (FreeGroup.{u1} α)) (fun (_x : α -> (FreeGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (FreeGroup.lift.{u1, u1} α (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)) (FreeGroup.of.{u1} α)) x) x
+  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.of.{u1} α)) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (α -> (FreeGroup.{u1} α)) (fun (_x : α -> (FreeGroup.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u1} α)) => MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (α -> (FreeGroup.{u1} α)) (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))))) (FreeGroup.lift.{u1, u1} α (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)) (FreeGroup.of.{u1} α)) x) x
 Case conversion may be inaccurate. Consider using '#align free_group.lift.of_eq FreeGroup.lift.of_eqₓ'. -/
 @[to_additive]
 theorem lift.of_eq (x : FreeGroup α) : lift of x = x :=
@@ -981,7 +981,7 @@ variable {f}
 lean 3 declaration is
   forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} {f : α -> β}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.mk.{u1} α L)) (FreeGroup.mk.{u2} β (List.map.{u1, u2} (Prod.{u1, 0} α Bool) (Prod.{u2, 0} β Bool) (fun (x : Prod.{u1, 0} α Bool) => Prod.mk.{u2, 0} β Bool (f (Prod.fst.{u1, 0} α Bool x)) (Prod.snd.{u1, 0} α Bool x)) L))
 but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.mk.{u1} α L)) (FreeGroup.mk.{u2} β (List.map.{u1, u2} (Prod.{u1, 0} α Bool) (Prod.{u2, 0} β Bool) (fun (x : Prod.{u1, 0} α Bool) => Prod.mk.{u2, 0} β Bool (f (Prod.fst.{u1, 0} α Bool x)) (Prod.snd.{u1, 0} α Bool x)) L))
+  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} {β : Type.{u2}} {f : α -> β}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.mk.{u1} α L)) (FreeGroup.mk.{u2} β (List.map.{u1, u2} (Prod.{u1, 0} α Bool) (Prod.{u2, 0} β Bool) (fun (x : Prod.{u1, 0} α Bool) => Prod.mk.{u2, 0} β Bool (f (Prod.fst.{u1, 0} α Bool x)) (Prod.snd.{u1, 0} α Bool x)) L))
 Case conversion may be inaccurate. Consider using '#align free_group.map.mk FreeGroup.map.mkₓ'. -/
 @[simp, to_additive]
 theorem map.mk : map f (mk L) = mk (L.map fun x => (f x.1, x.2)) :=
@@ -993,7 +993,7 @@ theorem map.mk : map f (mk L) = mk (L.map fun x => (f x.1, x.2)) :=
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (FreeGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
+  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (id.{succ u1} α)) x) x
 Case conversion may be inaccurate. Consider using '#align free_group.map.id FreeGroup.map.idₓ'. -/
 @[simp, to_additive]
 theorem map.id (x : FreeGroup α) : map id x = x := by rcases x with ⟨L⟩ <;> simp [List.map_id']
@@ -1004,7 +1004,7 @@ theorem map.id (x : FreeGroup α) : map id x = x := by rcases x with ⟨L⟩ <;>
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} (FreeGroup.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α))))) (FreeGroup.map.{u1, u1} α α (fun (z : α) => z)) x) x
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (fun (z : α) => z)) x) x
+  forall {α : Type.{u1}} (x : FreeGroup.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))))) (FreeGroup.map.{u1, u1} α α (fun (z : α) => z)) x) x
 Case conversion may be inaccurate. Consider using '#align free_group.map.id' FreeGroup.map.id'ₓ'. -/
 @[simp, to_additive]
 theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x :=
@@ -1016,7 +1016,7 @@ theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (f : α -> β) (g : β -> γ) (x : FreeGroup.{u1} α), Eq.{succ u3} (FreeGroup.{u3} γ) (coeFn.{max (succ u3) (succ u2), max (succ u2) (succ u3)} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (fun (_x : MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) => (FreeGroup.{u2} β) -> (FreeGroup.{u3} γ)) (MonoidHom.hasCoeToFun.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (FreeGroup.map.{u2, u3} β γ g) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x)) (coeFn.{max (succ u3) (succ u1), max (succ u1) (succ u3)} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (fun (_x : MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u3} γ)) (MonoidHom.hasCoeToFun.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.group.{u3} γ))))) (FreeGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (f : α -> β) (g : β -> γ) (x : FreeGroup.{u1} α), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (a : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u2) (succ u3), succ u2, succ u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u2, u3} β γ g) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u1) (succ u3), succ u1, succ u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x)
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} (f : α -> β) (g : β -> γ) (x : FreeGroup.{u1} α), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (a : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u2) (succ u3), succ u2, succ u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u2} β) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u2 u3, u2, u3} (MonoidHom.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u2, u3} (FreeGroup.{u2} β) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u2, u3} β γ g) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x)) (FunLike.coe.{max (succ u1) (succ u3), succ u1, succ u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u3} γ) _x) (MulHomClass.toFunLike.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u3} (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (MonoidHomClass.toMulHomClass.{max u1 u3, u1, u3} (MonoidHom.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))) (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ)))) (MonoidHom.monoidHomClass.{u1, u3} (FreeGroup.{u1} α) (FreeGroup.{u3} γ) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u3} (FreeGroup.{u3} γ) (DivInvMonoid.toMonoid.{u3} (FreeGroup.{u3} γ) (Group.toDivInvMonoid.{u3} (FreeGroup.{u3} γ) (FreeGroup.instGroupFreeGroup.{u3} γ))))))) (FreeGroup.map.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)) x)
 Case conversion may be inaccurate. Consider using '#align free_group.map.comp FreeGroup.map.compₓ'. -/
 @[to_additive]
 theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) : map g (map f x) = map (g ∘ f) x := by
@@ -1028,7 +1028,7 @@ theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) : map g (map
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : α}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))
 Case conversion may be inaccurate. Consider using '#align free_group.map.of FreeGroup.map.ofₓ'. -/
 @[simp, to_additive]
 theorem map.of {x} : map f (of x) = of (f x) :=
@@ -1040,7 +1040,7 @@ theorem map.of {x} : map f (of x) = of (f x) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))), (forall (x : α), Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) g (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) g x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} (g : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))), (forall (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) (FreeGroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g (FreeGroup.of.{u1} α x)) (FreeGroup.of.{u2} β (f x))) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) g x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
 Case conversion may be inaccurate. Consider using '#align free_group.map.unique FreeGroup.map.uniqueₓ'. -/
 @[to_additive]
 theorem map.unique (g : FreeGroup α →* FreeGroup β) (hg : ∀ x, g (of x) = of (f x)) :
@@ -1059,7 +1059,7 @@ theorem map.unique (g : FreeGroup α →* FreeGroup β) (hg : ∀ x, g (of x) =
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} (FreeGroup.{u2} β) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (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)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) => (α -> (FreeGroup.{u2} β)) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))))) (FreeGroup.lift.{u1, u2} α (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (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)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (α -> (FreeGroup.{u2} β)) (fun (_x : α -> (FreeGroup.{u2} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (FreeGroup.lift.{u1, u2} α (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) x)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (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)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (α -> (FreeGroup.{u2} β)) (fun (_x : α -> (FreeGroup.{u2} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> (FreeGroup.{u2} β)) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> (FreeGroup.{u2} β)) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))))) (FreeGroup.lift.{u1, u2} α (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)) (Function.comp.{succ u1, succ u2, succ u2} α β (FreeGroup.{u2} β) (FreeGroup.of.{u2} β) f)) x)
 Case conversion may be inaccurate. Consider using '#align free_group.map_eq_lift FreeGroup.map_eq_liftₓ'. -/
 @[to_additive]
 theorem map_eq_lift : map f x = lift (of ∘ f) x :=
@@ -1148,7 +1148,7 @@ variable {x y}
 lean 3 declaration is
   forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : Group.{u1} α], Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.mk.{u1} α L)) (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Prod.fst.{u1, 0} α Bool x))) L))
 but is expected to have type
-  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : Group.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => α) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.mk.{u1} α L)) (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (Prod.fst.{u1, 0} α Bool x))) L))
+  forall {α : Type.{u1}} {L : List.{u1} (Prod.{u1, 0} α Bool)} [_inst_1 : Group.{u1} α], Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) (FreeGroup.mk.{u1} α L)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.mk.{u1} α L)) (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (List.map.{u1, u1} (Prod.{u1, 0} α Bool) α (fun (x : Prod.{u1, 0} α Bool) => cond.{u1} α (Prod.snd.{u1, 0} α Bool x) (Prod.fst.{u1, 0} α Bool x) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (Prod.fst.{u1, 0} α Bool x))) L))
 Case conversion may be inaccurate. Consider using '#align free_group.prod_mk FreeGroup.prod_mkₓ'. -/
 @[simp, to_additive]
 theorem prod_mk : prod (mk L) = List.prod (L.map fun x => cond x.2 x.1 x.1⁻¹) :=
@@ -1160,7 +1160,7 @@ theorem prod_mk : prod (mk L) = List.prod (L.map fun x => cond x.2 x.1 x.1⁻¹)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.of.{u1} α x)) x
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.of.{u1} α x)) x
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {x : α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) (FreeGroup.of.{u1} α x)) x
 Case conversion may be inaccurate. Consider using '#align free_group.prod.of FreeGroup.prod.ofₓ'. -/
 @[simp, to_additive]
 theorem prod.of {x : α} : prod (of x) = x :=
@@ -1172,7 +1172,7 @@ theorem prod.of {x : α} : prod (of x) = x :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (g : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))), (forall (x : α), Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) g (FreeGroup.of.{u1} α x)) x) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u1} α (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) g x) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) => (FreeGroup.{u1} α) -> α) (MonoidHom.hasCoeToFun.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.prod.{u1} α _inst_1) x))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (g : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))), (forall (x : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g (FreeGroup.of.{u1} α x)) x) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) x))
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (g : MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))), (forall (x : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) (FreeGroup.of.{u1} α x)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g (FreeGroup.of.{u1} α x)) x) -> (forall {x : FreeGroup.{u1} α}, Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) g x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (FreeGroup.{u1} α) α (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (FreeGroup.prod.{u1} α _inst_1) x))
 Case conversion may be inaccurate. Consider using '#align free_group.prod.unique FreeGroup.prod.uniqueₓ'. -/
 @[to_additive]
 theorem prod.unique (g : FreeGroup α →* α) (hg : ∀ x, g (of x) = x) {x} : g x = prod x :=
@@ -1186,7 +1186,7 @@ end Prod
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u1} α) -> β) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) => (α -> β) -> (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x) (coeFn.{succ u2, succ u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (fun (_x : MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) => (FreeGroup.{u2} β) -> β) (MonoidHom.hasCoeToFun.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.prod.{u2} β _inst_1) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (fun (_x : MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) => (FreeGroup.{u1} α) -> (FreeGroup.{u2} β)) (MonoidHom.hasCoeToFun.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.group.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.group.{u2} β))))) (FreeGroup.map.{u1, u2} α β f) x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x) (FunLike.coe.{succ u2, succ u2, succ u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u2} β) => β) _x) (MulHomClass.toFunLike.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) (FreeGroup.prod.{u2} β _inst_1) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u2} β] {f : α -> β} {x : FreeGroup.{u1} α}, Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) x) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) f) (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{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)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MonoidHom.{u1, u2} (FreeGroup.{u1} α) β (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))))) (FreeGroup.lift.{u1, u2} α β _inst_1) f) x) (FunLike.coe.{succ u2, succ u2, succ u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) (fun (_x : FreeGroup.{u2} β) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u2} β) => β) _x) (MulHomClass.toFunLike.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (MonoidHomClass.toMulHomClass.{u2, u2, u2} (MonoidHom.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))) (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1))) (MonoidHom.monoidHomClass.{u2, u2} (FreeGroup.{u2} β) β (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (Group.toDivInvMonoid.{u2} β _inst_1)))))) (FreeGroup.prod.{u2} β _inst_1) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (fun (_x : FreeGroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeGroup.{u1} α) => FreeGroup.{u2} β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (MulOneClass.toMul.{u1} (FreeGroup.{u1} α) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α))))) (MulOneClass.toMul.{u2} (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))) (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β)))) (MonoidHom.monoidHomClass.{u1, u2} (FreeGroup.{u1} α) (FreeGroup.{u2} β) (Monoid.toMulOneClass.{u1} (FreeGroup.{u1} α) (DivInvMonoid.toMonoid.{u1} (FreeGroup.{u1} α) (Group.toDivInvMonoid.{u1} (FreeGroup.{u1} α) (FreeGroup.instGroupFreeGroup.{u1} α)))) (Monoid.toMulOneClass.{u2} (FreeGroup.{u2} β) (DivInvMonoid.toMonoid.{u2} (FreeGroup.{u2} β) (Group.toDivInvMonoid.{u2} (FreeGroup.{u2} β) (FreeGroup.instGroupFreeGroup.{u2} β))))))) (FreeGroup.map.{u1, u2} α β f) x))
 Case conversion may be inaccurate. Consider using '#align free_group.lift_eq_prod_map FreeGroup.lift_eq_prod_mapₓ'. -/
 @[to_additive]
 theorem lift_eq_prod_map {β : Type v} [Group β] {f : α → β} {x} : lift f x = prod (map f x) :=

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

These theorems already exist in Std: https://github.com/leanprover/std4/blob/e5306c3b0edefe722370b7387ee9bcd4631d6c17/Std/Data/List/Lemmas.lean#L150-L157

@@ -345,7 +345,7 @@ theorem red_iff_irreducible {x1 b1 x2 b2} (h : (x1, b1) ≠ (x2, b2)) :
   generalize eq : [(x1, not b1), (x2, b2)] = L'
   intro L h'
   cases h'
-  simp [List.cons_eq_append_iff, List.nil_eq_append] at eq
+  simp [List.cons_eq_append, List.nil_eq_append] at eq
   rcases eq with ⟨rfl, ⟨rfl, rfl⟩, ⟨rfl, rfl⟩, rfl⟩
   simp at h
 #align free_group.red.red_iff_irreducible FreeGroup.Red.red_iff_irreducible

A mix of various changes; generated with a script and manually tweaked.

@@ -946,7 +946,7 @@ section Sum
 variable [AddGroup α] (x y : FreeGroup α)
 
 /-- If `α` is a group, then any function from `α` to `α` extends uniquely to a homomorphism from the
-free group over `α` to `α`. This is the additive version of `prod`. -/
+free group over `α` to `α`. This is the additive version of `Prod`. -/
 def sum : α :=
   @prod (Multiplicative _) _ x
 #align free_group.sum FreeGroup.sum

Removes the insertNth section of this long file to its own new file. This section seems to be completely independent of the rest of the file, so this is a fairly easy split to make.

@@ -5,7 +5,7 @@ Authors: Kenny Lau
 -/
 import Mathlib.Data.Fintype.Basic
 import Mathlib.Data.List.Sublists
-import Mathlib.Data.List.Basic
+import Mathlib.Data.List.InsertNth
 import Mathlib.GroupTheory.Subgroup.Basic
 
 #align_import group_theory.free_group from "leanprover-community/mathlib"@"f93c11933efbc3c2f0299e47b8ff83e9b539cbf6"

• Add FreeGroup.closure_range_of: the subgroup closure of the range of FreeGroup.of : α → FreeGroup α is ⊤. (That is, the generators of a free group generate the free group.)
• Add PresentedGroup.closure_range_of: the subgroup closure of the range of PresentedGroup.of : α → PresentedGroup rels is ⊤. (That is, the generators of a presented group generate the presented group.)

@@ -752,9 +752,13 @@ theorem ext_hom {G : Type*} [Group G] (f g : FreeGroup α →* G) (h : ∀ a, f
 #align free_group.ext_hom FreeGroup.ext_hom
 #align free_add_group.ext_hom FreeAddGroup.ext_hom
 
+@[to_additive]
+theorem lift_of_eq_id (α) : lift of = MonoidHom.id (FreeGroup α) :=
+  lift.apply_symm_apply (MonoidHom.id _)
+
 @[to_additive]
 theorem lift.of_eq (x : FreeGroup α) : lift FreeGroup.of x = x :=
-  DFunLike.congr_fun (lift.apply_symm_apply (MonoidHom.id _)) x
+  DFunLike.congr_fun (lift_of_eq_id α) x
 #align free_group.lift.of_eq FreeGroup.lift.of_eq
 #align free_add_group.lift.of_eq FreeAddGroup.lift.of_eq
 
@@ -777,6 +781,14 @@ theorem lift.range_eq_closure : (lift f).range = Subgroup.closure (Set.range f)
 #align free_group.lift.range_eq_closure FreeGroup.lift.range_eq_closure
 #align free_add_group.lift.range_eq_closure FreeAddGroup.lift.range_eq_closure
 
+/-- The generators of `FreeGroup α` generate `FreeGroup α`. That is, the subgroup closure of the
+set of generators equals `⊤`. -/
+@[to_additive (attr := simp)]
+theorem closure_range_of (α) :
+    Subgroup.closure (Set.range (FreeGroup.of : α → FreeGroup α)) = ⊤ := by
+  rw [← lift.range_eq_closure, lift_of_eq_id]
+  exact MonoidHom.range_top_of_surjective _ Function.surjective_id
+
 end lift
 
 section Map

... and add a deprecated alias for the old name. This is mostly just me discovering the power of F2

@@ -1000,10 +1000,10 @@ def freeGroupUnitEquivInt : FreeGroup Unit ≃ ℤ
   right_inv x :=
     Int.induction_on x (by simp)
       (fun i ih => by
-        simp only [zpow_coe_nat, map_pow, map.of] at ih
+        simp only [zpow_natCast, map_pow, map.of] at ih
         simp [zpow_add, ih])
       (fun i ih => by
-        simp only [zpow_neg, zpow_coe_nat, map_inv, map_pow, map.of, sum.map_inv, neg_inj] at ih
+        simp only [zpow_neg, zpow_natCast, map_inv, map_pow, map.of, sum.map_inv, neg_inj] at ih
         simp [zpow_add, ih, sub_eq_add_neg])
 #align free_group.free_group_unit_equiv_int FreeGroup.freeGroupUnitEquivInt
 

More tactics that are not used, found using the linter at #11308.

The PR consists of tactic removals, whitespace changes and replacing a porting note by an explanation.

@@ -346,7 +346,7 @@ theorem red_iff_irreducible {x1 b1 x2 b2} (h : (x1, b1) ≠ (x2, b2)) :
   intro L h'
   cases h'
   simp [List.cons_eq_append_iff, List.nil_eq_append] at eq
-  rcases eq with ⟨rfl, ⟨rfl, rfl⟩, ⟨rfl, rfl⟩, rfl⟩; subst_vars
+  rcases eq with ⟨rfl, ⟨rfl, rfl⟩, ⟨rfl, rfl⟩, rfl⟩
   simp at h
 #align free_group.red.red_iff_irreducible FreeGroup.Red.red_iff_irreducible
 #align free_add_group.red.red_iff_irreducible FreeAddGroup.Red.red_iff_irreducible
@@ -1135,14 +1135,13 @@ theorem reduce.red : Red L (reduce L) := by
     | cons hd2 tl2 =>
       dsimp only
       split_ifs with h
-      · trans
-        · cases hd1
-          cases hd2
-          cases h
-          dsimp at *
-          subst_vars
-          apply Red.trans (Red.cons_cons ih)
-          exact Red.Step.cons_not_rev.to_red
+      · cases hd1
+        cases hd2
+        cases h
+        dsimp at *
+        subst_vars
+        apply Red.trans (Red.cons_cons ih)
+        exact Red.Step.cons_not_rev.to_red
       · exact Red.cons_cons ih
 #align free_group.reduce.red FreeGroup.reduce.red
 #align free_add_group.reduce.red FreeAddGroup.reduce.red

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

@@ -1026,7 +1026,7 @@ protected theorem induction_on {C : FreeGroup α → Prop} (z : FreeGroup α) (C
 #align free_group.induction_on FreeGroup.induction_on
 #align free_add_group.induction_on FreeAddGroup.induction_on
 
--- porting note: simp can prove this: by simp only [@map_pure]
+-- porting note (#10618): simp can prove this: by simp only [@map_pure]
 @[to_additive]
 theorem map_pure (f : α → β) (x : α) : f <$> (pure x : FreeGroup α) = pure (f x) :=
   map.of
@@ -1051,7 +1051,7 @@ theorem map_inv (f : α → β) (x : FreeGroup α) : f <$> x⁻¹ = (f <$> x)⁻
 #align free_group.map_inv FreeGroup.map_inv
 #align free_add_group.map_neg FreeAddGroup.map_neg
 
--- porting note: simp can prove this: by simp only [@pure_bind]
+-- porting note (#10618): simp can prove this: by simp only [@pure_bind]
 @[to_additive]
 theorem pure_bind (f : α → FreeGroup β) (x) : pure x >>= f = f x :=
   lift.of

@@ -58,7 +58,7 @@ variable {α : Type u}
 
 attribute [local simp] List.append_eq_has_append
 
--- porting notes: to_additive.map_namespace is not supported yet
+-- Porting note: to_additive.map_namespace is not supported yet
 -- worked around it by putting a few extra manual mappings (but not too many all in all)
 -- run_cmd to_additive.map_namespace `FreeGroup `FreeAddGroup
 

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>

@@ -737,7 +737,7 @@ theorem lift.of {x} : lift f (of x) = f x :=
 @[to_additive]
 theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (FreeGroup.of x) = f x) {x} :
     g x = FreeGroup.lift f x :=
-  FunLike.congr_fun (lift.symm_apply_eq.mp (funext hg : g ∘ FreeGroup.of = f)) x
+  DFunLike.congr_fun (lift.symm_apply_eq.mp (funext hg : g ∘ FreeGroup.of = f)) x
 #align free_group.lift.unique FreeGroup.lift.unique
 #align free_add_group.lift.unique FreeAddGroup.lift.unique
 
@@ -754,7 +754,7 @@ theorem ext_hom {G : Type*} [Group G] (f g : FreeGroup α →* G) (h : ∀ a, f
 
 @[to_additive]
 theorem lift.of_eq (x : FreeGroup α) : lift FreeGroup.of x = x :=
-  FunLike.congr_fun (lift.apply_symm_apply (MonoidHom.id _)) x
+  DFunLike.congr_fun (lift.apply_symm_apply (MonoidHom.id _)) x
 #align free_group.lift.of_eq FreeGroup.lift.of_eq
 #align free_add_group.lift.of_eq FreeAddGroup.lift.of_eq
 

See Zulip thread for the discussion.

@@ -1363,7 +1363,7 @@ instance Red.decidableRel : DecidableRel (@Red α)
     if h : (x1, b1) = (x2, b2) then
       match Red.decidableRel tl1 tl2 with
       | isTrue H => isTrue <| h ▸ Red.cons_cons H
-      | isFalse H => isFalse fun H2 => H $ (Red.cons_cons_iff _).1 $ h.symm ▸ H2
+      | isFalse H => isFalse fun H2 => H <| (Red.cons_cons_iff _).1 <| h.symm ▸ H2
     else
       match Red.decidableRel tl1 ((x1, ! b1) :: (x2, b2) :: tl2) with
       | isTrue H => isTrue <| (Red.cons_cons H).tail Red.Step.cons_not

This converts usages of the pattern

cases h
case inl h' => ...
case inr h' => ...

which derive from mathported code, to the "structured cases" syntax:

cases h with
| inl h' => ...
| inr h' => ...

The case where the subgoals are handled with · instead of case is more contentious (and much more numerous) so I left those alone. This pattern also appears with cases', induction, induction', and rcases. Furthermore, there is a similar transformation for by_cases:

by_cases h : cond
case pos => ...
case neg => ...

is replaced by:

if h : cond then
  ...
else
  ...

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -402,8 +402,8 @@ theorem length_le (h : Red L₁ L₂) : L₂.length ≤ L₁.length :=
 theorem sizeof_of_step : ∀ {L₁ L₂ : List (α × Bool)},
     Step L₁ L₂ → sizeOf L₂ < sizeOf L₁
   | _, _, @Step.not _ L1 L2 x b => by
-    induction' L1 with hd tl ih
-    case nil =>
+    induction L1 with
+    | nil =>
       -- dsimp [sizeOf]
       dsimp
       simp only [Bool.sizeOf_eq_one]
@@ -416,7 +416,7 @@ theorem sizeof_of_step : ∀ {L₁ L₂ : List (α × Bool)},
       apply Nat.lt_add_of_pos_right
       apply Nat.lt_add_right
       apply Nat.zero_lt_one
-    case cons =>
+    | cons hd tl ih =>
       dsimp
       exact Nat.add_lt_add_left ih _
 #align free_group.red.sizeof_of_step FreeGroup.Red.sizeof_of_step
@@ -1123,16 +1123,16 @@ theorem reduce.cons (x) :
 @[to_additive "The first theorem that characterises the function `reduce`: a word reduces to its
   maximal reduction."]
 theorem reduce.red : Red L (reduce L) := by
-  induction' L with hd1 tl1 ih
-  case nil => constructor
-  case cons =>
+  induction L with
+  | nil => constructor
+  | cons hd1 tl1 ih =>
     dsimp
     revert ih
     generalize htl : reduce tl1 = TL
     intro ih
-    cases' TL with hd2 tl2
-    case nil => exact Red.cons_cons ih
-    case cons =>
+    cases TL with
+    | nil => exact Red.cons_cons ih
+    | cons hd2 tl2 =>
       dsimp only
       split_ifs with h
       · trans
@@ -1147,41 +1147,37 @@ theorem reduce.red : Red L (reduce L) := by
 #align free_group.reduce.red FreeGroup.reduce.red
 #align free_add_group.reduce.red FreeAddGroup.reduce.red
 
--- porting notes: deleted mathport junk and manually formatted below.
 @[to_additive]
-theorem reduce.not {p : Prop} : ∀ {L₁ L₂ L₃ : List (α × Bool)} {x : α} {b},
-    ((reduce L₁) = L₂ ++ ((x,b)::(x ,!b)::L₃)) → p
-  | [], L2 ,L3, _, _ => fun h => by cases L2 <;> injections
-  | (x, b)::L1, L2, L3, x', b' => by
-      dsimp
-      cases r : reduce L1 with
-      | nil =>
-        dsimp
-        intro h
-        exfalso
-        have := congr_arg List.length h
-        simp? [List.length] at this says
-         simp only [List.length, zero_add, List.length_append] at this
-        rw [add_comm, add_assoc, add_assoc, add_comm, <-add_assoc] at this
-        simp [Nat.one_eq_succ_zero, Nat.succ_add] at this
-        -- Porting note: needed to add this step in #3414.
-        -- This is caused by https://github.com/leanprover/lean4/pull/2146.
-        -- Nevertheless the proof could be cleaned up.
-        cases this
-      | cons hd tail =>
-        cases' hd with y c
-        dsimp only
-        split_ifs with h <;> intro H
-        · rw [ H ] at r
-          exact @reduce.not _ L1 ((y, c)::L2) L3 x' b' r
-        · rcases L2 with ( _ | ⟨ a , L2 ⟩ )
-          · injections
-            subst_vars
-            simp at h
-          · refine' @reduce.not _ L1 L2 L3 x' b' _
-            injection H with _ H
-            rw [ r , H ]
-            rfl
+theorem reduce.not {p : Prop} :
+    ∀ {L₁ L₂ L₃ : List (α × Bool)} {x b}, reduce L₁ = L₂ ++ (x, b) :: (x, !b) :: L₃ → p
+  | [], L2, L3, _, _ => fun h => by cases L2 <;> injections
+  | (x, b) :: L1, L2, L3, x', b' => by
+    dsimp
+    cases r : reduce L1 with
+    | nil =>
+      dsimp; intro h
+      exfalso
+      have := congr_arg List.length h
+      simp? [List.length] at this says
+        simp only [List.length, zero_add, List.length_append] at this
+      rw [add_comm, add_assoc, add_assoc, add_comm, <-add_assoc] at this
+      simp [Nat.one_eq_succ_zero, Nat.succ_add] at this
+      -- Porting note: needed to add this step in #3414.
+      -- This is caused by https://github.com/leanprover/lean4/pull/2146.
+      -- Nevertheless the proof could be cleaned up.
+      cases this
+    | cons hd tail =>
+      cases' hd with y c
+      dsimp only
+      split_ifs with h <;> intro H
+      · rw [H] at r
+        exact @reduce.not _ L1 ((y, c) :: L2) L3 x' b' r
+      rcases L2 with (_ | ⟨a, L2⟩)
+      · injections; subst_vars
+        simp at h
+      · refine' @reduce.not _ L1 L2 L3 x' b' _
+        injection H with _ H
+        rw [r, H]; rfl
 #align free_group.reduce.not FreeGroup.reduce.not
 #align free_add_group.reduce.not FreeAddGroup.reduce.not
 

Removes nonterminal uses of simp at. Replaces most of these with instances of simp? ... says.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -1160,7 +1160,8 @@ theorem reduce.not {p : Prop} : ∀ {L₁ L₂ L₃ : List (α × Bool)} {x : α
         intro h
         exfalso
         have := congr_arg List.length h
-        simp [List.length] at this
+        simp? [List.length] at this says
+         simp only [List.length, zero_add, List.length_append] at this
         rw [add_comm, add_assoc, add_assoc, add_comm, <-add_assoc] at this
         simp [Nat.one_eq_succ_zero, Nat.succ_add] at this
         -- Porting note: needed to add this step in #3414.

@@ -1343,8 +1343,8 @@ theorem toWord_inv {x : FreeGroup α} : x⁻¹.toWord = invRev x.toWord := by
 #align free_group.to_word_inv FreeGroup.toWord_inv
 #align free_add_group.to_word_neg FreeAddGroup.toWord_neg
 
-/-- Constructive Church-Rosser theorem (compare `church_rosser`). -/
-@[to_additive "Constructive Church-Rosser theorem (compare `church_rosser`)."]
+/-- **Constructive Church-Rosser theorem** (compare `church_rosser`). -/
+@[to_additive "**Constructive Church-Rosser theorem** (compare `church_rosser`)."]
 def reduce.churchRosser (H12 : Red L₁ L₂) (H13 : Red L₁ L₃) : { L₄ // Red L₂ L₄ ∧ Red L₃ L₄ } :=
   ⟨reduce L₁, reduce.rev H12, reduce.rev H13⟩
 #align free_group.reduce.church_rosser FreeGroup.reduce.churchRosser

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>

@@ -529,6 +529,9 @@ theorem one_eq_mk : (1 : FreeGroup α) = mk [] :=
 instance : Inhabited (FreeGroup α) :=
   ⟨1⟩
 
+@[to_additive]
+instance [IsEmpty α] : Unique (FreeGroup α) := by unfold FreeGroup; infer_instance
+
 @[to_additive]
 instance : Mul (FreeGroup α) :=
   ⟨fun x y =>

This eliminates (fun a ↦ β) α in the type when applying a FunLike.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -945,7 +945,7 @@ theorem sum_mk : sum (mk L) = List.sum (L.map fun x => cond x.2 x.1 (-x.1)) :=
 
 @[simp]
 theorem sum.of {x : α} : sum (of x) = x :=
-  prod.of
+  @prod.of _ (_) _
 #align free_group.sum.of FreeGroup.sum.of
 
 -- note: there are no bundled homs with different notation in the domain and codomain, so we copy

Adding a test case for induction' that failed and fixing it: induction' a would accidentally leave a and variables depending on a in context.

@@ -260,10 +260,8 @@ theorem cons_cons_iff (p) : Red (p :: L₁) (p :: L₂) ↔ Red L₁ L₂ :=
         generalizing L₁ L₂
       · subst_vars
         cases eq₂
-        cases eq₁
         constructor
       · subst_vars
-        cases eq₂
         cases' p with a b
         rw [Step.cons_left_iff] at h₁₂
         rcases h₁₂ with (⟨L, h₁₂, rfl⟩ | rfl)

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -827,8 +827,8 @@ theorem map.of {x} : map f (of x) = of (f x) :=
 
 @[to_additive]
 theorem map.unique (g : FreeGroup α →* FreeGroup β)
-  (hg : ∀ x, g (FreeGroup.of x) = FreeGroup.of (f x)) :
-  ∀ {x}, g x = map f x := by
+    (hg : ∀ x, g (FreeGroup.of x) = FreeGroup.of (f x)) :
+    ∀ {x}, g x = map f x := by
   rintro ⟨L⟩
   exact List.recOn L g.map_one fun ⟨x, b⟩ t (ih : g (FreeGroup.mk t) = map f (FreeGroup.mk t)) =>
     Bool.recOn b
@@ -1149,7 +1149,7 @@ theorem reduce.red : Red L (reduce L) := by
 -- porting notes: deleted mathport junk and manually formatted below.
 @[to_additive]
 theorem reduce.not {p : Prop} : ∀ {L₁ L₂ L₃ : List (α × Bool)} {x : α} {b},
-  ((reduce L₁) = L₂ ++ ((x,b)::(x ,!b)::L₃)) → p
+    ((reduce L₁) = L₂ ++ ((x,b)::(x ,!b)::L₃)) → p
   | [], L2 ,L3, _, _ => fun h => by cases L2 <;> injections
   | (x, b)::L1, L2, L3, x', b' => by
       dsimp

Purely cosmetic PR

@@ -1087,7 +1087,7 @@ instance : LawfulMonad FreeGroup.{u} := LawfulMonad.mk'
       (fun x => by intros; iterate 2 rw [pure_bind])
       (fun x ih => by intros; (iterate 3 rw [inv_bind]); rw [ih])
       (fun x y ihx ihy => by intros; (iterate 3 rw [mul_bind]); rw [ihx, ihy]))
-  (bind_pure_comp  := fun f x =>
+  (bind_pure_comp := fun f x =>
     FreeGroup.induction_on x (by rw [one_bind, map_one]) (fun x => by rw [pure_bind, map_pure])
       (fun x ih => by rw [inv_bind, map_inv, ih]) fun x y ihx ihy => by
       rw [mul_bind, map_mul, ihx, ihy])

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -624,7 +624,7 @@ theorem Red.invRev {L₁ L₂ : List (α × Bool)} (h : Red L₁ L₂) : Red (in
 
 @[to_additive (attr := simp)]
 theorem Red.step_invRev_iff :
-  Red.Step (FreeGroup.invRev L₁) (FreeGroup.invRev L₂) ↔ Red.Step L₁ L₂ :=
+    Red.Step (FreeGroup.invRev L₁) (FreeGroup.invRev L₂) ↔ Red.Step L₁ L₂ :=
   ⟨fun h => by simpa only [invRev_invRev] using h.invRev, fun h => h.invRev⟩
 #align free_group.red.step_inv_rev_iff FreeGroup.Red.step_invRev_iff
 #align free_add_group.red.step_neg_rev_iff FreeAddGroup.Red.step_negRev_iff
@@ -735,7 +735,7 @@ theorem lift.of {x} : lift f (of x) = f x :=
 
 @[to_additive]
 theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (FreeGroup.of x) = f x) {x} :
-  g x = FreeGroup.lift f x :=
+    g x = FreeGroup.lift f x :=
   FunLike.congr_fun (lift.symm_apply_eq.mp (funext hg : g ∘ FreeGroup.of = f)) x
 #align free_group.lift.unique FreeGroup.lift.unique
 #align free_add_group.lift.unique FreeAddGroup.lift.unique
@@ -814,7 +814,7 @@ theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x :=
 
 @[to_additive]
 theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) :
-  map g (map f x) = map (g ∘ f) x := by
+    map g (map f x) = map (g ∘ f) x := by
   rcases x with ⟨L⟩; simp [(· ∘ ·)]
 #align free_group.map.comp FreeGroup.map.comp
 #align free_add_group.map.comp FreeAddGroup.map.comp

@@ -1219,10 +1219,10 @@ theorem reduce.eq_of_red (H : Red L₁ L₂) : reduce L₁ = reduce L₂ :=
 #align free_group.reduce.eq_of_red FreeGroup.reduce.eq_of_red
 #align free_add_group.reduce.eq_of_red FreeAddGroup.reduce.eq_of_red
 
-alias reduce.eq_of_red ← red.reduce_eq
+alias red.reduce_eq := reduce.eq_of_red
 #align free_group.red.reduce_eq FreeGroup.red.reduce_eq
 
-alias FreeAddGroup.reduce.eq_of_red ← freeAddGroup.red.reduce_eq
+alias freeAddGroup.red.reduce_eq := FreeAddGroup.reduce.eq_of_red
 #align free_group.free_add_group.red.reduce_eq FreeGroup.freeAddGroup.red.reduce_eq
 
 @[to_additive]

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

This has nice performance benefits.

@@ -745,7 +745,7 @@ theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (FreeGroup.of x) =
 See note [partially-applied ext lemmas]. -/
 @[to_additive (attr := ext) "Two homomorphisms out of a free additive group are equal if they are
   equal on generators. See note [partially-applied ext lemmas]."]
-theorem ext_hom {G : Type _} [Group G] (f g : FreeGroup α →* G) (h : ∀ a, f (of a) = g (of a)) :
+theorem ext_hom {G : Type*} [Group G] (f g : FreeGroup α →* G) (h : ∀ a, f (of a) = g (of a)) :
     f = g :=
   lift.symm.injective <| funext h
 #align free_group.ext_hom FreeGroup.ext_hom

• depends on: #5966

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

@@ -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_group
-! leanprover-community/mathlib commit f93c11933efbc3c2f0299e47b8ff83e9b539cbf6
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Fintype.Basic
 import Mathlib.Data.List.Sublists
 import Mathlib.Data.List.Basic
 import Mathlib.GroupTheory.Subgroup.Basic
 
+#align_import group_theory.free_group from "leanprover-community/mathlib"@"f93c11933efbc3c2f0299e47b8ff83e9b539cbf6"
+
 /-!
 # Free groups
 

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -1189,7 +1189,7 @@ theorem reduce.not {p : Prop} : ∀ {L₁ L₂ L₃ : List (α × Bool)} {x : α
 /-- The second theorem that characterises the function `reduce`: the maximal reduction of a word
 only reduces to itself. -/
 @[to_additive "The second theorem that characterises the function `reduce`: the maximal reduction of
-  a word  only reduces to itself."]
+  a word only reduces to itself."]
 theorem reduce.min (H : Red (reduce L₁) L₂) : reduce L₁ = L₂ := by
   induction' H with L1 L' L2 H1 H2 ih
   · rfl

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

@@ -201,13 +201,13 @@ theorem Step.diamond_aux :
     ∀ {L₁ L₂ L₃ L₄ : List (α × Bool)} {x1 b1 x2 b2},
       L₁ ++ (x1, b1) :: (x1, !b1) :: L₂ = L₃ ++ (x2, b2) :: (x2, !b2) :: L₄ →
         L₁ ++ L₂ = L₃ ++ L₄ ∨ ∃ L₅, Red.Step (L₁ ++ L₂) L₅ ∧ Red.Step (L₃ ++ L₄) L₅
-  | [], _, [], _, _, _, _, _, H => by injections ; subst_vars ; simp
-  | [], _, [(x3, b3)], _, _, _, _, _, H => by injections ; subst_vars ; simp
-  | [(x3, b3)], _, [], _, _, _, _, _, H => by injections ; subst_vars ; simp
+  | [], _, [], _, _, _, _, _, H => by injections; subst_vars; simp
+  | [], _, [(x3, b3)], _, _, _, _, _, H => by injections; subst_vars; simp
+  | [(x3, b3)], _, [], _, _, _, _, _, H => by injections; subst_vars; simp
   | [], _, (x3, b3) :: (x4, b4) :: tl, _, _, _, _, _, H => by
-    injections ; subst_vars ; simp ; right ; exact ⟨_, Red.Step.not, Red.Step.cons_not⟩
+    injections; subst_vars; simp; right; exact ⟨_, Red.Step.not, Red.Step.cons_not⟩
   | (x3, b3) :: (x4, b4) :: tl, _, [], _, _, _, _, _, H => by
-    injections ; subst_vars ; simp ; right ; exact ⟨_, Red.Step.cons_not, Red.Step.not⟩
+    injections; subst_vars; simp; right; exact ⟨_, Red.Step.cons_not, Red.Step.not⟩
   | (x3, b3) :: tl, _, (x4, b4) :: tl2, _, _, _, _, _, H =>
     let ⟨H1, H2⟩ := List.cons.inj H
     match Step.diamond_aux H2 with
@@ -673,7 +673,7 @@ theorem Red.exact : mk L₁ = mk L₂ ↔ Join Red L₁ L₂ :=
 @[to_additive "The canonical map from the type to the additive free group is an injection."]
 theorem of_injective : Function.Injective (@of α) := fun _ _ H => by
   let ⟨L₁, hx, hy⟩ := Red.exact.1 H
-  simp [Red.singleton_iff] at hx hy ; aesop
+  simp [Red.singleton_iff] at hx hy; aesop
 #align free_group.of_injective FreeGroup.of_injective
 #align free_add_group.of_injective FreeAddGroup.of_injective
 
@@ -791,7 +791,7 @@ variable {β : Type v} (f : α → β) {x y : FreeGroup α}
   the additive free group over `α` to the additive free group over `β`."]
 def map : FreeGroup α →* FreeGroup β :=
   MonoidHom.mk'
-    (Quot.map (List.map fun x => (f x.1, x.2)) fun L₁ L₂ H => by cases H ; simp)
+    (Quot.map (List.map fun x => (f x.1, x.2)) fun L₁ L₂ H => by cases H; simp)
     (by rintro ⟨L₁⟩ ⟨L₂⟩; simp)
 #align free_group.map FreeGroup.map
 #align free_add_group.map FreeAddGroup.map

Changes are of the form

• some_tactic at h⊢ -> some_tactic at h ⊢
• some_tactic at h -> some_tactic at h

@@ -765,8 +765,8 @@ theorem lift.range_le {s : Subgroup β} (H : Set.range f ⊆ s) : (lift f).range
   rintro _ ⟨⟨L⟩, rfl⟩;
     exact
       List.recOn L s.one_mem fun ⟨x, b⟩ tl ih =>
-        Bool.recOn b (by simp at ih⊢; exact s.mul_mem (s.inv_mem <| H ⟨x, rfl⟩) ih)
-          (by simp at ih⊢; exact s.mul_mem (H ⟨x, rfl⟩) ih)
+        Bool.recOn b (by simp at ih ⊢; exact s.mul_mem (s.inv_mem <| H ⟨x, rfl⟩) ih)
+          (by simp at ih ⊢; exact s.mul_mem (H ⟨x, rfl⟩) ih)
 #align free_group.lift.range_le FreeGroup.lift.range_le
 #align free_add_group.lift.range_le FreeAddGroup.lift.range_le
 
@@ -998,7 +998,7 @@ def freeGroupUnitEquivInt : FreeGroup Unit ≃ ℤ
     exact List.recOn L
      (by rfl)
      (fun ⟨⟨⟩, b⟩ tl ih => by
-        cases b <;> simp [zpow_add] at ih⊢ <;> rw [ih] <;> rfl)
+        cases b <;> simp [zpow_add] at ih ⊢ <;> rw [ih] <;> rfl)
   right_inv x :=
     Int.induction_on x (by simp)
       (fun i ih => by

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -91,13 +91,13 @@ def Red : List (α × Bool) → List (α × Bool) → Prop :=
 #align free_group.red FreeGroup.Red
 #align free_add_group.red FreeAddGroup.Red
 
-@[to_additive (attr:=refl)]
+@[to_additive (attr := refl)]
 theorem Red.refl : Red L L :=
   ReflTransGen.refl
 #align free_group.red.refl FreeGroup.Red.refl
 #align free_add_group.red.refl FreeAddGroup.Red.refl
 
-@[to_additive (attr:=trans)]
+@[to_additive (attr := trans)]
 theorem Red.trans : Red L₁ L₂ → Red L₂ L₃ → Red L₁ L₃ :=
   ReflTransGen.trans
 #align free_group.red.trans FreeGroup.Red.trans
@@ -114,19 +114,19 @@ theorem Step.length : ∀ {L₁ L₂ : List (α × Bool)}, Step L₁ L₂ → L
 #align free_group.red.step.length FreeGroup.Red.Step.length
 #align free_add_group.red.step.length FreeAddGroup.Red.Step.length
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem Step.not_rev {x b} : Step (L₁ ++ (x, !b) :: (x, b) :: L₂) (L₁ ++ L₂) := by
   cases b <;> exact Step.not
 #align free_group.red.step.bnot_rev FreeGroup.Red.Step.not_rev
 #align free_add_group.red.step.bnot_rev FreeAddGroup.Red.Step.not_rev
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem Step.cons_not {x b} : Red.Step ((x, b) :: (x, !b) :: L) L :=
   @Step.not _ [] _ _ _
 #align free_group.red.step.cons_bnot FreeGroup.Red.Step.cons_not
 #align free_add_group.red.step.cons_bnot FreeAddGroup.Red.Step.cons_not
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem Step.cons_not_rev {x b} : Red.Step ((x, !b) :: (x, b) :: L) L :=
   @Red.Step.not_rev _ [] _ _ _
 #align free_group.red.step.cons_bnot_rev FreeGroup.Red.Step.cons_not_rev
@@ -493,27 +493,27 @@ def mk (L : List (α × Bool)) : FreeGroup α :=
 #align free_group.mk FreeGroup.mk
 #align free_add_group.mk FreeAddGroup.mk
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem quot_mk_eq_mk : Quot.mk Red.Step L = mk L :=
   rfl
 #align free_group.quot_mk_eq_mk FreeGroup.quot_mk_eq_mk
 #align free_add_group.quot_mk_eq_mk FreeAddGroup.quot_mk_eq_mk
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem quot_lift_mk (β : Type v) (f : List (α × Bool) → β)
     (H : ∀ L₁ L₂, Red.Step L₁ L₂ → f L₁ = f L₂) : Quot.lift f H (mk L) = f L :=
   rfl
 #align free_group.quot_lift_mk FreeGroup.quot_lift_mk
 #align free_add_group.quot_lift_mk FreeAddGroup.quot_lift_mk
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem quot_liftOn_mk (β : Type v) (f : List (α × Bool) → β)
     (H : ∀ L₁ L₂, Red.Step L₁ L₂ → f L₁ = f L₂) : Quot.liftOn (mk L) f H = f L :=
   rfl
 #align free_group.quot_lift_on_mk FreeGroup.quot_liftOn_mk
 #align free_add_group.quot_lift_on_mk FreeAddGroup.quot_liftOn_mk
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem quot_map_mk (β : Type v) (f : List (α × Bool) → List (β × Bool))
     (H : (Red.Step ⇒ Red.Step) f f) : Quot.map f H (mk L) = mk (f L) :=
   rfl
@@ -543,7 +543,7 @@ instance : Mul (FreeGroup α) :=
           Quot.sound <| Red.Step.append_left H)
       fun _L₁ _L₂ H => Quot.inductionOn y fun _L₃ => Quot.sound <| Red.Step.append_right H⟩
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem mul_mk : mk L₁ * mk L₂ = mk (L₁ ++ L₂) :=
   rfl
 #align free_group.mul_mk FreeGroup.mul_mk
@@ -557,18 +557,18 @@ def invRev (w : List (α × Bool)) : List (α × Bool) :=
 #align free_group.inv_rev FreeGroup.invRev
 #align free_add_group.neg_rev FreeAddGroup.negRev
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem invRev_length : (invRev L₁).length = L₁.length := by simp [invRev]
 #align free_group.inv_rev_length FreeGroup.invRev_length
 #align free_add_group.neg_rev_length FreeAddGroup.negRev_length
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem invRev_invRev : invRev (invRev L₁) = L₁ :=
   by simp [invRev, List.map_reverse, (· ∘ ·)]
 #align free_group.inv_rev_inv_rev FreeGroup.invRev_invRev
 #align free_add_group.neg_rev_neg_rev FreeAddGroup.negRev_negRev
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem invRev_empty : invRev ([] : List (α × Bool)) = [] :=
   rfl
 #align free_group.inv_rev_empty FreeGroup.invRev_empty
@@ -605,7 +605,7 @@ instance : Inv (FreeGroup α) :=
         cases h
         simp [invRev])⟩
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem inv_mk : (mk L)⁻¹ = mk (invRev L) :=
   rfl
 #align free_group.inv_mk FreeGroup.inv_mk
@@ -625,14 +625,14 @@ theorem Red.invRev {L₁ L₂ : List (α × Bool)} (h : Red L₁ L₂) : Red (in
 #align free_group.red.inv_rev FreeGroup.Red.invRev
 #align free_add_group.red.neg_rev FreeAddGroup.Red.negRev
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem Red.step_invRev_iff :
   Red.Step (FreeGroup.invRev L₁) (FreeGroup.invRev L₂) ↔ Red.Step L₁ L₂ :=
   ⟨fun h => by simpa only [invRev_invRev] using h.invRev, fun h => h.invRev⟩
 #align free_group.red.step_inv_rev_iff FreeGroup.Red.step_invRev_iff
 #align free_add_group.red.step_neg_rev_iff FreeAddGroup.Red.step_negRev_iff
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem red_invRev_iff : Red (invRev L₁) (invRev L₂) ↔ Red L₁ L₂ :=
   ⟨fun h => by simpa only [invRev_invRev] using h.invRev, fun h => h.invRev⟩
 #align free_group.red_inv_rev_iff FreeGroup.red_invRev_iff
@@ -724,13 +724,13 @@ def lift : (α → β) ≃ (FreeGroup α →* β) where
 
 variable {f}
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem lift.mk : lift f (mk L) = List.prod (L.map fun x => cond x.2 (f x.1) (f x.1)⁻¹) :=
   rfl
 #align free_group.lift.mk FreeGroup.lift.mk
 #align free_add_group.lift.mk FreeAddGroup.lift.mk
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem lift.of {x} : lift f (of x) = f x :=
   one_mul _
 #align free_group.lift.of FreeGroup.lift.of
@@ -746,7 +746,7 @@ theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (FreeGroup.of x) =
 /-- Two homomorphisms out of a free group are equal if they are equal on generators.
 
 See note [partially-applied ext lemmas]. -/
-@[ to_additive (attr:=ext) "Two homomorphisms out of a free additive group are equal if they are
+@[to_additive (attr := ext) "Two homomorphisms out of a free additive group are equal if they are
   equal on generators. See note [partially-applied ext lemmas]."]
 theorem ext_hom {G : Type _} [Group G] (f g : FreeGroup α →* G) (h : ∀ a, f (of a) = g (of a)) :
     f = g :=
@@ -798,18 +798,18 @@ def map : FreeGroup α →* FreeGroup β :=
 
 variable {f}
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem map.mk : map f (mk L) = mk (L.map fun x => (f x.1, x.2)) :=
   rfl
 #align free_group.map.mk FreeGroup.map.mk
 #align free_add_group.map.mk FreeAddGroup.map.mk
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem map.id (x : FreeGroup α) : map id x = x := by rcases x with ⟨L⟩; simp [List.map_id']
 #align free_group.map.id FreeGroup.map.id
 #align free_add_group.map.id FreeAddGroup.map.id
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x :=
   map.id x
 #align free_group.map.id' FreeGroup.map.id'
@@ -822,7 +822,7 @@ theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) :
 #align free_group.map.comp FreeGroup.map.comp
 #align free_add_group.map.comp FreeAddGroup.map.comp
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem map.of {x} : map f (of x) = of (f x) :=
   rfl
 #align free_group.map.of FreeGroup.map.of
@@ -867,13 +867,13 @@ def freeGroupCongr {α β} (e : α ≃ β) : FreeGroup α ≃* FreeGroup β wher
 #align free_group.free_group_congr_apply FreeGroup.freeGroupCongr_apply
 #align free_add_group.free_add_group_congr_apply FreeAddGroup.freeAddGroupCongr_apply
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem freeGroupCongr_refl : freeGroupCongr (Equiv.refl α) = MulEquiv.refl _ :=
   MulEquiv.ext map.id
 #align free_group.free_group_congr_refl FreeGroup.freeGroupCongr_refl
 #align free_add_group.free_add_group_congr_refl FreeAddGroup.freeAddGroupCongr_refl
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem freeGroupCongr_symm {α β} (e : α ≃ β) : (freeGroupCongr e).symm = freeGroupCongr e.symm :=
   rfl
 #align free_group.free_group_congr_symm FreeGroup.freeGroupCongr_symm
@@ -903,13 +903,13 @@ def prod : FreeGroup α →* α :=
 
 variable {x y}
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem prod_mk : prod (mk L) = List.prod (L.map fun x => cond x.2 x.1 x.1⁻¹) :=
   rfl
 #align free_group.prod_mk FreeGroup.prod_mk
 #align free_add_group.sum_mk FreeAddGroup.sum_mk
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem prod.of {x : α} : prod (of x) = x :=
   lift.of
 #align free_group.prod.of FreeGroup.prod.of
@@ -1035,19 +1035,19 @@ theorem map_pure (f : α → β) (x : α) : f <$> (pure x : FreeGroup α) = pure
 #align free_group.map_pure FreeGroup.map_pure
 #align free_add_group.map_pure FreeAddGroup.map_pure
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem map_one (f : α → β) : f <$> (1 : FreeGroup α) = 1 :=
   (map f).map_one
 #align free_group.map_one FreeGroup.map_one
 #align free_add_group.map_zero FreeAddGroup.map_zero
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem map_mul (f : α → β) (x y : FreeGroup α) : f <$> (x * y) = f <$> x * f <$> y :=
   (map f).map_mul x y
 #align free_group.map_mul FreeGroup.map_mul
 #align free_add_group.map_add FreeAddGroup.map_add
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem map_inv (f : α → β) (x : FreeGroup α) : f <$> x⁻¹ = (f <$> x)⁻¹ :=
   (map f).map_inv x
 #align free_group.map_inv FreeGroup.map_inv
@@ -1060,19 +1060,19 @@ theorem pure_bind (f : α → FreeGroup β) (x) : pure x >>= f = f x :=
 #align free_group.pure_bind FreeGroup.pure_bind
 #align free_add_group.pure_bind FreeAddGroup.pure_bind
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem one_bind (f : α → FreeGroup β) : 1 >>= f = 1 :=
   (lift f).map_one
 #align free_group.one_bind FreeGroup.one_bind
 #align free_add_group.zero_bind FreeAddGroup.zero_bind
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem mul_bind (f : α → FreeGroup β) (x y : FreeGroup α) : x * y >>= f = (x >>= f) * (y >>= f) :=
   (lift f).map_mul _ _
 #align free_group.mul_bind FreeGroup.mul_bind
 #align free_add_group.add_bind FreeAddGroup.add_bind
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem inv_bind (f : α → FreeGroup β) (x : FreeGroup α) : x⁻¹ >>= f = (x >>= f)⁻¹ :=
   (lift f).map_inv _
 #align free_group.inv_bind FreeGroup.inv_bind
@@ -1111,7 +1111,7 @@ def reduce : (L : List (α × Bool)) -> List (α × Bool) :=
 #align free_group.reduce FreeGroup.reduce
 #align free_add_group.reduce FreeAddGroup.reduce
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem reduce.cons (x) :
     reduce (x :: L) =
       List.casesOn (reduce L) [x] fun hd tl =>
@@ -1151,7 +1151,7 @@ theorem reduce.red : Red L (reduce L) := by
 
 -- porting notes: deleted mathport junk and manually formatted below.
 @[to_additive]
-theorem reduce.not {p : Prop}: ∀ {L₁ L₂ L₃: List (α × Bool)} {x : α} {b},
+theorem reduce.not {p : Prop} : ∀ {L₁ L₂ L₃ : List (α × Bool)} {x : α} {b},
   ((reduce L₁) = L₂ ++ ((x,b)::(x ,!b)::L₃)) → p
   | [], L2 ,L3, _, _ => fun h => by cases L2 <;> injections
   | (x, b)::L1, L2, L3, x', b' => by
@@ -1200,7 +1200,7 @@ theorem reduce.min (H : Red (reduce L₁) L₂) : reduce L₁ = L₂ := by
 
 /-- `reduce` is idempotent, i.e. the maximal reduction of the maximal reduction of a word is the
   maximal reduction of the word. -/
-@[to_additive (attr:=simp) "`reduce` is idempotent, i.e. the maximal reduction of the maximal
+@[to_additive (attr := simp) "`reduce` is idempotent, i.e. the maximal reduction of the maximal
   reduction of a word is the maximal reduction of the word."]
 theorem reduce.idem : reduce (reduce L) = reduce L :=
   Eq.symm <| reduce.min reduce.red
@@ -1297,32 +1297,32 @@ theorem toWord_injective : Function.Injective (toWord : FreeGroup α → List (
 #align free_group.to_word_injective FreeGroup.toWord_injective
 #align free_add_group.to_word_injective FreeAddGroup.toWord_injective
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem toWord_inj {x y : FreeGroup α} : toWord x = toWord y ↔ x = y :=
   toWord_injective.eq_iff
 #align free_group.to_word_inj FreeGroup.toWord_inj
 #align free_add_group.to_word_inj FreeAddGroup.toWord_inj
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem toWord_mk : (mk L₁).toWord = reduce L₁ :=
   rfl
 #align free_group.to_word_mk FreeGroup.toWord_mk
 #align free_add_group.to_word_mk FreeAddGroup.toWord_mk
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem reduce_toWord : ∀ x : FreeGroup α, reduce (toWord x) = toWord x := by
   rintro ⟨L⟩
   exact reduce.idem
 #align free_group.reduce_to_word FreeGroup.reduce_toWord
 #align free_add_group.reduce_to_word FreeAddGroup.reduce_toWord
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem toWord_one : (1 : FreeGroup α).toWord = [] :=
   rfl
 #align free_group.to_word_one FreeGroup.toWord_one
 #align free_add_group.to_word_zero FreeAddGroup.toWord_zero
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem toWord_eq_nil_iff {x : FreeGroup α} : x.toWord = [] ↔ x = 1 :=
   toWord_injective.eq_iff' toWord_one
 #align free_group.to_word_eq_nil_iff FreeGroup.toWord_eq_nil_iff
@@ -1406,19 +1406,19 @@ def norm (x : FreeGroup α) : ℕ :=
 #align free_group.norm FreeGroup.norm
 #align free_add_group.norm FreeAddGroup.norm
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem norm_inv_eq {x : FreeGroup α} : norm x⁻¹ = norm x := by
   simp only [norm, toWord_inv, invRev_length]
 #align free_group.norm_inv_eq FreeGroup.norm_inv_eq
 #align free_add_group.norm_neg_eq FreeAddGroup.norm_neg_eq
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem norm_eq_zero {x : FreeGroup α} : norm x = 0 ↔ x = 1 := by
   simp only [norm, List.length_eq_zero, toWord_eq_nil_iff]
 #align free_group.norm_eq_zero FreeGroup.norm_eq_zero
 #align free_add_group.norm_eq_zero FreeAddGroup.norm_eq_zero
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem norm_one : norm (1 : FreeGroup α) = 0 :=
   rfl
 #align free_group.norm_one FreeGroup.norm_one

These are all doc fixes

@@ -62,7 +62,7 @@ variable {α : Type u}
 attribute [local simp] List.append_eq_has_append
 
 -- porting notes: to_additive.map_namespace is not supported yet
--- worked aruond it by putting a few extra manual mappings (but not too many all in all)
+-- worked around it by putting a few extra manual mappings (but not too many all in all)
 -- run_cmd to_additive.map_namespace `FreeGroup `FreeAddGroup
 
 /-- Reduction step for the additive free group relation: `w + x + (-x) + v ~> w + v` -/

Tracking down porting notes mentioning lean4#2210.

Some removals of nolint simpNF may need to be reverted; let's see what CI says.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -1166,8 +1166,7 @@ theorem reduce.not {p : Prop}: ∀ {L₁ L₂ L₃: List (α × Bool)} {x : α}
         rw [add_comm, add_assoc, add_assoc, add_comm, <-add_assoc] at this
         simp [Nat.one_eq_succ_zero, Nat.succ_add] at this
         -- Porting note: needed to add this step in #3414.
-        -- However it is not caused by lean4#2210 (reenableeta)
-        -- but rather by https://github.com/leanprover/lean4/pull/2146.
+        -- This is caused by https://github.com/leanprover/lean4/pull/2146.
         -- Nevertheless the proof could be cleaned up.
         cases this
       | cons hd tail =>

• Run a non-interactive version of fix-comments.py on all files.
• Go through the diff and manually add/discard/edit chunks.

@@ -486,7 +486,7 @@ namespace FreeGroup
 
 variable {L L₁ L₂ L₃ L₄ : List (α × Bool)}
 
-/-- The canonical map from `list (α × bool)` to the free group on `α`. -/
+/-- The canonical map from `List (α × Bool)` to the free group on `α`. -/
 @[to_additive "The canonical map from `list (α × bool)` to the free additive group on `α`."]
 def mk (L : List (α × Bool)) : FreeGroup α :=
   Quot.mk Red.Step L
@@ -681,7 +681,7 @@ section lift
 
 variable {β : Type v} [Group β] (f : α → β) {x y : FreeGroup α}
 
-/-- Given `f : α → β` with `β` a group, the canonical map `list (α × bool) → β` -/
+/-- Given `f : α → β` with `β` a group, the canonical map `List (α × Bool) → β` -/
 @[to_additive "Given `f : α → β` with `β` an additive group, the canonical map
   `list (α × bool) → β`"]
 def Lift.aux : List (α × Bool) → β := fun L =>

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>

@@ -1165,6 +1165,11 @@ theorem reduce.not {p : Prop}: ∀ {L₁ L₂ L₃: List (α × Bool)} {x : α}
         simp [List.length] at this
         rw [add_comm, add_assoc, add_assoc, add_comm, <-add_assoc] at this
         simp [Nat.one_eq_succ_zero, Nat.succ_add] at this
+        -- Porting note: needed to add this step in #3414.
+        -- However it is not caused by lean4#2210 (reenableeta)
+        -- but rather by https://github.com/leanprover/lean4/pull/2146.
+        -- Nevertheless the proof could be cleaned up.
+        cases this
       | cons hd tail =>
         cases' hd with y c
         dsimp only

This PR fixes two things:

• Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
• All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

@@ -666,7 +666,6 @@ theorem Red.exact : mk L₁ = mk L₂ ↔ Join Red L₁ L₂ :=
   calc
     mk L₁ = mk L₂ ↔ EqvGen Red.Step L₁ L₂ := Iff.intro (Quot.exact _) Quot.EqvGen_sound
     _ ↔ Join Red L₁ L₂ := eqvGen_step_iff_join_red
-
 #align free_group.red.exact FreeGroup.Red.exact
 #align free_add_group.red.exact FreeAddGroup.Red.exact
 
@@ -1433,7 +1432,6 @@ theorem norm_mul_le (x y : FreeGroup α) : norm (x * y) ≤ norm x + norm y :=
     norm (x * y) = norm (mk (x.toWord ++ y.toWord)) := by rw [← mul_mk, mk_toWord, mk_toWord]
     _ ≤ (x.toWord ++ y.toWord).length := norm_mk_le
     _ = norm x + norm y := List.length_append _ _
-
 #align free_group.norm_mul_le FreeGroup.norm_mul_le
 #align free_add_group.norm_add_le FreeAddGroup.norm_add_le
 

@@ -995,14 +995,19 @@ def freeGroupUnitEquivInt : FreeGroup Unit ≃ ℤ
   invFun x := of () ^ x
   left_inv := by
     rintro ⟨L⟩
-    simp
+    simp only [quot_mk_eq_mk, map.mk, sum_mk, List.map_map]
     exact List.recOn L
      (by rfl)
      (fun ⟨⟨⟩, b⟩ tl ih => by
         cases b <;> simp [zpow_add] at ih⊢ <;> rw [ih] <;> rfl)
   right_inv x :=
-    Int.induction_on x (by simp) (fun i ih => by simp at ih; simp [zpow_add, ih]) fun i ih => by
-      simp at ih; simp [zpow_add, ih, sub_eq_add_neg]
+    Int.induction_on x (by simp)
+      (fun i ih => by
+        simp only [zpow_coe_nat, map_pow, map.of] at ih
+        simp [zpow_add, ih])
+      (fun i ih => by
+        simp only [zpow_neg, zpow_coe_nat, map_inv, map_pow, map.of, sum.map_inv, neg_inj] at ih
+        simp [zpow_add, ih, sub_eq_add_neg])
 #align free_group.free_group_unit_equiv_int FreeGroup.freeGroupUnitEquivInt
 
 section Category

• initialize_simps_projections automatically find coercions if there is a Funlike or SetLike instance defined by one of the projections.
• Some improvements compared to Lean 3:
  • Find coercions even if it is defined by a field of a parent structure
  • Find SetLike coercions

Not yet implemented (and rarely - if ever - used in mathlib3):

• Automatic custom projections for algebraic notation (like +,*,...)

Co-authored-by: Johan Commelin <johan@commelin.net>

@@ -995,7 +995,7 @@ def freeGroupUnitEquivInt : FreeGroup Unit ≃ ℤ
   invFun x := of () ^ x
   left_inv := by
     rintro ⟨L⟩
-    simp [MonoidHom.Simps.apply]
+    simp
     exact List.recOn L
      (by rfl)
      (fun ⟨⟨⟩, b⟩ tl ih => by

@@ -1015,7 +1015,7 @@ instance : Monad FreeGroup.{u} where
   map {_α} {_β} {f} := map f
   bind {_α} {_β} {x} {f} := lift f x
 
-@[elab_as_elim, to_additive]
+@[to_additive (attr := elab_as_elim)]
 protected theorem induction_on {C : FreeGroup α → Prop} (z : FreeGroup α) (C1 : C 1)
     (Cp : ∀ x, C <| pure x) (Ci : ∀ x, C (pure x) → C (pure x)⁻¹)
     (Cm : ∀ x y, C x → C y → C (x * y)) : C z :=

@@ -698,11 +698,10 @@ theorem Red.Step.lift {f : α → β} (H : Red.Step L₁ L₂) : Lift.aux f L₁
 
 /-- If `β` is a group, then any function from `α` to `β` extends uniquely to a group homomorphism
 from the free group over `α` to `β` -/
-@[to_additive "If `β` is an additive group, then any function from `α` to `β` extends uniquely to an
-  additive group homomorphism from the free additive group over `α` to `β`",
-  simps symm_apply]
-def lift : (α → β) ≃ (FreeGroup α →* β)
-    where
+@[to_additive (attr := simps symm_apply)
+  "If `β` is an additive group, then any function from `α` to `β` extends uniquely to an
+  additive group homomorphism from the free additive group over `α` to `β`"]
+def lift : (α → β) ≃ (FreeGroup α →* β) where
   toFun f :=
     MonoidHom.mk' (Quot.lift (Lift.aux f) fun L₁ L₂ => Red.Step.lift) <| by
       rintro ⟨L₁⟩ ⟨L₂⟩; simp [Lift.aux]
@@ -722,6 +721,7 @@ def lift : (α → β) ≃ (FreeGroup α →* β)
 #align free_group.lift FreeGroup.lift
 #align free_add_group.lift FreeAddGroup.lift
 #align free_group.lift_symm_apply FreeGroup.lift_symm_apply
+#align free_add_group.lift_symm_apply FreeAddGroup.lift_symm_apply
 
 variable {f}
 
@@ -855,10 +855,9 @@ theorem map_eq_lift : map f x = lift (of ∘ f) x :=
 The converse can be found in `GroupTheory.FreeAbelianGroupFinsupp`,
 as `Equiv.of_freeGroupEquiv`
  -/
-@[to_additive "Equivalent types give rise to additively equivalent additive free groups.",
-  simps apply]
-def freeGroupCongr {α β} (e : α ≃ β) : FreeGroup α ≃* FreeGroup β
-    where
+@[to_additive (attr := simps apply)
+  "Equivalent types give rise to additively equivalent additive free groups."]
+def freeGroupCongr {α β} (e : α ≃ β) : FreeGroup α ≃* FreeGroup β where
   toFun := map e
   invFun := map e.symm
   left_inv x := by simp [Function.comp, map.comp]
@@ -867,6 +866,7 @@ def freeGroupCongr {α β} (e : α ≃ β) : FreeGroup α ≃* FreeGroup β
 #align free_group.free_group_congr FreeGroup.freeGroupCongr
 #align free_add_group.free_add_group_congr FreeAddGroup.freeAddGroupCongr
 #align free_group.free_group_congr_apply FreeGroup.freeGroupCongr_apply
+#align free_add_group.free_add_group_congr_apply FreeAddGroup.freeAddGroupCongr_apply
 
 @[to_additive (attr:=simp)]
 theorem freeGroupCongr_refl : freeGroupCongr (Equiv.refl α) = MulEquiv.refl _ :=
@@ -1434,4 +1434,4 @@ theorem norm_mul_le (x y : FreeGroup α) : norm (x * y) ≤ norm x + norm y :=
 
 end Metric
 
-end FreeGroup
\ No newline at end of file
+end FreeGroup

This PR is the result of a slight variant on the following "algorithm"

• take all mathlib 3 names, remove _ and make all uppercase letters into lowercase
• take all mathlib 4 names, remove _ and make all uppercase letters into lowercase
• look for matches, and create pairs (original_lean3_name, OriginalLean4Name)
• for pairs that do not have an align statement:
  • use Lean 4 to lookup the file + position of the Lean 4 name
  • add an #align statement just before the next empty line
• manually fix some tiny mistakes (e.g., empty lines in proofs might cause the #align statement to have been inserted too early)

@@ -721,6 +721,7 @@ def lift : (α → β) ≃ (FreeGroup α →* β)
           simpa [Lift.aux] using ih)
 #align free_group.lift FreeGroup.lift
 #align free_add_group.lift FreeAddGroup.lift
+#align free_group.lift_symm_apply FreeGroup.lift_symm_apply
 
 variable {f}
 
@@ -865,6 +866,7 @@ def freeGroupCongr {α β} (e : α ≃ β) : FreeGroup α ≃* FreeGroup β
   map_mul' := MonoidHom.map_mul _
 #align free_group.free_group_congr FreeGroup.freeGroupCongr
 #align free_add_group.free_add_group_congr FreeAddGroup.freeAddGroupCongr
+#align free_group.free_group_congr_apply FreeGroup.freeGroupCongr_apply
 
 @[to_additive (attr:=simp)]
 theorem freeGroupCongr_refl : freeGroupCongr (Equiv.refl α) = MulEquiv.refl _ :=

Co-authored-by: Arien Malec <arien.malec@gmail.com>