algebra.free ⟷ Mathlib.Algebra.Free

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

@@ -3,8 +3,8 @@ Copyright (c) 2019 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
 -/
-import Algebra.Hom.Group
-import Algebra.Hom.Equiv.Basic
+import Algebra.Group.Hom.Defs
+import Algebra.Group.Equiv.Basic
 import Control.Applicative
 import Control.Traversable.Basic
 import Logic.Equiv.Defs

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

@@ -90,7 +90,7 @@ def recOnMul {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (of x))
 #print FreeMagma.hom_ext /-
 @[ext, to_additive]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeMagma α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
-  FunLike.ext _ _ fun x => recOnMul x (congr_fun h) <| by intros; simp only [map_mul, *]
+  DFunLike.ext _ _ fun x => recOnMul x (congr_fun h) <| by intros; simp only [map_mul, *]
 #align free_magma.hom_ext FreeMagma.hom_ext
 #align free_add_magma.hom_ext FreeAddMagma.hom_ext
 -/
@@ -516,7 +516,7 @@ variable {β : Type v} [Semigroup β] (f : α →ₙ* β)
 #print Magma.AssocQuotient.hom_ext /-
 @[ext, to_additive]
 theorem hom_ext {f g : AssocQuotient α →ₙ* β} (h : f.comp of = g.comp of) : f = g :=
-  FunLike.ext _ _ fun x => AssocQuotient.induction_on x <| FunLike.congr_fun h
+  DFunLike.ext _ _ fun x => AssocQuotient.induction_on x <| DFunLike.congr_fun h
 #align magma.assoc_quotient.hom_ext Magma.AssocQuotient.hom_ext
 #align add_magma.free_add_semigroup.hom_ext AddMagma.FreeAddSemigroup.hom_ext
 -/
@@ -535,8 +535,8 @@ def lift : (α →ₙ* β) ≃ (AssocQuotient α →ₙ* β)
           rintro a b (⟨c, d, e⟩ | ⟨c, d, e, f⟩) <;> simp only [map_mul, mul_assoc]
       map_mul' := fun x y => Quot.induction_on₂ x y (map_mul f) }
   invFun f := f.comp of
-  left_inv f := FunLike.ext _ _ fun x => rfl
-  right_inv f := hom_ext <| FunLike.ext _ _ fun x => rfl
+  left_inv f := DFunLike.ext _ _ fun x => rfl
+  right_inv f := hom_ext <| DFunLike.ext _ _ fun x => rfl
 #align magma.assoc_quotient.lift Magma.AssocQuotient.lift
 #align add_magma.free_add_semigroup.lift AddMagma.FreeAddSemigroup.lift
 -/
@@ -697,7 +697,7 @@ protected def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (of
 #print FreeSemigroup.hom_ext /-
 @[ext, to_additive]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeSemigroup α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
-  FunLike.ext _ _ fun x =>
+  DFunLike.ext _ _ fun x =>
     FreeSemigroup.recOnMul x (congr_fun h) fun x y hx hy => by simp only [map_mul, *]
 #align free_semigroup.hom_ext FreeSemigroup.hom_ext
 #align free_add_semigroup.hom_ext FreeAddSemigroup.hom_ext
@@ -1015,7 +1015,7 @@ theorem toFreeSemigroup_comp_map (f : α → β) :
 @[to_additive]
 theorem toFreeSemigroup_map (f : α → β) (x : FreeMagma α) :
     (map f x).toFreeSemigroup = FreeSemigroup.map f x.toFreeSemigroup :=
-  FunLike.congr_fun (toFreeSemigroup_comp_map f) x
+  DFunLike.congr_fun (toFreeSemigroup_comp_map f) x
 #align free_magma.to_free_semigroup_map FreeMagma.toFreeSemigroup_map
 -/
 

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

@@ -3,12 +3,12 @@ Copyright (c) 2019 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
 -/
-import Mathbin.Algebra.Hom.Group
-import Mathbin.Algebra.Hom.Equiv.Basic
-import Mathbin.Control.Applicative
-import Mathbin.Control.Traversable.Basic
-import Mathbin.Logic.Equiv.Defs
-import Mathbin.Data.List.Basic
+import Algebra.Hom.Group
+import Algebra.Hom.Equiv.Basic
+import Control.Applicative
+import Control.Traversable.Basic
+import Logic.Equiv.Defs
+import Data.List.Basic
 
 #align_import algebra.free from "leanprover-community/mathlib"@"68d1483e8a718ec63219f0e227ca3f0140361086"
 

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

@@ -2,11 +2,6 @@
 Copyright (c) 2019 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 algebra.free
-! leanprover-community/mathlib commit 68d1483e8a718ec63219f0e227ca3f0140361086
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Hom.Group
 import Mathbin.Algebra.Hom.Equiv.Basic
@@ -15,6 +10,8 @@ import Mathbin.Control.Traversable.Basic
 import Mathbin.Logic.Equiv.Defs
 import Mathbin.Data.List.Basic
 
+#align_import algebra.free from "leanprover-community/mathlib"@"68d1483e8a718ec63219f0e227ca3f0140361086"
+
 /-!
 # Free constructions
 

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

@@ -360,7 +360,7 @@ theorem mul_map_seq (x y : FreeMagma α) :
 -/
 
 @[to_additive]
-instance : IsLawfulTraversable FreeMagma.{u} :=
+instance : LawfulTraversable FreeMagma.{u} :=
   {
     FreeMagma.lawfulMonad with
     id_traverse := fun α x =>
@@ -954,7 +954,7 @@ theorem mul_map_seq (x y : FreeSemigroup α) :
 -/
 
 @[to_additive]
-instance : IsLawfulTraversable FreeSemigroup.{u} :=
+instance : LawfulTraversable FreeSemigroup.{u} :=
   {
     FreeSemigroup.lawfulMonad with
     id_traverse := fun α x =>

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

@@ -141,17 +141,21 @@ def lift : (α → β) ≃ (FreeMagma α →ₙ* β)
 #align free_add_magma.lift FreeAddMagma.lift
 -/
 
+#print FreeMagma.lift_of /-
 @[simp, to_additive]
 theorem lift_of (x) : lift f (of x) = f x :=
   rfl
 #align free_magma.lift_of FreeMagma.lift_of
 #align free_add_magma.lift_of FreeAddMagma.lift_of
+-/
 
+#print FreeMagma.lift_comp_of /-
 @[simp, to_additive]
 theorem lift_comp_of : lift f ∘ of = f :=
   rfl
 #align free_magma.lift_comp_of FreeMagma.lift_comp_of
 #align free_add_magma.lift_comp_of FreeAddMagma.lift_comp_of
+-/
 
 #print FreeMagma.lift_comp_of' /-
 @[simp, to_additive]
@@ -197,6 +201,7 @@ instance : Monad FreeMagma where
   pure _ := of
   bind _ _ x f := lift f x
 
+#print FreeMagma.recOnPure /-
 /-- Recursor on `free_magma` using `pure` instead of `of`. -/
 @[elab_as_elim, to_additive "Recursor on `free_add_magma` using `pure` instead of `of`."]
 protected def recOnPure {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (pure x))
@@ -204,43 +209,56 @@ protected def recOnPure {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (pure
   FreeMagma.recOnMul x ih1 ih2
 #align free_magma.rec_on_pure FreeMagma.recOnPure
 #align free_add_magma.rec_on_pure FreeAddMagma.recOnPure
+-/
 
+#print FreeMagma.map_pure /-
 @[simp, to_additive]
 theorem map_pure (f : α → β) (x) : (f <$> pure x : FreeMagma β) = pure (f x) :=
   rfl
 #align free_magma.map_pure FreeMagma.map_pure
 #align free_add_magma.map_pure FreeAddMagma.map_pure
+-/
 
+#print FreeMagma.map_mul' /-
 @[simp, to_additive]
 theorem map_mul' (f : α → β) (x y : FreeMagma α) : f <$> (x * y) = f <$> x * f <$> y :=
   rfl
 #align free_magma.map_mul' FreeMagma.map_mul'
 #align free_add_magma.map_add' FreeAddMagma.map_add'
+-/
 
+#print FreeMagma.pure_bind /-
 @[simp, to_additive]
 theorem pure_bind (f : α → FreeMagma β) (x) : pure x >>= f = f x :=
   rfl
 #align free_magma.pure_bind FreeMagma.pure_bind
 #align free_add_magma.pure_bind FreeAddMagma.pure_bind
+-/
 
+#print FreeMagma.mul_bind /-
 @[simp, to_additive]
 theorem mul_bind (f : α → FreeMagma β) (x y : FreeMagma α) : x * y >>= f = (x >>= f) * (y >>= f) :=
   rfl
 #align free_magma.mul_bind FreeMagma.mul_bind
 #align free_add_magma.add_bind FreeAddMagma.add_bind
+-/
 
+#print FreeMagma.pure_seq /-
 @[simp, to_additive]
 theorem pure_seq {α β : Type u} {f : α → β} {x : FreeMagma α} : pure f <*> x = f <$> x :=
   rfl
 #align free_magma.pure_seq FreeMagma.pure_seq
 #align free_add_magma.pure_seq FreeAddMagma.pure_seq
+-/
 
+#print FreeMagma.mul_seq /-
 @[simp, to_additive]
 theorem mul_seq {α β : Type u} {f g : FreeMagma (α → β)} {x : FreeMagma α} :
     f * g <*> x = (f <*> x) * (g <*> x) :=
   rfl
 #align free_magma.mul_seq FreeMagma.mul_seq
 #align free_add_magma.add_seq FreeAddMagma.add_seq
+-/
 
 @[to_additive]
 instance : LawfulMonad FreeMagma.{u}
@@ -289,25 +307,32 @@ instance : Traversable FreeMagma :=
 
 variable {m : Type u → Type u} [Applicative m] (F : α → m β)
 
+#print FreeMagma.traverse_pure /-
 @[simp, to_additive]
 theorem traverse_pure (x) : traverse F (pure x : FreeMagma α) = pure <$> F x :=
   rfl
 #align free_magma.traverse_pure FreeMagma.traverse_pure
 #align free_add_magma.traverse_pure FreeAddMagma.traverse_pure
+-/
 
+#print FreeMagma.traverse_pure' /-
 @[simp, to_additive]
 theorem traverse_pure' : traverse F ∘ pure = fun x => (pure <$> F x : m (FreeMagma β)) :=
   rfl
 #align free_magma.traverse_pure' FreeMagma.traverse_pure'
 #align free_add_magma.traverse_pure' FreeAddMagma.traverse_pure'
+-/
 
+#print FreeMagma.traverse_mul /-
 @[simp, to_additive]
 theorem traverse_mul (x y : FreeMagma α) :
     traverse F (x * y) = (· * ·) <$> traverse F x <*> traverse F y :=
   rfl
 #align free_magma.traverse_mul FreeMagma.traverse_mul
 #align free_add_magma.traverse_add FreeAddMagma.traverse_add
+-/
 
+#print FreeMagma.traverse_mul' /-
 @[simp, to_additive]
 theorem traverse_mul' :
     Function.comp (traverse F) ∘ @Mul.mul (FreeMagma α) _ = fun x y =>
@@ -315,6 +340,7 @@ theorem traverse_mul' :
   rfl
 #align free_magma.traverse_mul' FreeMagma.traverse_mul'
 #align free_add_magma.traverse_add' FreeAddMagma.traverse_add'
+-/
 
 #print FreeMagma.traverse_eq /-
 @[simp, to_additive]
@@ -324,12 +350,14 @@ theorem traverse_eq (x) : FreeMagma.traverse F x = traverse F x :=
 #align free_add_magma.traverse_eq FreeAddMagma.traverse_eq
 -/
 
+#print FreeMagma.mul_map_seq /-
 @[simp, to_additive]
 theorem mul_map_seq (x y : FreeMagma α) :
     ((· * ·) <$> x <*> y : id (FreeMagma α)) = (x * y : FreeMagma α) :=
   rfl
 #align free_magma.mul_map_seq FreeMagma.mul_map_seq
 #align free_add_magma.add_map_seq FreeAddMagma.add_map_seq
+-/
 
 @[to_additive]
 instance : IsLawfulTraversable FreeMagma.{u} :=
@@ -355,17 +383,21 @@ end Category
 
 end FreeMagma
 
+#print FreeMagma.repr /-
 /-- Representation of an element of a free magma. -/
 protected def FreeMagma.repr {α : Type u} [Repr α] : FreeMagma α → String
   | FreeMagma.of x => repr x
   | x * y => "( " ++ x.repr ++ " * " ++ y.repr ++ " )"
 #align free_magma.repr FreeMagma.repr
+-/
 
+#print FreeAddMagma.repr /-
 /-- Representation of an element of a free additive magma. -/
 protected def FreeAddMagma.repr {α : Type u} [Repr α] : FreeAddMagma α → String
   | FreeAddMagma.of x => repr x
   | x + y => "( " ++ x.repr ++ " + " ++ y.repr ++ " )"
 #align free_add_magma.repr FreeAddMagma.repr
+-/
 
 attribute [to_additive FreeAddMagma.repr] FreeMagma.repr
 
@@ -458,12 +490,14 @@ instance : Semigroup (AssocQuotient α)
           quot_mk_assoc_left, ← quot_mk_assoc c d, ← quot_mk_assoc c d, quot_mk_assoc_left]
   mul_assoc x y z := Quot.induction_on₃ x y z fun p q r => quot_mk_assoc p q r
 
+#print Magma.AssocQuotient.of /-
 /-- Embedding from magma to its free semigroup. -/
 @[to_additive "Embedding from additive magma to its free additive semigroup."]
 def of : α →ₙ* AssocQuotient α :=
   ⟨Quot.mk _, fun x y => rfl⟩
 #align magma.assoc_quotient.of Magma.AssocQuotient.of
 #align add_magma.free_add_semigroup.of AddMagma.FreeAddSemigroup.of
+-/
 
 @[to_additive]
 instance [Inhabited α] : Inhabited (AssocQuotient α) :=
@@ -482,12 +516,15 @@ section lift
 
 variable {β : Type v} [Semigroup β] (f : α →ₙ* β)
 
+#print Magma.AssocQuotient.hom_ext /-
 @[ext, to_additive]
 theorem hom_ext {f g : AssocQuotient α →ₙ* β} (h : f.comp of = g.comp of) : f = g :=
   FunLike.ext _ _ fun x => AssocQuotient.induction_on x <| FunLike.congr_fun h
 #align magma.assoc_quotient.hom_ext Magma.AssocQuotient.hom_ext
 #align add_magma.free_add_semigroup.hom_ext AddMagma.FreeAddSemigroup.hom_ext
+-/
 
+#print Magma.AssocQuotient.lift /-
 /-- Lifts a magma homomorphism `α → β` to a semigroup homomorphism `magma.assoc_quotient α → β`
 given a semigroup `β`. -/
 @[to_additive
@@ -505,29 +542,37 @@ def lift : (α →ₙ* β) ≃ (AssocQuotient α →ₙ* β)
   right_inv f := hom_ext <| FunLike.ext _ _ fun x => rfl
 #align magma.assoc_quotient.lift Magma.AssocQuotient.lift
 #align add_magma.free_add_semigroup.lift AddMagma.FreeAddSemigroup.lift
+-/
 
+#print Magma.AssocQuotient.lift_of /-
 @[simp, to_additive]
 theorem lift_of (x : α) : lift f (of x) = f x :=
   rfl
 #align magma.assoc_quotient.lift_of Magma.AssocQuotient.lift_of
 #align add_magma.free_add_semigroup.lift_of AddMagma.FreeAddSemigroup.lift_of
+-/
 
+#print Magma.AssocQuotient.lift_comp_of /-
 @[simp, to_additive]
 theorem lift_comp_of : (lift f).comp of = f :=
   lift.symm_apply_apply f
 #align magma.assoc_quotient.lift_comp_of Magma.AssocQuotient.lift_comp_of
 #align add_magma.free_add_semigroup.lift_comp_of AddMagma.FreeAddSemigroup.lift_comp_of
+-/
 
+#print Magma.AssocQuotient.lift_comp_of' /-
 @[simp, to_additive]
 theorem lift_comp_of' (f : AssocQuotient α →ₙ* β) : lift (f.comp of) = f :=
   lift.apply_symm_apply f
 #align magma.assoc_quotient.lift_comp_of' Magma.AssocQuotient.lift_comp_of'
 #align add_magma.free_add_semigroup.lift_comp_of' AddMagma.FreeAddSemigroup.lift_comp_of'
+-/
 
 end lift
 
 variable {β : Type v} [Mul β] (f : α →ₙ* β)
 
+#print Magma.AssocQuotient.map /-
 /-- From a magma homomorphism `α →ₙ* β` to a semigroup homomorphism
 `magma.assoc_quotient α →ₙ* magma.assoc_quotient β`. -/
 @[to_additive
@@ -536,6 +581,7 @@ def map : AssocQuotient α →ₙ* AssocQuotient β :=
   lift (of.comp f)
 #align magma.assoc_quotient.map Magma.AssocQuotient.map
 #align add_magma.free_add_semigroup.map AddMagma.FreeAddSemigroup.map
+-/
 
 #print Magma.AssocQuotient.map_of /-
 @[simp, to_additive]
@@ -578,23 +624,29 @@ instance : Semigroup (FreeSemigroup α)
   mul L1 L2 := ⟨L1.1, L1.2 ++ L2.1 :: L2.2⟩
   mul_assoc L1 L2 L3 := ext _ _ rfl <| List.append_assoc _ _ _
 
+#print FreeSemigroup.head_mul /-
 @[simp, to_additive]
 theorem head_mul (x y : FreeSemigroup α) : (x * y).1 = x.1 :=
   rfl
 #align free_semigroup.head_mul FreeSemigroup.head_mul
 #align free_add_semigroup.head_add FreeAddSemigroup.head_add
+-/
 
+#print FreeSemigroup.tail_mul /-
 @[simp, to_additive]
 theorem tail_mul (x y : FreeSemigroup α) : (x * y).2 = x.2 ++ y.1 :: y.2 :=
   rfl
 #align free_semigroup.tail_mul FreeSemigroup.tail_mul
 #align free_add_semigroup.tail_add FreeAddSemigroup.tail_add
+-/
 
+#print FreeSemigroup.mk_mul_mk /-
 @[simp, to_additive]
 theorem mk_mul_mk (x y : α) (L1 L2 : List α) : mk x L1 * mk y L2 = mk x (L1 ++ y :: L2) :=
   rfl
 #align free_semigroup.mk_mul_mk FreeSemigroup.mk_mul_mk
 #align free_add_semigroup.mk_add_mk FreeAddSemigroup.mk_add_mk
+-/
 
 #print FreeSemigroup.of /-
 /-- The embedding `α → free_semigroup α`. -/
@@ -614,11 +666,13 @@ def length (x : FreeSemigroup α) : ℕ :=
 #align free_add_semigroup.length FreeAddSemigroup.length
 -/
 
+#print FreeSemigroup.length_mul /-
 @[simp, to_additive]
 theorem length_mul (x y : FreeSemigroup α) : (x * y).length = x.length + y.length := by
   simp [length, ← add_assoc, add_right_comm]
 #align free_semigroup.length_mul FreeSemigroup.length_mul
 #align free_add_semigroup.length_add FreeAddSemigroup.length_add
+-/
 
 #print FreeSemigroup.length_of /-
 @[simp, to_additive]
@@ -632,6 +686,7 @@ theorem length_of (x : α) : (of x).length = 1 :=
 instance [Inhabited α] : Inhabited (FreeSemigroup α) :=
   ⟨of default⟩
 
+#print FreeSemigroup.recOnMul /-
 /-- Recursor for free semigroup using `of` and `*`. -/
 @[elab_as_elim, to_additive "Recursor for free additive semigroup using `of` and `+`."]
 protected def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (of x))
@@ -640,18 +695,22 @@ protected def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (of
     List.recOn s ih1 (fun hd tl ih f => ih2 f ⟨hd, tl⟩ (ih1 f) (ih hd)) f
 #align free_semigroup.rec_on_mul FreeSemigroup.recOnMul
 #align free_add_semigroup.rec_on_add FreeAddSemigroup.recOnAdd
+-/
 
+#print FreeSemigroup.hom_ext /-
 @[ext, to_additive]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeSemigroup α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
   FunLike.ext _ _ fun x =>
     FreeSemigroup.recOnMul x (congr_fun h) fun x y hx hy => by simp only [map_mul, *]
 #align free_semigroup.hom_ext FreeSemigroup.hom_ext
 #align free_add_semigroup.hom_ext FreeAddSemigroup.hom_ext
+-/
 
 section lift
 
 variable {β : Type v} [Semigroup β] (f : α → β)
 
+#print FreeSemigroup.lift /-
 /-- Lifts a function `α → β` to a semigroup homomorphism `free_semigroup α → β` given
 a semigroup `β`. -/
 @[to_additive
@@ -669,24 +728,31 @@ def lift : (α → β) ≃ (FreeSemigroup α →ₙ* β)
   right_inv f := hom_ext rfl
 #align free_semigroup.lift FreeSemigroup.lift
 #align free_add_semigroup.lift FreeAddSemigroup.lift
+-/
 
+#print FreeSemigroup.lift_of /-
 @[simp, to_additive]
 theorem lift_of (x : α) : lift f (of x) = f x :=
   rfl
 #align free_semigroup.lift_of FreeSemigroup.lift_of
 #align free_add_semigroup.lift_of FreeAddSemigroup.lift_of
+-/
 
+#print FreeSemigroup.lift_comp_of /-
 @[simp, to_additive]
 theorem lift_comp_of : lift f ∘ of = f :=
   rfl
 #align free_semigroup.lift_comp_of FreeSemigroup.lift_comp_of
 #align free_add_semigroup.lift_comp_of FreeAddSemigroup.lift_comp_of
+-/
 
+#print FreeSemigroup.lift_comp_of' /-
 @[simp, to_additive]
 theorem lift_comp_of' (f : FreeSemigroup α →ₙ* β) : lift (f ∘ of) = f :=
   hom_ext rfl
 #align free_semigroup.lift_comp_of' FreeSemigroup.lift_comp_of'
 #align free_add_semigroup.lift_comp_of' FreeAddSemigroup.lift_comp_of'
+-/
 
 #print FreeSemigroup.lift_of_mul /-
 @[to_additive]
@@ -701,12 +767,14 @@ section Map
 
 variable {β : Type v} (f : α → β)
 
+#print FreeSemigroup.map /-
 /-- The unique semigroup homomorphism that sends `of x` to `of (f x)`. -/
 @[to_additive "The unique additive semigroup homomorphism that sends `of x` to `of (f x)`."]
 def map : FreeSemigroup α →ₙ* FreeSemigroup β :=
   lift <| of ∘ f
 #align free_semigroup.map FreeSemigroup.map
 #align free_add_semigroup.map FreeAddSemigroup.map
+-/
 
 #print FreeSemigroup.map_of /-
 @[simp, to_additive]
@@ -735,6 +803,7 @@ instance : Monad FreeSemigroup where
   pure _ := of
   bind _ _ x f := lift f x
 
+#print FreeSemigroup.recOnPure /-
 /-- Recursor that uses `pure` instead of `of`. -/
 @[elab_as_elim, to_additive "Recursor that uses `pure` instead of `of`."]
 def recOnPure {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (pure x))
@@ -742,44 +811,57 @@ def recOnPure {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (pure x))
   FreeSemigroup.recOnMul x ih1 ih2
 #align free_semigroup.rec_on_pure FreeSemigroup.recOnPure
 #align free_add_semigroup.rec_on_pure FreeAddSemigroup.recOnPure
+-/
 
+#print FreeSemigroup.map_pure /-
 @[simp, to_additive]
 theorem map_pure (f : α → β) (x) : (f <$> pure x : FreeSemigroup β) = pure (f x) :=
   rfl
 #align free_semigroup.map_pure FreeSemigroup.map_pure
 #align free_add_semigroup.map_pure FreeAddSemigroup.map_pure
+-/
 
+#print FreeSemigroup.map_mul' /-
 @[simp, to_additive]
 theorem map_mul' (f : α → β) (x y : FreeSemigroup α) : f <$> (x * y) = f <$> x * f <$> y :=
   map_mul (map f) _ _
 #align free_semigroup.map_mul' FreeSemigroup.map_mul'
 #align free_add_semigroup.map_add' FreeAddSemigroup.map_add'
+-/
 
+#print FreeSemigroup.pure_bind /-
 @[simp, to_additive]
 theorem pure_bind (f : α → FreeSemigroup β) (x) : pure x >>= f = f x :=
   rfl
 #align free_semigroup.pure_bind FreeSemigroup.pure_bind
 #align free_add_semigroup.pure_bind FreeAddSemigroup.pure_bind
+-/
 
+#print FreeSemigroup.mul_bind /-
 @[simp, to_additive]
 theorem mul_bind (f : α → FreeSemigroup β) (x y : FreeSemigroup α) :
     x * y >>= f = (x >>= f) * (y >>= f) :=
   map_mul (lift f) _ _
 #align free_semigroup.mul_bind FreeSemigroup.mul_bind
 #align free_add_semigroup.add_bind FreeAddSemigroup.add_bind
+-/
 
+#print FreeSemigroup.pure_seq /-
 @[simp, to_additive]
 theorem pure_seq {f : α → β} {x : FreeSemigroup α} : pure f <*> x = f <$> x :=
   rfl
 #align free_semigroup.pure_seq FreeSemigroup.pure_seq
 #align free_add_semigroup.pure_seq FreeAddSemigroup.pure_seq
+-/
 
+#print FreeSemigroup.mul_seq /-
 @[simp, to_additive]
 theorem mul_seq {f g : FreeSemigroup (α → β)} {x : FreeSemigroup α} :
     f * g <*> x = (f <*> x) * (g <*> x) :=
   mul_bind _ _ _
 #align free_semigroup.mul_seq FreeSemigroup.mul_seq
 #align free_add_semigroup.add_seq FreeAddSemigroup.add_seq
+-/
 
 @[to_additive]
 instance : LawfulMonad FreeSemigroup.{u}
@@ -805,22 +887,27 @@ instance : Traversable FreeSemigroup :=
 
 variable {m : Type u → Type u} [Applicative m] (F : α → m β)
 
+#print FreeSemigroup.traverse_pure /-
 @[simp, to_additive]
 theorem traverse_pure (x) : traverse F (pure x : FreeSemigroup α) = pure <$> F x :=
   rfl
 #align free_semigroup.traverse_pure FreeSemigroup.traverse_pure
 #align free_add_semigroup.traverse_pure FreeAddSemigroup.traverse_pure
+-/
 
+#print FreeSemigroup.traverse_pure' /-
 @[simp, to_additive]
 theorem traverse_pure' : traverse F ∘ pure = fun x => (pure <$> F x : m (FreeSemigroup β)) :=
   rfl
 #align free_semigroup.traverse_pure' FreeSemigroup.traverse_pure'
 #align free_add_semigroup.traverse_pure' FreeAddSemigroup.traverse_pure'
+-/
 
 section
 
 variable [LawfulApplicative m]
 
+#print FreeSemigroup.traverse_mul /-
 @[simp, to_additive]
 theorem traverse_mul (x y : FreeSemigroup α) :
     traverse F (x * y) = (· * ·) <$> traverse F x <*> traverse F y :=
@@ -835,7 +922,9 @@ theorem traverse_mul (x y : FreeSemigroup α) :
     x
 #align free_semigroup.traverse_mul FreeSemigroup.traverse_mul
 #align free_add_semigroup.traverse_add FreeAddSemigroup.traverse_add
+-/
 
+#print FreeSemigroup.traverse_mul' /-
 @[simp, to_additive]
 theorem traverse_mul' :
     Function.comp (traverse F) ∘ @Mul.mul (FreeSemigroup α) _ = fun x y =>
@@ -843,6 +932,7 @@ theorem traverse_mul' :
   funext fun x => funext fun y => traverse_mul F x y
 #align free_semigroup.traverse_mul' FreeSemigroup.traverse_mul'
 #align free_add_semigroup.traverse_add' FreeAddSemigroup.traverse_add'
+-/
 
 end
 
@@ -854,12 +944,14 @@ theorem traverse_eq (x) : FreeSemigroup.traverse F x = traverse F x :=
 #align free_add_semigroup.traverse_eq FreeAddSemigroup.traverse_eq
 -/
 
+#print FreeSemigroup.mul_map_seq /-
 @[simp, to_additive]
 theorem mul_map_seq (x y : FreeSemigroup α) :
     ((· * ·) <$> x <*> y : id (FreeSemigroup α)) = (x * y : FreeSemigroup α) :=
   rfl
 #align free_semigroup.mul_map_seq FreeSemigroup.mul_map_seq
 #align free_add_semigroup.add_map_seq FreeAddSemigroup.add_map_seq
+-/
 
 @[to_additive]
 instance : IsLawfulTraversable FreeSemigroup.{u} :=
@@ -892,12 +984,14 @@ namespace FreeMagma
 
 variable {α : Type u} {β : Type v}
 
+#print FreeMagma.toFreeSemigroup /-
 /-- The canonical multiplicative morphism from `free_magma α` to `free_semigroup α`. -/
 @[to_additive "The canonical additive morphism from `free_add_magma α` to `free_add_semigroup α`."]
 def toFreeSemigroup : FreeMagma α →ₙ* FreeSemigroup α :=
   FreeMagma.lift FreeSemigroup.of
 #align free_magma.to_free_semigroup FreeMagma.toFreeSemigroup
 #align free_add_magma.to_free_add_semigroup FreeAddMagma.toFreeAddSemigroup
+-/
 
 #print FreeMagma.toFreeSemigroup_of /-
 @[simp, to_additive]
@@ -913,10 +1007,12 @@ theorem toFreeSemigroup_comp_of : @toFreeSemigroup α ∘ of = FreeSemigroup.of
 #align free_magma.to_free_semigroup_comp_of FreeMagma.toFreeSemigroup_comp_of
 -/
 
+#print FreeMagma.toFreeSemigroup_comp_map /-
 @[to_additive]
 theorem toFreeSemigroup_comp_map (f : α → β) :
     toFreeSemigroup.comp (map f) = (FreeSemigroup.map f).comp toFreeSemigroup := by ext1; rfl
 #align free_magma.to_free_semigroup_comp_map FreeMagma.toFreeSemigroup_comp_map
+-/
 
 #print FreeMagma.toFreeSemigroup_map /-
 @[to_additive]
@@ -936,6 +1032,7 @@ theorem length_toFreeSemigroup (x : FreeMagma α) : x.toFreeSemigroup.length = x
 
 end FreeMagma
 
+#print FreeMagmaAssocQuotientEquiv /-
 /-- Isomorphism between `magma.assoc_quotient (free_magma α)` and `free_semigroup α`. -/
 @[to_additive
       "Isomorphism between\n`add_magma.assoc_quotient (free_add_magma α)` and `free_add_semigroup α`."]
@@ -944,4 +1041,5 @@ def FreeMagmaAssocQuotientEquiv (α : Type u) :
   (Magma.AssocQuotient.lift FreeMagma.toFreeSemigroup).toMulEquiv
     (FreeSemigroup.lift (Magma.AssocQuotient.of ∘ FreeMagma.of)) (by ext; rfl) (by ext1; rfl)
 #align free_magma_assoc_quotient_equiv FreeMagmaAssocQuotientEquiv
+-/
 

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

@@ -93,7 +93,7 @@ def recOnMul {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (of x))
 #print FreeMagma.hom_ext /-
 @[ext, to_additive]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeMagma α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
-  FunLike.ext _ _ fun x => recOnMul x (congr_fun h) <| by intros ; simp only [map_mul, *]
+  FunLike.ext _ _ fun x => recOnMul x (congr_fun h) <| by intros; simp only [map_mul, *]
 #align free_magma.hom_ext FreeMagma.hom_ext
 #align free_add_magma.hom_ext FreeAddMagma.hom_ext
 -/

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

@@ -141,24 +141,12 @@ def lift : (α → β) ≃ (FreeMagma α →ₙ* β)
 #align free_add_magma.lift FreeAddMagma.lift
 -/
 
-/- warning: free_magma.lift_of -> FreeMagma.lift_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) => (FreeMagma.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) => (α -> β) -> (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f) (FreeMagma.of.{u1} α x)) (f x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeMagma.{u1} α) => β) (FreeMagma.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f) (FreeMagma.of.{u1} α x)) (f x)
-Case conversion may be inaccurate. Consider using '#align free_magma.lift_of FreeMagma.lift_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_of (x) : lift f (of x) = f x :=
   rfl
 #align free_magma.lift_of FreeMagma.lift_of
 #align free_add_magma.lift_of FreeAddMagma.lift_of
 
-/- warning: free_magma.lift_comp_of -> FreeMagma.lift_comp_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeMagma.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) => (FreeMagma.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) => (α -> β) -> (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f)) (FreeMagma.of.{u1} α)) f
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeMagma.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f)) (FreeMagma.of.{u1} α)) f
-Case conversion may be inaccurate. Consider using '#align free_magma.lift_comp_of FreeMagma.lift_comp_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of : lift f ∘ of = f :=
   rfl
@@ -209,12 +197,6 @@ instance : Monad FreeMagma where
   pure _ := of
   bind _ _ x f := lift f x
 
-/- warning: free_magma.rec_on_pure -> FreeMagma.recOnPure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {C : (FreeMagma.{u1} α) -> Sort.{u2}} (x : FreeMagma.{u1} α), (forall (x : α), C (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toHasPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α x)) -> (forall (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)) x y))) -> (C x)
-but is expected to have type
-  forall {α : Type.{u1}} {C : (FreeMagma.{u1} α) -> Sort.{u2}} (x : FreeMagma.{u1} α), (forall (x : α), C (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α x)) -> (forall (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y))) -> (C x)
-Case conversion may be inaccurate. Consider using '#align free_magma.rec_on_pure FreeMagma.recOnPureₓ'. -/
 /-- Recursor on `free_magma` using `pure` instead of `of`. -/
 @[elab_as_elim, to_additive "Recursor on `free_add_magma` using `pure` instead of `of`."]
 protected def recOnPure {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (pure x))
@@ -223,72 +205,36 @@ protected def recOnPure {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (pure
 #align free_magma.rec_on_pure FreeMagma.recOnPure
 #align free_add_magma.rec_on_pure FreeAddMagma.recOnPure
 
-/- warning: free_magma.map_pure -> FreeMagma.map_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : α), Eq.{succ u1} (FreeMagma.{u1} β) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β f (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toHasPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α x)) (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toHasPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) β (f x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : α), Eq.{succ u1} (FreeMagma.{u1} β) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α x)) (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) β (f x))
-Case conversion may be inaccurate. Consider using '#align free_magma.map_pure FreeMagma.map_pureₓ'. -/
 @[simp, to_additive]
 theorem map_pure (f : α → β) (x) : (f <$> pure x : FreeMagma β) = pure (f x) :=
   rfl
 #align free_magma.map_pure FreeMagma.map_pure
 #align free_add_magma.map_pure FreeAddMagma.map_pure
 
-/- warning: free_magma.map_mul' -> FreeMagma.map_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (FreeMagma.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.monad.{u1})) α β f (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)) x y)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.hasMul.{u1} β)) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β f x) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β f y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (FreeMagma.{u1} β) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f x) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f y))
-Case conversion may be inaccurate. Consider using '#align free_magma.map_mul' FreeMagma.map_mul'ₓ'. -/
 @[simp, to_additive]
 theorem map_mul' (f : α → β) (x y : FreeMagma α) : f <$> (x * y) = f <$> x * f <$> y :=
   rfl
 #align free_magma.map_mul' FreeMagma.map_mul'
 #align free_add_magma.map_add' FreeAddMagma.map_add'
 
-/- warning: free_magma.pure_bind -> FreeMagma.pure_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeMagma.{u1} β)) (x : α), Eq.{succ u1} (FreeMagma.{u1} β) (Bind.bind.{u1, u1} FreeMagma.{u1} (Monad.toHasBind.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1}) α β (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toHasPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α x) f) (f x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeMagma.{u1} β)) (x : α), Eq.{succ u1} (FreeMagma.{u1} β) (Bind.bind.{u1, u1} FreeMagma.{u1} (Monad.toBind.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1}) α β (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α x) f) (f x)
-Case conversion may be inaccurate. Consider using '#align free_magma.pure_bind FreeMagma.pure_bindₓ'. -/
 @[simp, to_additive]
 theorem pure_bind (f : α → FreeMagma β) (x) : pure x >>= f = f x :=
   rfl
 #align free_magma.pure_bind FreeMagma.pure_bind
 #align free_add_magma.pure_bind FreeAddMagma.pure_bind
 
-/- warning: free_magma.mul_bind -> FreeMagma.mul_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeMagma.{u1} β)) (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (FreeMagma.{u1} β) (Bind.bind.{u1, u1} FreeMagma.{u1} (Monad.toHasBind.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1}) α β (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)) x y) f) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.hasMul.{u1} β)) (Bind.bind.{u1, u1} FreeMagma.{u1} (Monad.toHasBind.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1}) α β x f) (Bind.bind.{u1, u1} FreeMagma.{u1} (Monad.toHasBind.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1}) α β y f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeMagma.{u1} β)) (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (FreeMagma.{u1} β) (Bind.bind.{u1, u1} FreeMagma.{u1} (Monad.toBind.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1}) α β (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y) f) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) (Bind.bind.{u1, u1} FreeMagma.{u1} (Monad.toBind.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1}) α β x f) (Bind.bind.{u1, u1} FreeMagma.{u1} (Monad.toBind.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1}) α β y f))
-Case conversion may be inaccurate. Consider using '#align free_magma.mul_bind FreeMagma.mul_bindₓ'. -/
 @[simp, to_additive]
 theorem mul_bind (f : α → FreeMagma β) (x y : FreeMagma α) : x * y >>= f = (x >>= f) * (y >>= f) :=
   rfl
 #align free_magma.mul_bind FreeMagma.mul_bind
 #align free_add_magma.add_bind FreeAddMagma.add_bind
 
-/- warning: free_magma.pure_seq -> FreeMagma.pure_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Applicative.toHasSeq.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.monad.{u1})) α β (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Applicative.toHasPure.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.monad.{u1})) (α -> β) f) x) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β f x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) (α -> β) f) (fun (x._@.Mathlib.Algebra.Free._hyg.1879 : Unit) => x)) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f x)
-Case conversion may be inaccurate. Consider using '#align free_magma.pure_seq FreeMagma.pure_seqₓ'. -/
 @[simp, to_additive]
 theorem pure_seq {α β : Type u} {f : α → β} {x : FreeMagma α} : pure f <*> x = f <$> x :=
   rfl
 #align free_magma.pure_seq FreeMagma.pure_seq
 #align free_add_magma.pure_seq FreeAddMagma.pure_seq
 
-/- warning: free_magma.mul_seq -> FreeMagma.mul_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeMagma.{u1} (α -> β)} {g : FreeMagma.{u1} (α -> β)} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toHasSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (instHMul.{u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.hasMul.{u1} (α -> β))) f g) x) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.hasMul.{u1} β)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toHasSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toHasSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β g x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeMagma.{u1} (α -> β)} {g : FreeMagma.{u1} (α -> β)} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (instHMul.{u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.instMulFreeMagma.{u1} (α -> β))) f g) (fun (x._@.Mathlib.Algebra.Free._hyg.1921 : Unit) => x)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f (fun (x._@.Mathlib.Algebra.Free._hyg.1932 : Unit) => x)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β g (fun (x._@.Mathlib.Algebra.Free._hyg.1942 : Unit) => x)))
-Case conversion may be inaccurate. Consider using '#align free_magma.mul_seq FreeMagma.mul_seqₓ'. -/
 @[simp, to_additive]
 theorem mul_seq {α β : Type u} {f g : FreeMagma (α → β)} {x : FreeMagma α} :
     f * g <*> x = (f <*> x) * (g <*> x) :=
@@ -343,36 +289,18 @@ instance : Traversable FreeMagma :=
 
 variable {m : Type u → Type u} [Applicative m] (F : α → m β)
 
-/- warning: free_magma.traverse_pure -> FreeMagma.traverse_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) (x : α), Eq.{succ u1} (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.traversable.{u1} m _inst_1 α β F (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toHasPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α x)) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) β (FreeMagma.{u1} β) (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toHasPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) β) (F x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) (x : α), Eq.{succ u1} (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α x)) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) β (FreeMagma.{u1} β) (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) β) (F x))
-Case conversion may be inaccurate. Consider using '#align free_magma.traverse_pure FreeMagma.traverse_pureₓ'. -/
 @[simp, to_additive]
 theorem traverse_pure (x) : traverse F (pure x : FreeMagma α) = pure <$> F x :=
   rfl
 #align free_magma.traverse_pure FreeMagma.traverse_pure
 #align free_add_magma.traverse_pure FreeAddMagma.traverse_pure
 
-/- warning: free_magma.traverse_pure' -> FreeMagma.traverse_pure' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)), Eq.{succ u1} (α -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} α (FreeMagma.{u1} α) (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} (fun {β : Type.{u1}} => FreeMagma.{u1} β) FreeMagma.traversable.{u1} m _inst_1 α β F) (Pure.pure.{u1, u1} (fun {β : Type.{u1}} => FreeMagma.{u1} β) (Applicative.toHasPure.{u1, u1} (fun {β : Type.{u1}} => FreeMagma.{u1} β) (Monad.toApplicative.{u1, u1} (fun {β : Type.{u1}} => FreeMagma.{u1} β) FreeMagma.monad.{u1})) α)) (fun (x : α) => Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) β (FreeMagma.{u1} β) (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toHasPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) β) (F x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)), Eq.{succ u1} (α -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} α (FreeMagma.{u1} α) (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F) (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α)) (fun (x : α) => Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) β (FreeMagma.{u1} β) (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) β) (F x))
-Case conversion may be inaccurate. Consider using '#align free_magma.traverse_pure' FreeMagma.traverse_pure'ₓ'. -/
 @[simp, to_additive]
 theorem traverse_pure' : traverse F ∘ pure = fun x => (pure <$> F x : m (FreeMagma β)) :=
   rfl
 #align free_magma.traverse_pure' FreeMagma.traverse_pure'
 #align free_add_magma.traverse_pure' FreeAddMagma.traverse_pure'
 
-/- warning: free_magma.traverse_mul -> FreeMagma.traverse_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.traversable.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)) x y)) (Seq.seq.{u1, u1} m (Applicative.toHasSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.hasMul.{u1} β))) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.traversable.{u1} m _inst_1 α β F x)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.traversable.{u1} m _inst_1 α β F y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y)) (Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.2525 : FreeMagma.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.2527 : FreeMagma.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) x._@.Mathlib.Algebra.Free._hyg.2525 x._@.Mathlib.Algebra.Free._hyg.2527) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.2544 : Unit) => Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F y))
-Case conversion may be inaccurate. Consider using '#align free_magma.traverse_mul FreeMagma.traverse_mulₓ'. -/
 @[simp, to_additive]
 theorem traverse_mul (x y : FreeMagma α) :
     traverse F (x * y) = (· * ·) <$> traverse F x <*> traverse F y :=
@@ -380,12 +308,6 @@ theorem traverse_mul (x y : FreeMagma α) :
 #align free_magma.traverse_mul FreeMagma.traverse_mul
 #align free_add_magma.traverse_add FreeAddMagma.traverse_add
 
-/- warning: free_magma.traverse_mul' -> FreeMagma.traverse_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)), Eq.{succ u1} ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) ((FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.traversable.{u1} m _inst_1 α β F)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)))) (fun (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toHasSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.hasMul.{u1} β))) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.traversable.{u1} m _inst_1 α β F x)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.traversable.{u1} m _inst_1 α β F y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)), Eq.{succ u1} ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) ((FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F)) (Mul.mul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α))) (fun (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.2593 : FreeMagma.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.2595 : FreeMagma.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) x._@.Mathlib.Algebra.Free._hyg.2593 x._@.Mathlib.Algebra.Free._hyg.2595) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.2612 : Unit) => Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F y))
-Case conversion may be inaccurate. Consider using '#align free_magma.traverse_mul' FreeMagma.traverse_mul'ₓ'. -/
 @[simp, to_additive]
 theorem traverse_mul' :
     Function.comp (traverse F) ∘ @Mul.mul (FreeMagma α) _ = fun x y =>
@@ -402,12 +324,6 @@ theorem traverse_eq (x) : FreeMagma.traverse F x = traverse F x :=
 #align free_add_magma.traverse_eq FreeAddMagma.traverse_eq
 -/
 
-/- warning: free_magma.mul_map_seq -> FreeMagma.mul_map_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (id.{succ (succ u1)} Type.{u1} (FreeMagma.{u1} α)) (Seq.seq.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Applicative.toHasSeq.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Monad.toApplicative.{u1, u1} (id.{succ (succ u1)} Type.{u1}) id.monad.{u1})) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (Functor.map.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Traversable.toFunctor.{u1} (id.{succ (succ u1)} Type.{u1}) id.traversable.{u1}) (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α))) x) y) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)) x y)
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (Id.{u1} (FreeMagma.{u1} α)) (Seq.seq.{u1, u1} Id.{u1} (Applicative.toSeq.{u1, u1} Id.{u1} (Monad.toApplicative.{u1, u1} Id.{u1} Id.instMonadId.{u1})) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (Functor.map.{u1, u1} Id.{u1} (Traversable.toFunctor.{u1} Id.{u1} instTraversableId.{u1}) (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) (fun (x._@.Mathlib.Algebra.Free._hyg.2681 : FreeMagma.{u1} α) (x._@.Mathlib.Algebra.Free._hyg.2683 : FreeMagma.{u1} α) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x._@.Mathlib.Algebra.Free._hyg.2681 x._@.Mathlib.Algebra.Free._hyg.2683) x) (fun (x._@.Mathlib.Algebra.Free._hyg.2698 : Unit) => y)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y)
-Case conversion may be inaccurate. Consider using '#align free_magma.mul_map_seq FreeMagma.mul_map_seqₓ'. -/
 @[simp, to_additive]
 theorem mul_map_seq (x y : FreeMagma α) :
     ((· * ·) <$> x <*> y : id (FreeMagma α)) = (x * y : FreeMagma α) :=
@@ -439,24 +355,12 @@ end Category
 
 end FreeMagma
 
-/- warning: free_magma.repr -> FreeMagma.repr is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Repr.{u1} α], (FreeMagma.{u1} α) -> String
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Repr.{u1} α], (FreeMagma.{u1} α) -> Std.Format
-Case conversion may be inaccurate. Consider using '#align free_magma.repr FreeMagma.reprₓ'. -/
 /-- Representation of an element of a free magma. -/
 protected def FreeMagma.repr {α : Type u} [Repr α] : FreeMagma α → String
   | FreeMagma.of x => repr x
   | x * y => "( " ++ x.repr ++ " * " ++ y.repr ++ " )"
 #align free_magma.repr FreeMagma.repr
 
-/- warning: free_add_magma.repr -> FreeAddMagma.repr is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Repr.{u1} α], (FreeAddMagma.{u1} α) -> String
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Repr.{u1} α], (FreeAddMagma.{u1} α) -> Std.Format
-Case conversion may be inaccurate. Consider using '#align free_add_magma.repr FreeAddMagma.reprₓ'. -/
 /-- Representation of an element of a free additive magma. -/
 protected def FreeAddMagma.repr {α : Type u} [Repr α] : FreeAddMagma α → String
   | FreeAddMagma.of x => repr x
@@ -554,12 +458,6 @@ instance : Semigroup (AssocQuotient α)
           quot_mk_assoc_left, ← quot_mk_assoc c d, ← quot_mk_assoc c d, quot_mk_assoc_left]
   mul_assoc x y z := Quot.induction_on₃ x y z fun p q r => quot_mk_assoc p q r
 
-/- warning: magma.assoc_quotient.of -> Magma.AssocQuotient.of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))
-Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.of Magma.AssocQuotient.ofₓ'. -/
 /-- Embedding from magma to its free semigroup. -/
 @[to_additive "Embedding from additive magma to its free additive semigroup."]
 def of : α →ₙ* AssocQuotient α :=
@@ -584,24 +482,12 @@ section lift
 
 variable {β : Type v} [Semigroup β] (f : α →ₙ* β)
 
-/- warning: magma.assoc_quotient.hom_ext -> Magma.AssocQuotient.hom_ext is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] {f : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)} {g : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)}, (Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2) g (Magma.AssocQuotient.of.{u1} α _inst_1))) -> (Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) f g)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] {f : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)} {g : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)}, (Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) g (Magma.AssocQuotient.of.{u1} α _inst_1))) -> (Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f g)
-Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.hom_ext Magma.AssocQuotient.hom_extₓ'. -/
 @[ext, to_additive]
 theorem hom_ext {f g : AssocQuotient α →ₙ* β} (h : f.comp of = g.comp of) : f = g :=
   FunLike.ext _ _ fun x => AssocQuotient.induction_on x <| FunLike.congr_fun h
 #align magma.assoc_quotient.hom_ext Magma.AssocQuotient.hom_ext
 #align add_magma.free_add_semigroup.hom_ext AddMagma.FreeAddSemigroup.hom_ext
 
-/- warning: magma.assoc_quotient.lift -> Magma.AssocQuotient.lift is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β], Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β], Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))
-Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.lift Magma.AssocQuotient.liftₓ'. -/
 /-- Lifts a magma homomorphism `α → β` to a semigroup homomorphism `magma.assoc_quotient α → β`
 given a semigroup `β`. -/
 @[to_additive
@@ -620,36 +506,18 @@ def lift : (α →ₙ* β) ≃ (AssocQuotient α →ₙ* β)
 #align magma.assoc_quotient.lift Magma.AssocQuotient.lift
 #align add_magma.free_add_semigroup.lift AddMagma.FreeAddSemigroup.lift
 
-/- warning: magma.assoc_quotient.lift_of -> Magma.AssocQuotient.lift_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) => (Magma.AssocQuotient.{u1} α _inst_1) -> β) (MulHom.hasCoeToFun.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) (coeFn.{max 1 (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) => (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) -> (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (coeFn.{succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))) (fun (_x : MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))) => α -> (Magma.AssocQuotient.{u1} α _inst_1)) (MulHom.hasCoeToFun.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) => α -> β) (MulHom.hasCoeToFun.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) f x)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Magma.AssocQuotient.{u1} α _inst_1) => β) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => Magma.AssocQuotient.{u1} α _inst_1) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) (fun (_x : Magma.AssocQuotient.{u1} α _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Magma.AssocQuotient.{u1} α _inst_1) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => Magma.AssocQuotient.{u1} α _inst_1) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α β _inst_1 (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2))) f x)
-Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.lift_of Magma.AssocQuotient.lift_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_of (x : α) : lift f (of x) = f x :=
   rfl
 #align magma.assoc_quotient.lift_of Magma.AssocQuotient.lift_of
 #align add_magma.free_add_semigroup.lift_of AddMagma.FreeAddSemigroup.lift_of
 
-/- warning: magma.assoc_quotient.lift_comp_of -> Magma.AssocQuotient.lift_comp_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)), Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2) (coeFn.{max 1 (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) => (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) -> (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (Magma.AssocQuotient.of.{u1} α _inst_1)) f
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)), Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (Magma.AssocQuotient.of.{u1} α _inst_1)) f
-Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.lift_comp_of Magma.AssocQuotient.lift_comp_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of : (lift f).comp of = f :=
   lift.symm_apply_apply f
 #align magma.assoc_quotient.lift_comp_of Magma.AssocQuotient.lift_comp_of
 #align add_magma.free_add_semigroup.lift_comp_of AddMagma.FreeAddSemigroup.lift_comp_of
 
-/- warning: magma.assoc_quotient.lift_comp_of' -> Magma.AssocQuotient.lift_comp_of' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)), Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) (coeFn.{max 1 (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) => (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) -> (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) f
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) f
-Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.lift_comp_of' Magma.AssocQuotient.lift_comp_of'ₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of' (f : AssocQuotient α →ₙ* β) : lift (f.comp of) = f :=
   lift.apply_symm_apply f
@@ -660,12 +528,6 @@ end lift
 
 variable {β : Type v} [Mul β] (f : α →ₙ* β)
 
-/- warning: magma.assoc_quotient.map -> Magma.AssocQuotient.map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Mul.{u2} β], (MulHom.{u1, u2} α β _inst_1 _inst_2) -> (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.{u2} β _inst_2) (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} (Magma.AssocQuotient.{u2} β _inst_2) (Magma.AssocQuotient.semigroup.{u2} β _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Mul.{u2} β], (MulHom.{u1, u2} α β _inst_1 _inst_2) -> (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.{u2} β _inst_2) (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} (Magma.AssocQuotient.{u2} β _inst_2) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u2} β _inst_2)))
-Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.map Magma.AssocQuotient.mapₓ'. -/
 /-- From a magma homomorphism `α →ₙ* β` to a semigroup homomorphism
 `magma.assoc_quotient α →ₙ* magma.assoc_quotient β`. -/
 @[to_additive
@@ -716,36 +578,18 @@ instance : Semigroup (FreeSemigroup α)
   mul L1 L2 := ⟨L1.1, L1.2 ++ L2.1 :: L2.2⟩
   mul_assoc L1 L2 L3 := ext _ _ rfl <| List.append_assoc _ _ _
 
-/- warning: free_semigroup.head_mul -> FreeSemigroup.head_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} α (FreeSemigroup.head.{u1} α (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) x y)) (FreeSemigroup.head.{u1} α x)
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} α (FreeSemigroup.head.{u1} α (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)) (FreeSemigroup.head.{u1} α x)
-Case conversion may be inaccurate. Consider using '#align free_semigroup.head_mul FreeSemigroup.head_mulₓ'. -/
 @[simp, to_additive]
 theorem head_mul (x y : FreeSemigroup α) : (x * y).1 = x.1 :=
   rfl
 #align free_semigroup.head_mul FreeSemigroup.head_mul
 #align free_add_semigroup.head_add FreeAddSemigroup.head_add
 
-/- warning: free_semigroup.tail_mul -> FreeSemigroup.tail_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (List.{u1} α) (FreeSemigroup.tail.{u1} α (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) x y)) (Append.append.{u1} (List.{u1} α) (List.hasAppend.{u1} α) (FreeSemigroup.tail.{u1} α x) (List.cons.{u1} α (FreeSemigroup.head.{u1} α y) (FreeSemigroup.tail.{u1} α y)))
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (List.{u1} α) (FreeSemigroup.tail.{u1} α (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)) (HAppend.hAppend.{u1, u1, u1} (List.{u1} α) (List.{u1} α) (List.{u1} α) (instHAppend.{u1} (List.{u1} α) (List.instAppendList.{u1} α)) (FreeSemigroup.tail.{u1} α x) (List.cons.{u1} α (FreeSemigroup.head.{u1} α y) (FreeSemigroup.tail.{u1} α y)))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.tail_mul FreeSemigroup.tail_mulₓ'. -/
 @[simp, to_additive]
 theorem tail_mul (x y : FreeSemigroup α) : (x * y).2 = x.2 ++ y.1 :: y.2 :=
   rfl
 #align free_semigroup.tail_mul FreeSemigroup.tail_mul
 #align free_add_semigroup.tail_add FreeAddSemigroup.tail_add
 
-/- warning: free_semigroup.mk_mul_mk -> FreeSemigroup.mk_mul_mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : α) (y : α) (L1 : List.{u1} α) (L2 : List.{u1} α), Eq.{succ u1} (FreeSemigroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) (FreeSemigroup.mk.{u1} α x L1) (FreeSemigroup.mk.{u1} α y L2)) (FreeSemigroup.mk.{u1} α x (Append.append.{u1} (List.{u1} α) (List.hasAppend.{u1} α) L1 (List.cons.{u1} α y L2)))
-but is expected to have type
-  forall {α : Type.{u1}} (x : α) (y : α) (L1 : List.{u1} α) (L2 : List.{u1} α), Eq.{succ u1} (FreeSemigroup.{u1} α) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) (FreeSemigroup.mk.{u1} α x L1) (FreeSemigroup.mk.{u1} α y L2)) (FreeSemigroup.mk.{u1} α x (HAppend.hAppend.{u1, u1, u1} (List.{u1} α) (List.{u1} α) (List.{u1} α) (instHAppend.{u1} (List.{u1} α) (List.instAppendList.{u1} α)) L1 (List.cons.{u1} α y L2)))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.mk_mul_mk FreeSemigroup.mk_mul_mkₓ'. -/
 @[simp, to_additive]
 theorem mk_mul_mk (x y : α) (L1 L2 : List α) : mk x L1 * mk y L2 = mk x (L1 ++ y :: L2) :=
   rfl
@@ -770,12 +614,6 @@ def length (x : FreeSemigroup α) : ℕ :=
 #align free_add_semigroup.length FreeAddSemigroup.length
 -/
 
-/- warning: free_semigroup.length_mul -> FreeSemigroup.length_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{1} Nat (FreeSemigroup.length.{u1} α (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) x y)) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) (FreeSemigroup.length.{u1} α x) (FreeSemigroup.length.{u1} α y))
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{1} Nat (FreeSemigroup.length.{u1} α (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) (FreeSemigroup.length.{u1} α x) (FreeSemigroup.length.{u1} α y))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.length_mul FreeSemigroup.length_mulₓ'. -/
 @[simp, to_additive]
 theorem length_mul (x y : FreeSemigroup α) : (x * y).length = x.length + y.length := by
   simp [length, ← add_assoc, add_right_comm]
@@ -794,12 +632,6 @@ theorem length_of (x : α) : (of x).length = 1 :=
 instance [Inhabited α] : Inhabited (FreeSemigroup α) :=
   ⟨of default⟩
 
-/- warning: free_semigroup.rec_on_mul -> FreeSemigroup.recOnMul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {C : (FreeSemigroup.{u1} α) -> Sort.{u2}} (x : FreeSemigroup.{u1} α), (forall (x : α), C (FreeSemigroup.of.{u1} α x)) -> (forall (x : α) (y : FreeSemigroup.{u1} α), (C (FreeSemigroup.of.{u1} α x)) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) (FreeSemigroup.of.{u1} α x) y))) -> (C x)
-but is expected to have type
-  forall {α : Type.{u1}} {C : (FreeSemigroup.{u1} α) -> Sort.{u2}} (x : FreeSemigroup.{u1} α), (forall (x : α), C (FreeSemigroup.of.{u1} α x)) -> (forall (x : α) (y : FreeSemigroup.{u1} α), (C (FreeSemigroup.of.{u1} α x)) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) (FreeSemigroup.of.{u1} α x) y))) -> (C x)
-Case conversion may be inaccurate. Consider using '#align free_semigroup.rec_on_mul FreeSemigroup.recOnMulₓ'. -/
 /-- Recursor for free semigroup using `of` and `*`. -/
 @[elab_as_elim, to_additive "Recursor for free additive semigroup using `of` and `+`."]
 protected def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (of x))
@@ -809,12 +641,6 @@ protected def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (of
 #align free_semigroup.rec_on_mul FreeSemigroup.recOnMul
 #align free_add_semigroup.rec_on_add FreeAddSemigroup.recOnAdd
 
-/- warning: free_semigroup.hom_ext -> FreeSemigroup.hom_ext is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] {f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1} {g : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1}, (Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) f) (FreeSemigroup.of.{u1} α)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) g) (FreeSemigroup.of.{u1} α))) -> (Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) f g)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] {f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1} {g : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1}, (Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) f) (FreeSemigroup.of.{u1} α)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) g) (FreeSemigroup.of.{u1} α))) -> (Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) f g)
-Case conversion may be inaccurate. Consider using '#align free_semigroup.hom_ext FreeSemigroup.hom_extₓ'. -/
 @[ext, to_additive]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeSemigroup α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
   FunLike.ext _ _ fun x =>
@@ -826,12 +652,6 @@ section lift
 
 variable {β : Type v} [Semigroup β] (f : α → β)
 
-/- warning: free_semigroup.lift -> FreeSemigroup.lift is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β], Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β], Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.lift FreeSemigroup.liftₓ'. -/
 /-- Lifts a function `α → β` to a semigroup homomorphism `free_semigroup α → β` given
 a semigroup `β`. -/
 @[to_additive
@@ -850,36 +670,18 @@ def lift : (α → β) ≃ (FreeSemigroup α →ₙ* β)
 #align free_semigroup.lift FreeSemigroup.lift
 #align free_add_semigroup.lift FreeAddSemigroup.lift
 
-/- warning: free_semigroup.lift_of -> FreeSemigroup.lift_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) => (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f) (FreeSemigroup.of.{u1} α x)) (f x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) (FreeSemigroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f) (FreeSemigroup.of.{u1} α x)) (f x)
-Case conversion may be inaccurate. Consider using '#align free_semigroup.lift_of FreeSemigroup.lift_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_of (x : α) : lift f (of x) = f x :=
   rfl
 #align free_semigroup.lift_of FreeSemigroup.lift_of
 #align free_add_semigroup.lift_of FreeAddSemigroup.lift_of
 
-/- warning: free_semigroup.lift_comp_of -> FreeSemigroup.lift_comp_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) => (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f)) (FreeSemigroup.of.{u1} α)) f
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f)) (FreeSemigroup.of.{u1} α)) f
-Case conversion may be inaccurate. Consider using '#align free_semigroup.lift_comp_of FreeSemigroup.lift_comp_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of : lift f ∘ of = f :=
   rfl
 #align free_semigroup.lift_comp_of FreeSemigroup.lift_comp_of
 #align free_add_semigroup.lift_comp_of FreeAddSemigroup.lift_comp_of
 
-/- warning: free_semigroup.lift_comp_of' -> FreeSemigroup.lift_comp_of' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)), Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) => (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) f) (FreeSemigroup.of.{u1} α))) f
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (a : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) (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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) f
-Case conversion may be inaccurate. Consider using '#align free_semigroup.lift_comp_of' FreeSemigroup.lift_comp_of'ₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of' (f : FreeSemigroup α →ₙ* β) : lift (f ∘ of) = f :=
   hom_ext rfl
@@ -899,12 +701,6 @@ section Map
 
 variable {β : Type v} (f : α → β)
 
-/- warning: free_semigroup.map -> FreeSemigroup.map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}}, (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) (FreeSemigroup.{u2} β) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} (FreeSemigroup.{u2} β) (FreeSemigroup.semigroup.{u2} β)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}}, (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) (FreeSemigroup.{u2} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} (FreeSemigroup.{u2} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u2} β)))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.map FreeSemigroup.mapₓ'. -/
 /-- The unique semigroup homomorphism that sends `of x` to `of (f x)`. -/
 @[to_additive "The unique additive semigroup homomorphism that sends `of x` to `of (f x)`."]
 def map : FreeSemigroup α →ₙ* FreeSemigroup β :=
@@ -939,12 +735,6 @@ instance : Monad FreeSemigroup where
   pure _ := of
   bind _ _ x f := lift f x
 
-/- warning: free_semigroup.rec_on_pure -> FreeSemigroup.recOnPure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {C : (FreeSemigroup.{u1} α) -> Sort.{u2}} (x : FreeSemigroup.{u1} α), (forall (x : α), C (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α x)) -> (forall (x : α) (y : FreeSemigroup.{u1} α), (C (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α x)) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α x) y))) -> (C x)
-but is expected to have type
-  forall {α : Type.{u1}} {C : (FreeSemigroup.{u1} α) -> Sort.{u2}} (x : FreeSemigroup.{u1} α), (forall (x : α), C (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α x)) -> (forall (x : α) (y : FreeSemigroup.{u1} α), (C (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α x)) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α x) y))) -> (C x)
-Case conversion may be inaccurate. Consider using '#align free_semigroup.rec_on_pure FreeSemigroup.recOnPureₓ'. -/
 /-- Recursor that uses `pure` instead of `of`. -/
 @[elab_as_elim, to_additive "Recursor that uses `pure` instead of `of`."]
 def recOnPure {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (pure x))
@@ -953,48 +743,24 @@ def recOnPure {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (pure x))
 #align free_semigroup.rec_on_pure FreeSemigroup.recOnPure
 #align free_add_semigroup.rec_on_pure FreeAddSemigroup.recOnPure
 
-/- warning: free_semigroup.map_pure -> FreeSemigroup.map_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : α), Eq.{succ u1} (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β f (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α x)) (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) β (f x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : α), Eq.{succ u1} (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α x)) (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) β (f x))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.map_pure FreeSemigroup.map_pureₓ'. -/
 @[simp, to_additive]
 theorem map_pure (f : α → β) (x) : (f <$> pure x : FreeSemigroup β) = pure (f x) :=
   rfl
 #align free_semigroup.map_pure FreeSemigroup.map_pure
 #align free_add_semigroup.map_pure FreeAddSemigroup.map_pure
 
-/- warning: free_semigroup.map_mul' -> FreeSemigroup.map_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Applicative.toFunctor.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.monad.{u1})) α β f (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) x y)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.semigroup.{u1} β))) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β f x) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β f y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> β) (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f x) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f y))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.map_mul' FreeSemigroup.map_mul'ₓ'. -/
 @[simp, to_additive]
 theorem map_mul' (f : α → β) (x y : FreeSemigroup α) : f <$> (x * y) = f <$> x * f <$> y :=
   map_mul (map f) _ _
 #align free_semigroup.map_mul' FreeSemigroup.map_mul'
 #align free_add_semigroup.map_add' FreeAddSemigroup.map_add'
 
-/- warning: free_semigroup.pure_bind -> FreeSemigroup.pure_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeSemigroup.{u1} β)) (x : α), Eq.{succ u1} (FreeSemigroup.{u1} β) (Bind.bind.{u1, u1} FreeSemigroup.{u1} (Monad.toHasBind.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1}) α β (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α x) f) (f x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeSemigroup.{u1} β)) (x : α), Eq.{succ u1} (FreeSemigroup.{u1} β) (Bind.bind.{u1, u1} FreeSemigroup.{u1} (Monad.toBind.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1}) α β (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α x) f) (f x)
-Case conversion may be inaccurate. Consider using '#align free_semigroup.pure_bind FreeSemigroup.pure_bindₓ'. -/
 @[simp, to_additive]
 theorem pure_bind (f : α → FreeSemigroup β) (x) : pure x >>= f = f x :=
   rfl
 #align free_semigroup.pure_bind FreeSemigroup.pure_bind
 #align free_add_semigroup.pure_bind FreeAddSemigroup.pure_bind
 
-/- warning: free_semigroup.mul_bind -> FreeSemigroup.mul_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeSemigroup.{u1} β)) (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (FreeSemigroup.{u1} β) (Bind.bind.{u1, u1} FreeSemigroup.{u1} (Monad.toHasBind.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1}) α β (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) x y) f) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.semigroup.{u1} β))) (Bind.bind.{u1, u1} FreeSemigroup.{u1} (Monad.toHasBind.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1}) α β x f) (Bind.bind.{u1, u1} FreeSemigroup.{u1} (Monad.toHasBind.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1}) α β y f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : α -> (FreeSemigroup.{u1} β)) (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (FreeSemigroup.{u1} β) (Bind.bind.{u1, u1} FreeSemigroup.{u1} (Monad.toBind.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1}) α β (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y) f) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) (Bind.bind.{u1, u1} FreeSemigroup.{u1} (Monad.toBind.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1}) α β x f) (Bind.bind.{u1, u1} FreeSemigroup.{u1} (Monad.toBind.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1}) α β y f))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.mul_bind FreeSemigroup.mul_bindₓ'. -/
 @[simp, to_additive]
 theorem mul_bind (f : α → FreeSemigroup β) (x y : FreeSemigroup α) :
     x * y >>= f = (x >>= f) * (y >>= f) :=
@@ -1002,24 +768,12 @@ theorem mul_bind (f : α → FreeSemigroup β) (x y : FreeSemigroup α) :
 #align free_semigroup.mul_bind FreeSemigroup.mul_bind
 #align free_add_semigroup.add_bind FreeAddSemigroup.add_bind
 
-/- warning: free_semigroup.pure_seq -> FreeSemigroup.pure_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Applicative.toHasSeq.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.monad.{u1})) α β (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Applicative.toHasPure.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.monad.{u1})) (α -> β) f) x) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β f x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.Algebra.Free._hyg.5541 : Unit) => x)) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f x)
-Case conversion may be inaccurate. Consider using '#align free_semigroup.pure_seq FreeSemigroup.pure_seqₓ'. -/
 @[simp, to_additive]
 theorem pure_seq {f : α → β} {x : FreeSemigroup α} : pure f <*> x = f <$> x :=
   rfl
 #align free_semigroup.pure_seq FreeSemigroup.pure_seq
 #align free_add_semigroup.pure_seq FreeAddSemigroup.pure_seq
 
-/- warning: free_semigroup.mul_seq -> FreeSemigroup.mul_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeSemigroup.{u1} (α -> β)} {g : FreeSemigroup.{u1} (α -> β)} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (instHMul.{u1} (FreeSemigroup.{u1} (α -> β)) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.semigroup.{u1} (α -> β)))) f g) x) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.semigroup.{u1} β))) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β g x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeSemigroup.{u1} (α -> β)} {g : FreeSemigroup.{u1} (α -> β)} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (instHMul.{u1} (FreeSemigroup.{u1} (α -> β)) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} (α -> β)))) f g) (fun (x._@.Mathlib.Algebra.Free._hyg.5581 : Unit) => x)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f (fun (x._@.Mathlib.Algebra.Free._hyg.5592 : Unit) => x)) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β g (fun (x._@.Mathlib.Algebra.Free._hyg.5602 : Unit) => x)))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.mul_seq FreeSemigroup.mul_seqₓ'. -/
 @[simp, to_additive]
 theorem mul_seq {f g : FreeSemigroup (α → β)} {x : FreeSemigroup α} :
     f * g <*> x = (f <*> x) * (g <*> x) :=
@@ -1051,24 +805,12 @@ instance : Traversable FreeSemigroup :=
 
 variable {m : Type u → Type u} [Applicative m] (F : α → m β)
 
-/- warning: free_semigroup.traverse_pure -> FreeSemigroup.traverse_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) (x : α), Eq.{succ u1} (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.traversable.{u1} m _inst_1 α β F (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α x)) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) β (FreeSemigroup.{u1} β) (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) β) (F x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) (x : α), Eq.{succ u1} (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α x)) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) β (FreeSemigroup.{u1} β) (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) β) (F x))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.traverse_pure FreeSemigroup.traverse_pureₓ'. -/
 @[simp, to_additive]
 theorem traverse_pure (x) : traverse F (pure x : FreeSemigroup α) = pure <$> F x :=
   rfl
 #align free_semigroup.traverse_pure FreeSemigroup.traverse_pure
 #align free_add_semigroup.traverse_pure FreeAddSemigroup.traverse_pure
 
-/- warning: free_semigroup.traverse_pure' -> FreeSemigroup.traverse_pure' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)), Eq.{succ u1} (α -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} α (FreeSemigroup.{u1} α) (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} (fun {β : Type.{u1}} => FreeSemigroup.{u1} β) FreeSemigroup.traversable.{u1} m _inst_1 α β F) (Pure.pure.{u1, u1} (fun {β : Type.{u1}} => FreeSemigroup.{u1} β) (Applicative.toHasPure.{u1, u1} (fun {β : Type.{u1}} => FreeSemigroup.{u1} β) (Monad.toApplicative.{u1, u1} (fun {β : Type.{u1}} => FreeSemigroup.{u1} β) FreeSemigroup.monad.{u1})) α)) (fun (x : α) => Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) β (FreeSemigroup.{u1} β) (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) β) (F x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)), Eq.{succ u1} (α -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} α (FreeSemigroup.{u1} α) (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F) (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α)) (fun (x : α) => Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) β (FreeSemigroup.{u1} β) (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) β) (F x))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.traverse_pure' FreeSemigroup.traverse_pure'ₓ'. -/
 @[simp, to_additive]
 theorem traverse_pure' : traverse F ∘ pure = fun x => (pure <$> F x : m (FreeSemigroup β)) :=
   rfl
@@ -1079,12 +821,6 @@ section
 
 variable [LawfulApplicative m]
 
-/- warning: free_semigroup.traverse_mul -> FreeSemigroup.traverse_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1] (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.traversable.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) x y)) (Seq.seq.{u1, u1} m (Applicative.toHasSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.semigroup.{u1} β)))) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.traversable.{u1} m _inst_1 α β F x)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.traversable.{u1} m _inst_1 α β F y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1] (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)) (Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.6029 : FreeSemigroup.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.6031 : FreeSemigroup.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) x._@.Mathlib.Algebra.Free._hyg.6029 x._@.Mathlib.Algebra.Free._hyg.6031) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.6048 : Unit) => Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F y))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.traverse_mul FreeSemigroup.traverse_mulₓ'. -/
 @[simp, to_additive]
 theorem traverse_mul (x y : FreeSemigroup α) :
     traverse F (x * y) = (· * ·) <$> traverse F x <*> traverse F y :=
@@ -1100,12 +836,6 @@ theorem traverse_mul (x y : FreeSemigroup α) :
 #align free_semigroup.traverse_mul FreeSemigroup.traverse_mul
 #align free_add_semigroup.traverse_add FreeAddSemigroup.traverse_add
 
-/- warning: free_semigroup.traverse_mul' -> FreeSemigroup.traverse_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1], Eq.{succ u1} ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) ((FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.traversable.{u1} m _inst_1 α β F)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))))) (fun (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toHasSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.semigroup.{u1} β)))) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.traversable.{u1} m _inst_1 α β F x)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.traversable.{u1} m _inst_1 α β F y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1], Eq.{succ u1} ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) ((FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F)) (Mul.mul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)))) (fun (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.6326 : FreeSemigroup.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.6328 : FreeSemigroup.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) x._@.Mathlib.Algebra.Free._hyg.6326 x._@.Mathlib.Algebra.Free._hyg.6328) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.6345 : Unit) => Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F y))
-Case conversion may be inaccurate. Consider using '#align free_semigroup.traverse_mul' FreeSemigroup.traverse_mul'ₓ'. -/
 @[simp, to_additive]
 theorem traverse_mul' :
     Function.comp (traverse F) ∘ @Mul.mul (FreeSemigroup α) _ = fun x y =>
@@ -1124,12 +854,6 @@ theorem traverse_eq (x) : FreeSemigroup.traverse F x = traverse F x :=
 #align free_add_semigroup.traverse_eq FreeAddSemigroup.traverse_eq
 -/
 
-/- warning: free_semigroup.mul_map_seq -> FreeSemigroup.mul_map_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (id.{succ (succ u1)} Type.{u1} (FreeSemigroup.{u1} α)) (Seq.seq.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Applicative.toHasSeq.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Monad.toApplicative.{u1, u1} (id.{succ (succ u1)} Type.{u1}) id.monad.{u1})) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (Functor.map.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Traversable.toFunctor.{u1} (id.{succ (succ u1)} Type.{u1}) id.traversable.{u1}) (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)))) x) y) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) x y)
-but is expected to have type
-  forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (Id.{u1} (FreeSemigroup.{u1} α)) (Seq.seq.{u1, u1} Id.{u1} (Applicative.toSeq.{u1, u1} Id.{u1} (Monad.toApplicative.{u1, u1} Id.{u1} Id.instMonadId.{u1})) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (Functor.map.{u1, u1} Id.{u1} (Traversable.toFunctor.{u1} Id.{u1} instTraversableId.{u1}) (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) (fun (x._@.Mathlib.Algebra.Free._hyg.6426 : FreeSemigroup.{u1} α) (x._@.Mathlib.Algebra.Free._hyg.6428 : FreeSemigroup.{u1} α) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x._@.Mathlib.Algebra.Free._hyg.6426 x._@.Mathlib.Algebra.Free._hyg.6428) x) (fun (x._@.Mathlib.Algebra.Free._hyg.6443 : Unit) => y)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)
-Case conversion may be inaccurate. Consider using '#align free_semigroup.mul_map_seq FreeSemigroup.mul_map_seqₓ'. -/
 @[simp, to_additive]
 theorem mul_map_seq (x y : FreeSemigroup α) :
     ((· * ·) <$> x <*> y : id (FreeSemigroup α)) = (x * y : FreeSemigroup α) :=
@@ -1168,12 +892,6 @@ namespace FreeMagma
 
 variable {α : Type u} {β : Type v}
 
-/- warning: free_magma.to_free_semigroup -> FreeMagma.toFreeSemigroup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, MulHom.{u1, u1} (FreeMagma.{u1} α) (FreeSemigroup.{u1} α) (FreeMagma.hasMul.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}}, MulHom.{u1, u1} (FreeMagma.{u1} α) (FreeSemigroup.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))
-Case conversion may be inaccurate. Consider using '#align free_magma.to_free_semigroup FreeMagma.toFreeSemigroupₓ'. -/
 /-- The canonical multiplicative morphism from `free_magma α` to `free_semigroup α`. -/
 @[to_additive "The canonical additive morphism from `free_add_magma α` to `free_add_semigroup α`."]
 def toFreeSemigroup : FreeMagma α →ₙ* FreeSemigroup α :=
@@ -1195,12 +913,6 @@ theorem toFreeSemigroup_comp_of : @toFreeSemigroup α ∘ of = FreeSemigroup.of
 #align free_magma.to_free_semigroup_comp_of FreeMagma.toFreeSemigroup_comp_of
 -/
 
-/- warning: free_magma.to_free_semigroup_comp_map -> FreeMagma.toFreeSemigroup_comp_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β), Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (FreeMagma.{u1} α) (FreeSemigroup.{u2} β) (FreeMagma.hasMul.{u1} α) (Semigroup.toHasMul.{u2} (FreeSemigroup.{u2} β) (FreeSemigroup.semigroup.{u2} β))) (MulHom.comp.{u1, u2, u2} (FreeMagma.{u1} α) (FreeMagma.{u2} β) (FreeSemigroup.{u2} β) (FreeMagma.hasMul.{u1} α) (FreeMagma.hasMul.{u2} β) (Semigroup.toHasMul.{u2} (FreeSemigroup.{u2} β) (FreeSemigroup.semigroup.{u2} β)) (FreeMagma.toFreeSemigroup.{u2} β) (FreeMagma.map.{u1, u2} α β f)) (MulHom.comp.{u1, u1, u2} (FreeMagma.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u2} β) (FreeMagma.hasMul.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} (FreeSemigroup.{u2} β) (FreeSemigroup.semigroup.{u2} β)) (FreeSemigroup.map.{u1, u2} α β f) (FreeMagma.toFreeSemigroup.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β), Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeMagma.{u1} α) (FreeSemigroup.{u2} β) (FreeMagma.instMulFreeMagma.{u1} α) (Semigroup.toMul.{u2} (FreeSemigroup.{u2} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u2} β))) (MulHom.comp.{u1, u2, u2} (FreeMagma.{u1} α) (FreeMagma.{u2} β) (FreeSemigroup.{u2} β) (FreeMagma.instMulFreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u2} β) (Semigroup.toMul.{u2} (FreeSemigroup.{u2} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u2} β)) (FreeMagma.toFreeSemigroup.{u2} β) (FreeMagma.map.{u1, u2} α β f)) (MulHom.comp.{u1, u1, u2} (FreeMagma.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u2} β) (FreeMagma.instMulFreeMagma.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} (FreeSemigroup.{u2} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u2} β)) (FreeSemigroup.map.{u1, u2} α β f) (FreeMagma.toFreeSemigroup.{u1} α))
-Case conversion may be inaccurate. Consider using '#align free_magma.to_free_semigroup_comp_map FreeMagma.toFreeSemigroup_comp_mapₓ'. -/
 @[to_additive]
 theorem toFreeSemigroup_comp_map (f : α → β) :
     toFreeSemigroup.comp (map f) = (FreeSemigroup.map f).comp toFreeSemigroup := by ext1; rfl
@@ -1224,12 +936,6 @@ theorem length_toFreeSemigroup (x : FreeMagma α) : x.toFreeSemigroup.length = x
 
 end FreeMagma
 
-/- warning: free_magma_assoc_quotient_equiv -> FreeMagmaAssocQuotientEquiv is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}), MulEquiv.{u1, u1} (Magma.AssocQuotient.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)) (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)) (Magma.AssocQuotient.semigroup.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α))) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))
-but is expected to have type
-  forall (α : Type.{u1}), MulEquiv.{u1, u1} (Magma.AssocQuotient.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α))) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))
-Case conversion may be inaccurate. Consider using '#align free_magma_assoc_quotient_equiv FreeMagmaAssocQuotientEquivₓ'. -/
 /-- Isomorphism between `magma.assoc_quotient (free_magma α)` and `free_semigroup α`. -/
 @[to_additive
       "Isomorphism between\n`add_magma.assoc_quotient (free_add_magma α)` and `free_add_semigroup α`."]

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

@@ -93,10 +93,7 @@ def recOnMul {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (of x))
 #print FreeMagma.hom_ext /-
 @[ext, to_additive]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeMagma α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
-  FunLike.ext _ _ fun x =>
-    recOnMul x (congr_fun h) <| by
-      intros
-      simp only [map_mul, *]
+  FunLike.ext _ _ fun x => recOnMul x (congr_fun h) <| by intros ; simp only [map_mul, *]
 #align free_magma.hom_ext FreeMagma.hom_ext
 #align free_add_magma.hom_ext FreeAddMagma.hom_ext
 -/
@@ -138,12 +135,8 @@ def lift : (α → β) ≃ (FreeMagma α →ₙ* β)
     { toFun := liftAux f
       map_mul' := fun x y => rfl }
   invFun F := F ∘ of
-  left_inv f := by
-    ext
-    rfl
-  right_inv F := by
-    ext
-    rfl
+  left_inv f := by ext; rfl
+  right_inv F := by ext; rfl
 #align free_magma.lift FreeMagma.lift
 #align free_add_magma.lift FreeAddMagma.lift
 -/
@@ -1210,10 +1203,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align free_magma.to_free_semigroup_comp_map FreeMagma.toFreeSemigroup_comp_mapₓ'. -/
 @[to_additive]
 theorem toFreeSemigroup_comp_map (f : α → β) :
-    toFreeSemigroup.comp (map f) = (FreeSemigroup.map f).comp toFreeSemigroup :=
-  by
-  ext1
-  rfl
+    toFreeSemigroup.comp (map f) = (FreeSemigroup.map f).comp toFreeSemigroup := by ext1; rfl
 #align free_magma.to_free_semigroup_comp_map FreeMagma.toFreeSemigroup_comp_map
 
 #print FreeMagma.toFreeSemigroup_map /-
@@ -1246,12 +1236,6 @@ Case conversion may be inaccurate. Consider using '#align free_magma_assoc_quoti
 def FreeMagmaAssocQuotientEquiv (α : Type u) :
     Magma.AssocQuotient (FreeMagma α) ≃* FreeSemigroup α :=
   (Magma.AssocQuotient.lift FreeMagma.toFreeSemigroup).toMulEquiv
-    (FreeSemigroup.lift (Magma.AssocQuotient.of ∘ FreeMagma.of))
-    (by
-      ext
-      rfl)
-    (by
-      ext1
-      rfl)
+    (FreeSemigroup.lift (Magma.AssocQuotient.of ∘ FreeMagma.of)) (by ext; rfl) (by ext1; rfl)
 #align free_magma_assoc_quotient_equiv FreeMagmaAssocQuotientEquiv
 

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

@@ -152,7 +152,7 @@ def lift : (α → β) ≃ (FreeMagma α →ₙ* β)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) => (FreeMagma.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) => (α -> β) -> (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f) (FreeMagma.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeMagma.{u1} α) => β) (FreeMagma.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f) (FreeMagma.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeMagma.{u1} α) => β) (FreeMagma.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f) (FreeMagma.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_magma.lift_of FreeMagma.lift_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_of (x) : lift f (of x) = f x :=
@@ -164,7 +164,7 @@ theorem lift_of (x) : lift f (of x) = f x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeMagma.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) => (FreeMagma.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) => (α -> β) -> (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f)) (FreeMagma.of.{u1} α)) f
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeMagma.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f)) (FreeMagma.of.{u1} α)) f
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeMagma.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f)) (FreeMagma.of.{u1} α)) f
 Case conversion may be inaccurate. Consider using '#align free_magma.lift_comp_of FreeMagma.lift_comp_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of : lift f ∘ of = f :=
@@ -282,7 +282,7 @@ theorem mul_bind (f : α → FreeMagma β) (x y : FreeMagma α) : x * y >>= f =
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Applicative.toHasSeq.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.monad.{u1})) α β (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Applicative.toHasPure.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.monad.{u1})) (α -> β) f) x) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) (α -> β) f) (fun (x._@.Mathlib.Algebra.Free._hyg.1875 : Unit) => x)) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f x)
+  forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) (α -> β) f) (fun (x._@.Mathlib.Algebra.Free._hyg.1879 : Unit) => x)) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f x)
 Case conversion may be inaccurate. Consider using '#align free_magma.pure_seq FreeMagma.pure_seqₓ'. -/
 @[simp, to_additive]
 theorem pure_seq {α β : Type u} {f : α → β} {x : FreeMagma α} : pure f <*> x = f <$> x :=
@@ -294,7 +294,7 @@ theorem pure_seq {α β : Type u} {f : α → β} {x : FreeMagma α} : pure f <*
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeMagma.{u1} (α -> β)} {g : FreeMagma.{u1} (α -> β)} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toHasSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (instHMul.{u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.hasMul.{u1} (α -> β))) f g) x) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.hasMul.{u1} β)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toHasSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toHasSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β g x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeMagma.{u1} (α -> β)} {g : FreeMagma.{u1} (α -> β)} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (instHMul.{u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.instMulFreeMagma.{u1} (α -> β))) f g) (fun (x._@.Mathlib.Algebra.Free._hyg.1917 : Unit) => x)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f (fun (x._@.Mathlib.Algebra.Free._hyg.1928 : Unit) => x)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β g (fun (x._@.Mathlib.Algebra.Free._hyg.1938 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeMagma.{u1} (α -> β)} {g : FreeMagma.{u1} (α -> β)} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (instHMul.{u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.instMulFreeMagma.{u1} (α -> β))) f g) (fun (x._@.Mathlib.Algebra.Free._hyg.1921 : Unit) => x)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f (fun (x._@.Mathlib.Algebra.Free._hyg.1932 : Unit) => x)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β g (fun (x._@.Mathlib.Algebra.Free._hyg.1942 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_magma.mul_seq FreeMagma.mul_seqₓ'. -/
 @[simp, to_additive]
 theorem mul_seq {α β : Type u} {f g : FreeMagma (α → β)} {x : FreeMagma α} :
@@ -378,7 +378,7 @@ theorem traverse_pure' : traverse F ∘ pure = fun x => (pure <$> F x : m (FreeM
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.traversable.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)) x y)) (Seq.seq.{u1, u1} m (Applicative.toHasSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.hasMul.{u1} β))) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.traversable.{u1} m _inst_1 α β F x)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.traversable.{u1} m _inst_1 α β F y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y)) (Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.2519 : FreeMagma.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.2521 : FreeMagma.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) x._@.Mathlib.Algebra.Free._hyg.2519 x._@.Mathlib.Algebra.Free._hyg.2521) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.2538 : Unit) => Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F y))
+  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y)) (Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.2525 : FreeMagma.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.2527 : FreeMagma.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) x._@.Mathlib.Algebra.Free._hyg.2525 x._@.Mathlib.Algebra.Free._hyg.2527) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.2544 : Unit) => Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F y))
 Case conversion may be inaccurate. Consider using '#align free_magma.traverse_mul FreeMagma.traverse_mulₓ'. -/
 @[simp, to_additive]
 theorem traverse_mul (x y : FreeMagma α) :
@@ -391,7 +391,7 @@ theorem traverse_mul (x y : FreeMagma α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)), Eq.{succ u1} ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) ((FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.traversable.{u1} m _inst_1 α β F)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)))) (fun (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toHasSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.hasMul.{u1} β))) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.traversable.{u1} m _inst_1 α β F x)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.traversable.{u1} m _inst_1 α β F y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)), Eq.{succ u1} ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) ((FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F)) (Mul.mul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α))) (fun (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.2587 : FreeMagma.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.2589 : FreeMagma.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) x._@.Mathlib.Algebra.Free._hyg.2587 x._@.Mathlib.Algebra.Free._hyg.2589) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.2606 : Unit) => Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F y))
+  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)), Eq.{succ u1} ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) ((FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F)) (Mul.mul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α))) (fun (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.2593 : FreeMagma.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.2595 : FreeMagma.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) x._@.Mathlib.Algebra.Free._hyg.2593 x._@.Mathlib.Algebra.Free._hyg.2595) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.2612 : Unit) => Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F y))
 Case conversion may be inaccurate. Consider using '#align free_magma.traverse_mul' FreeMagma.traverse_mul'ₓ'. -/
 @[simp, to_additive]
 theorem traverse_mul' :
@@ -413,7 +413,7 @@ theorem traverse_eq (x) : FreeMagma.traverse F x = traverse F x :=
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (id.{succ (succ u1)} Type.{u1} (FreeMagma.{u1} α)) (Seq.seq.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Applicative.toHasSeq.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Monad.toApplicative.{u1, u1} (id.{succ (succ u1)} Type.{u1}) id.monad.{u1})) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (Functor.map.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Traversable.toFunctor.{u1} (id.{succ (succ u1)} Type.{u1}) id.traversable.{u1}) (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α))) x) y) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)) x y)
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (Id.{u1} (FreeMagma.{u1} α)) (Seq.seq.{u1, u1} Id.{u1} (Applicative.toSeq.{u1, u1} Id.{u1} (Monad.toApplicative.{u1, u1} Id.{u1} Id.instMonadId.{u1})) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (Functor.map.{u1, u1} Id.{u1} (Traversable.toFunctor.{u1} Id.{u1} instTraversableId.{u1}) (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) (fun (x._@.Mathlib.Algebra.Free._hyg.2675 : FreeMagma.{u1} α) (x._@.Mathlib.Algebra.Free._hyg.2677 : FreeMagma.{u1} α) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x._@.Mathlib.Algebra.Free._hyg.2675 x._@.Mathlib.Algebra.Free._hyg.2677) x) (fun (x._@.Mathlib.Algebra.Free._hyg.2692 : Unit) => y)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y)
+  forall {α : Type.{u1}} (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (Id.{u1} (FreeMagma.{u1} α)) (Seq.seq.{u1, u1} Id.{u1} (Applicative.toSeq.{u1, u1} Id.{u1} (Monad.toApplicative.{u1, u1} Id.{u1} Id.instMonadId.{u1})) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (Functor.map.{u1, u1} Id.{u1} (Traversable.toFunctor.{u1} Id.{u1} instTraversableId.{u1}) (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) (fun (x._@.Mathlib.Algebra.Free._hyg.2681 : FreeMagma.{u1} α) (x._@.Mathlib.Algebra.Free._hyg.2683 : FreeMagma.{u1} α) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x._@.Mathlib.Algebra.Free._hyg.2681 x._@.Mathlib.Algebra.Free._hyg.2683) x) (fun (x._@.Mathlib.Algebra.Free._hyg.2698 : Unit) => y)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y)
 Case conversion may be inaccurate. Consider using '#align free_magma.mul_map_seq FreeMagma.mul_map_seqₓ'. -/
 @[simp, to_additive]
 theorem mul_map_seq (x y : FreeMagma α) :
@@ -631,7 +631,7 @@ def lift : (α →ₙ* β) ≃ (AssocQuotient α →ₙ* β)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) => (Magma.AssocQuotient.{u1} α _inst_1) -> β) (MulHom.hasCoeToFun.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) (coeFn.{max 1 (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) => (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) -> (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (coeFn.{succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))) (fun (_x : MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))) => α -> (Magma.AssocQuotient.{u1} α _inst_1)) (MulHom.hasCoeToFun.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) => α -> β) (MulHom.hasCoeToFun.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) f x)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Magma.AssocQuotient.{u1} α _inst_1) => β) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => Magma.AssocQuotient.{u1} α _inst_1) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) (fun (_x : Magma.AssocQuotient.{u1} α _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Magma.AssocQuotient.{u1} α _inst_1) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => Magma.AssocQuotient.{u1} α _inst_1) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α β _inst_1 (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2))) f x)
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Magma.AssocQuotient.{u1} α _inst_1) => β) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => Magma.AssocQuotient.{u1} α _inst_1) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) (fun (_x : Magma.AssocQuotient.{u1} α _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Magma.AssocQuotient.{u1} α _inst_1) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => Magma.AssocQuotient.{u1} α _inst_1) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α β _inst_1 (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2))) f x)
 Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.lift_of Magma.AssocQuotient.lift_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_of (x : α) : lift f (of x) = f x :=
@@ -643,7 +643,7 @@ theorem lift_of (x : α) : lift f (of x) = f x :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)), Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2) (coeFn.{max 1 (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) => (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) -> (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (Magma.AssocQuotient.of.{u1} α _inst_1)) f
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)), Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (Magma.AssocQuotient.of.{u1} α _inst_1)) f
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)), Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (Magma.AssocQuotient.of.{u1} α _inst_1)) f
 Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.lift_comp_of Magma.AssocQuotient.lift_comp_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of : (lift f).comp of = f :=
@@ -655,7 +655,7 @@ theorem lift_comp_of : (lift f).comp of = f :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)), Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) (coeFn.{max 1 (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) => (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) -> (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) f
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) f
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) f
 Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.lift_comp_of' Magma.AssocQuotient.lift_comp_of'ₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of' (f : AssocQuotient α →ₙ* β) : lift (f.comp of) = f :=
@@ -820,7 +820,7 @@ protected def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (of
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] {f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1} {g : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1}, (Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) f) (FreeSemigroup.of.{u1} α)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) g) (FreeSemigroup.of.{u1} α))) -> (Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) f g)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] {f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1} {g : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1}, (Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) f) (FreeSemigroup.of.{u1} α)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) g) (FreeSemigroup.of.{u1} α))) -> (Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) f g)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] {f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1} {g : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1}, (Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) f) (FreeSemigroup.of.{u1} α)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) g) (FreeSemigroup.of.{u1} α))) -> (Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) f g)
 Case conversion may be inaccurate. Consider using '#align free_semigroup.hom_ext FreeSemigroup.hom_extₓ'. -/
 @[ext, to_additive]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeSemigroup α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
@@ -861,7 +861,7 @@ def lift : (α → β) ≃ (FreeSemigroup α →ₙ* β)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) => (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f) (FreeSemigroup.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) (FreeSemigroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f) (FreeSemigroup.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) (FreeSemigroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f) (FreeSemigroup.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_semigroup.lift_of FreeSemigroup.lift_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_of (x : α) : lift f (of x) = f x :=
@@ -873,7 +873,7 @@ theorem lift_of (x : α) : lift f (of x) = f x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) => (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f)) (FreeSemigroup.of.{u1} α)) f
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f)) (FreeSemigroup.of.{u1} α)) f
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f)) (FreeSemigroup.of.{u1} α)) f
 Case conversion may be inaccurate. Consider using '#align free_semigroup.lift_comp_of FreeSemigroup.lift_comp_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of : lift f ∘ of = f :=
@@ -885,7 +885,7 @@ theorem lift_comp_of : lift f ∘ of = f :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)), Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) => (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) f) (FreeSemigroup.of.{u1} α))) f
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (a : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) (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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) f
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (a : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) (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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) f
 Case conversion may be inaccurate. Consider using '#align free_semigroup.lift_comp_of' FreeSemigroup.lift_comp_of'ₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of' (f : FreeSemigroup α →ₙ* β) : lift (f ∘ of) = f :=
@@ -1013,7 +1013,7 @@ theorem mul_bind (f : α → FreeSemigroup β) (x y : FreeSemigroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Applicative.toHasSeq.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.monad.{u1})) α β (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Applicative.toHasPure.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.monad.{u1})) (α -> β) f) x) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.Algebra.Free._hyg.5531 : Unit) => x)) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f x)
+  forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.Algebra.Free._hyg.5541 : Unit) => x)) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f x)
 Case conversion may be inaccurate. Consider using '#align free_semigroup.pure_seq FreeSemigroup.pure_seqₓ'. -/
 @[simp, to_additive]
 theorem pure_seq {f : α → β} {x : FreeSemigroup α} : pure f <*> x = f <$> x :=
@@ -1025,7 +1025,7 @@ theorem pure_seq {f : α → β} {x : FreeSemigroup α} : pure f <*> x = f <$> x
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeSemigroup.{u1} (α -> β)} {g : FreeSemigroup.{u1} (α -> β)} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (instHMul.{u1} (FreeSemigroup.{u1} (α -> β)) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.semigroup.{u1} (α -> β)))) f g) x) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.semigroup.{u1} β))) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β g x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeSemigroup.{u1} (α -> β)} {g : FreeSemigroup.{u1} (α -> β)} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (instHMul.{u1} (FreeSemigroup.{u1} (α -> β)) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} (α -> β)))) f g) (fun (x._@.Mathlib.Algebra.Free._hyg.5571 : Unit) => x)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f (fun (x._@.Mathlib.Algebra.Free._hyg.5582 : Unit) => x)) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β g (fun (x._@.Mathlib.Algebra.Free._hyg.5592 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeSemigroup.{u1} (α -> β)} {g : FreeSemigroup.{u1} (α -> β)} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (instHMul.{u1} (FreeSemigroup.{u1} (α -> β)) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} (α -> β)))) f g) (fun (x._@.Mathlib.Algebra.Free._hyg.5581 : Unit) => x)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f (fun (x._@.Mathlib.Algebra.Free._hyg.5592 : Unit) => x)) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β g (fun (x._@.Mathlib.Algebra.Free._hyg.5602 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_semigroup.mul_seq FreeSemigroup.mul_seqₓ'. -/
 @[simp, to_additive]
 theorem mul_seq {f g : FreeSemigroup (α → β)} {x : FreeSemigroup α} :
@@ -1090,7 +1090,7 @@ variable [LawfulApplicative m]
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1] (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.traversable.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) x y)) (Seq.seq.{u1, u1} m (Applicative.toHasSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.semigroup.{u1} β)))) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.traversable.{u1} m _inst_1 α β F x)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.traversable.{u1} m _inst_1 α β F y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1] (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)) (Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.6019 : FreeSemigroup.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.6021 : FreeSemigroup.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) x._@.Mathlib.Algebra.Free._hyg.6019 x._@.Mathlib.Algebra.Free._hyg.6021) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.6038 : Unit) => Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F y))
+  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1] (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)) (Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.6029 : FreeSemigroup.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.6031 : FreeSemigroup.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) x._@.Mathlib.Algebra.Free._hyg.6029 x._@.Mathlib.Algebra.Free._hyg.6031) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.6048 : Unit) => Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F y))
 Case conversion may be inaccurate. Consider using '#align free_semigroup.traverse_mul FreeSemigroup.traverse_mulₓ'. -/
 @[simp, to_additive]
 theorem traverse_mul (x y : FreeSemigroup α) :
@@ -1111,7 +1111,7 @@ theorem traverse_mul (x y : FreeSemigroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1], Eq.{succ u1} ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) ((FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.traversable.{u1} m _inst_1 α β F)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))))) (fun (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toHasSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.semigroup.{u1} β)))) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.traversable.{u1} m _inst_1 α β F x)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.traversable.{u1} m _inst_1 α β F y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1], Eq.{succ u1} ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) ((FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F)) (Mul.mul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)))) (fun (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.6314 : FreeSemigroup.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.6316 : FreeSemigroup.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) x._@.Mathlib.Algebra.Free._hyg.6314 x._@.Mathlib.Algebra.Free._hyg.6316) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.6333 : Unit) => Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F y))
+  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1], Eq.{succ u1} ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) ((FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F)) (Mul.mul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)))) (fun (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.6326 : FreeSemigroup.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.6328 : FreeSemigroup.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) x._@.Mathlib.Algebra.Free._hyg.6326 x._@.Mathlib.Algebra.Free._hyg.6328) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.6345 : Unit) => Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F y))
 Case conversion may be inaccurate. Consider using '#align free_semigroup.traverse_mul' FreeSemigroup.traverse_mul'ₓ'. -/
 @[simp, to_additive]
 theorem traverse_mul' :
@@ -1135,7 +1135,7 @@ theorem traverse_eq (x) : FreeSemigroup.traverse F x = traverse F x :=
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (id.{succ (succ u1)} Type.{u1} (FreeSemigroup.{u1} α)) (Seq.seq.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Applicative.toHasSeq.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Monad.toApplicative.{u1, u1} (id.{succ (succ u1)} Type.{u1}) id.monad.{u1})) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (Functor.map.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Traversable.toFunctor.{u1} (id.{succ (succ u1)} Type.{u1}) id.traversable.{u1}) (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)))) x) y) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) x y)
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (Id.{u1} (FreeSemigroup.{u1} α)) (Seq.seq.{u1, u1} Id.{u1} (Applicative.toSeq.{u1, u1} Id.{u1} (Monad.toApplicative.{u1, u1} Id.{u1} Id.instMonadId.{u1})) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (Functor.map.{u1, u1} Id.{u1} (Traversable.toFunctor.{u1} Id.{u1} instTraversableId.{u1}) (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) (fun (x._@.Mathlib.Algebra.Free._hyg.6414 : FreeSemigroup.{u1} α) (x._@.Mathlib.Algebra.Free._hyg.6416 : FreeSemigroup.{u1} α) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x._@.Mathlib.Algebra.Free._hyg.6414 x._@.Mathlib.Algebra.Free._hyg.6416) x) (fun (x._@.Mathlib.Algebra.Free._hyg.6431 : Unit) => y)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)
+  forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (Id.{u1} (FreeSemigroup.{u1} α)) (Seq.seq.{u1, u1} Id.{u1} (Applicative.toSeq.{u1, u1} Id.{u1} (Monad.toApplicative.{u1, u1} Id.{u1} Id.instMonadId.{u1})) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (Functor.map.{u1, u1} Id.{u1} (Traversable.toFunctor.{u1} Id.{u1} instTraversableId.{u1}) (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) (fun (x._@.Mathlib.Algebra.Free._hyg.6426 : FreeSemigroup.{u1} α) (x._@.Mathlib.Algebra.Free._hyg.6428 : FreeSemigroup.{u1} α) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x._@.Mathlib.Algebra.Free._hyg.6426 x._@.Mathlib.Algebra.Free._hyg.6428) x) (fun (x._@.Mathlib.Algebra.Free._hyg.6443 : Unit) => y)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)
 Case conversion may be inaccurate. Consider using '#align free_semigroup.mul_map_seq FreeSemigroup.mul_map_seqₓ'. -/
 @[simp, to_additive]
 theorem mul_map_seq (x y : FreeSemigroup α) :

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

@@ -152,7 +152,7 @@ def lift : (α → β) ≃ (FreeMagma α →ₙ* β)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) => (FreeMagma.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) => (α -> β) -> (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f) (FreeMagma.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeMagma.{u1} α) => β) (FreeMagma.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f) (FreeMagma.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeMagma.{u1} α) => β) (FreeMagma.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f) (FreeMagma.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_magma.lift_of FreeMagma.lift_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_of (x) : lift f (of x) = f x :=
@@ -164,7 +164,7 @@ theorem lift_of (x) : lift f (of x) = f x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeMagma.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) => (FreeMagma.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) => (α -> β) -> (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f)) (FreeMagma.of.{u1} α)) f
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeMagma.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f)) (FreeMagma.of.{u1} α)) f
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeMagma.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f)) (FreeMagma.of.{u1} α)) f
 Case conversion may be inaccurate. Consider using '#align free_magma.lift_comp_of FreeMagma.lift_comp_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of : lift f ∘ of = f :=
@@ -282,7 +282,7 @@ theorem mul_bind (f : α → FreeMagma β) (x y : FreeMagma α) : x * y >>= f =
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Applicative.toHasSeq.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.monad.{u1})) α β (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Applicative.toHasPure.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.monad.{u1})) (α -> β) f) x) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) (α -> β) f) (fun (x._@.Mathlib.Algebra.Free._hyg.1862 : Unit) => x)) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f x)
+  forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β (Pure.pure.{u1, u1} FreeMagma.{u1} (Applicative.toPure.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) (α -> β) f) (fun (x._@.Mathlib.Algebra.Free._hyg.1875 : Unit) => x)) (Functor.map.{u1, u1} FreeMagma.{u1} (Applicative.toFunctor.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f x)
 Case conversion may be inaccurate. Consider using '#align free_magma.pure_seq FreeMagma.pure_seqₓ'. -/
 @[simp, to_additive]
 theorem pure_seq {α β : Type u} {f : α → β} {x : FreeMagma α} : pure f <*> x = f <$> x :=
@@ -294,7 +294,7 @@ theorem pure_seq {α β : Type u} {f : α → β} {x : FreeMagma α} : pure f <*
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeMagma.{u1} (α -> β)} {g : FreeMagma.{u1} (α -> β)} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toHasSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (instHMul.{u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.hasMul.{u1} (α -> β))) f g) x) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.hasMul.{u1} β)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toHasSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toHasSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.monad.{u1})) α β g x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeMagma.{u1} (α -> β)} {g : FreeMagma.{u1} (α -> β)} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (instHMul.{u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.instMulFreeMagma.{u1} (α -> β))) f g) (fun (x._@.Mathlib.Algebra.Free._hyg.1904 : Unit) => x)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f (fun (x._@.Mathlib.Algebra.Free._hyg.1915 : Unit) => x)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β g (fun (x._@.Mathlib.Algebra.Free._hyg.1925 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeMagma.{u1} (α -> β)} {g : FreeMagma.{u1} (α -> β)} {x : FreeMagma.{u1} α}, Eq.{succ u1} (FreeMagma.{u1} β) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (FreeMagma.{u1} (α -> β)) (instHMul.{u1} (FreeMagma.{u1} (α -> β)) (FreeMagma.instMulFreeMagma.{u1} (α -> β))) f g) (fun (x._@.Mathlib.Algebra.Free._hyg.1917 : Unit) => x)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β f (fun (x._@.Mathlib.Algebra.Free._hyg.1928 : Unit) => x)) (Seq.seq.{u1, u1} FreeMagma.{u1} (Applicative.toSeq.{u1, u1} FreeMagma.{u1} (Monad.toApplicative.{u1, u1} FreeMagma.{u1} FreeMagma.instMonadFreeMagma.{u1})) α β g (fun (x._@.Mathlib.Algebra.Free._hyg.1938 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_magma.mul_seq FreeMagma.mul_seqₓ'. -/
 @[simp, to_additive]
 theorem mul_seq {α β : Type u} {f g : FreeMagma (α → β)} {x : FreeMagma α} :
@@ -378,7 +378,7 @@ theorem traverse_pure' : traverse F ∘ pure = fun x => (pure <$> F x : m (FreeM
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.traversable.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)) x y)) (Seq.seq.{u1, u1} m (Applicative.toHasSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.hasMul.{u1} β))) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.traversable.{u1} m _inst_1 α β F x)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.traversable.{u1} m _inst_1 α β F y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y)) (Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.2506 : FreeMagma.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.2508 : FreeMagma.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) x._@.Mathlib.Algebra.Free._hyg.2506 x._@.Mathlib.Algebra.Free._hyg.2508) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.2525 : Unit) => Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F y))
+  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y)) (Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.2519 : FreeMagma.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.2521 : FreeMagma.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) x._@.Mathlib.Algebra.Free._hyg.2519 x._@.Mathlib.Algebra.Free._hyg.2521) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.2538 : Unit) => Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F y))
 Case conversion may be inaccurate. Consider using '#align free_magma.traverse_mul FreeMagma.traverse_mulₓ'. -/
 @[simp, to_additive]
 theorem traverse_mul (x y : FreeMagma α) :
@@ -391,7 +391,7 @@ theorem traverse_mul (x y : FreeMagma α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)), Eq.{succ u1} ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) ((FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeMagma.{u1} α) FreeMagma.traversable.{u1} m _inst_1 α β F)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)))) (fun (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toHasSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.hasMul.{u1} β))) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.traversable.{u1} m _inst_1 α β F x)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.traversable.{u1} m _inst_1 α β F y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)), Eq.{succ u1} ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) ((FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F)) (Mul.mul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α))) (fun (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.2574 : FreeMagma.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.2576 : FreeMagma.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) x._@.Mathlib.Algebra.Free._hyg.2574 x._@.Mathlib.Algebra.Free._hyg.2576) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.2593 : Unit) => Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F y))
+  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)), Eq.{succ u1} ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) ((FreeMagma.{u1} α) -> (m (FreeMagma.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (m (FreeMagma.{u1} β)) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F)) (Mul.mul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α))) (fun (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeMagma.{u1} β) ((FreeMagma.{u1} β) -> (FreeMagma.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.2587 : FreeMagma.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.2589 : FreeMagma.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} β) (FreeMagma.{u1} β) (FreeMagma.{u1} β) (instHMul.{u1} (FreeMagma.{u1} β) (FreeMagma.instMulFreeMagma.{u1} β)) x._@.Mathlib.Algebra.Free._hyg.2587 x._@.Mathlib.Algebra.Free._hyg.2589) (Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.2606 : Unit) => Traversable.traverse.{u1} FreeMagma.{u1} FreeMagma.instTraversableFreeMagma.{u1} m _inst_1 α β F y))
 Case conversion may be inaccurate. Consider using '#align free_magma.traverse_mul' FreeMagma.traverse_mul'ₓ'. -/
 @[simp, to_additive]
 theorem traverse_mul' :
@@ -413,7 +413,7 @@ theorem traverse_eq (x) : FreeMagma.traverse F x = traverse F x :=
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (id.{succ (succ u1)} Type.{u1} (FreeMagma.{u1} α)) (Seq.seq.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Applicative.toHasSeq.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Monad.toApplicative.{u1, u1} (id.{succ (succ u1)} Type.{u1}) id.monad.{u1})) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (Functor.map.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Traversable.toFunctor.{u1} (id.{succ (succ u1)} Type.{u1}) id.traversable.{u1}) (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α))) x) y) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.hasMul.{u1} α)) x y)
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (Id.{u1} (FreeMagma.{u1} α)) (Seq.seq.{u1, u1} Id.{u1} (Applicative.toSeq.{u1, u1} Id.{u1} (Monad.toApplicative.{u1, u1} Id.{u1} Id.instMonadId.{u1})) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (Functor.map.{u1, u1} Id.{u1} (Traversable.toFunctor.{u1} Id.{u1} instTraversableId.{u1}) (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) (fun (x._@.Mathlib.Algebra.Free._hyg.2662 : FreeMagma.{u1} α) (x._@.Mathlib.Algebra.Free._hyg.2664 : FreeMagma.{u1} α) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x._@.Mathlib.Algebra.Free._hyg.2662 x._@.Mathlib.Algebra.Free._hyg.2664) x) (fun (x._@.Mathlib.Algebra.Free._hyg.2679 : Unit) => y)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y)
+  forall {α : Type.{u1}} (x : FreeMagma.{u1} α) (y : FreeMagma.{u1} α), Eq.{succ u1} (Id.{u1} (FreeMagma.{u1} α)) (Seq.seq.{u1, u1} Id.{u1} (Applicative.toSeq.{u1, u1} Id.{u1} (Monad.toApplicative.{u1, u1} Id.{u1} Id.instMonadId.{u1})) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (Functor.map.{u1, u1} Id.{u1} (Traversable.toFunctor.{u1} Id.{u1} instTraversableId.{u1}) (FreeMagma.{u1} α) ((FreeMagma.{u1} α) -> (FreeMagma.{u1} α)) (fun (x._@.Mathlib.Algebra.Free._hyg.2675 : FreeMagma.{u1} α) (x._@.Mathlib.Algebra.Free._hyg.2677 : FreeMagma.{u1} α) => HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x._@.Mathlib.Algebra.Free._hyg.2675 x._@.Mathlib.Algebra.Free._hyg.2677) x) (fun (x._@.Mathlib.Algebra.Free._hyg.2692 : Unit) => y)) (HMul.hMul.{u1, u1, u1} (FreeMagma.{u1} α) (FreeMagma.{u1} α) (FreeMagma.{u1} α) (instHMul.{u1} (FreeMagma.{u1} α) (FreeMagma.instMulFreeMagma.{u1} α)) x y)
 Case conversion may be inaccurate. Consider using '#align free_magma.mul_map_seq FreeMagma.mul_map_seqₓ'. -/
 @[simp, to_additive]
 theorem mul_map_seq (x y : FreeMagma α) :
@@ -631,7 +631,7 @@ def lift : (α →ₙ* β) ≃ (AssocQuotient α →ₙ* β)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) => (Magma.AssocQuotient.{u1} α _inst_1) -> β) (MulHom.hasCoeToFun.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) (coeFn.{max 1 (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) => (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) -> (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (coeFn.{succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))) (fun (_x : MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))) => α -> (Magma.AssocQuotient.{u1} α _inst_1)) (MulHom.hasCoeToFun.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) => α -> β) (MulHom.hasCoeToFun.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) f x)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Magma.AssocQuotient.{u1} α _inst_1) => β) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => Magma.AssocQuotient.{u1} α _inst_1) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) (fun (_x : Magma.AssocQuotient.{u1} α _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Magma.AssocQuotient.{u1} α _inst_1) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => Magma.AssocQuotient.{u1} α _inst_1) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α β _inst_1 (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2))) f x)
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Magma.AssocQuotient.{u1} α _inst_1) => β) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => Magma.AssocQuotient.{u1} α _inst_1) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) (fun (_x : Magma.AssocQuotient.{u1} α _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Magma.AssocQuotient.{u1} α _inst_1) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => Magma.AssocQuotient.{u1} α _inst_1) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α β _inst_1 (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2))) f x)
 Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.lift_of Magma.AssocQuotient.lift_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_of (x : α) : lift f (of x) = f x :=
@@ -643,7 +643,7 @@ theorem lift_of (x : α) : lift f (of x) = f x :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)), Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2) (coeFn.{max 1 (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) => (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) -> (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (Magma.AssocQuotient.of.{u1} α _inst_1)) f
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)), Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (Magma.AssocQuotient.of.{u1} α _inst_1)) f
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)), Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (Magma.AssocQuotient.of.{u1} α _inst_1)) f
 Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.lift_comp_of Magma.AssocQuotient.lift_comp_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of : (lift f).comp of = f :=
@@ -655,7 +655,7 @@ theorem lift_comp_of : (lift f).comp of = f :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)), Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) (coeFn.{max 1 (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) => (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) -> (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) f
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) f
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) (MulHom.comp.{u1, u1, u2} α (Magma.AssocQuotient.{u1} α _inst_1) β _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) f (Magma.AssocQuotient.of.{u1} α _inst_1))) f
 Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.lift_comp_of' Magma.AssocQuotient.lift_comp_of'ₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of' (f : AssocQuotient α →ₙ* β) : lift (f.comp of) = f :=
@@ -820,7 +820,7 @@ protected def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (of
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] {f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1} {g : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1}, (Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) f) (FreeSemigroup.of.{u1} α)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) g) (FreeSemigroup.of.{u1} α))) -> (Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) f g)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] {f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1} {g : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1}, (Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) f) (FreeSemigroup.of.{u1} α)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) g) (FreeSemigroup.of.{u1} α))) -> (Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) f g)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] {f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1} {g : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1}, (Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) f) (FreeSemigroup.of.{u1} α)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) g) (FreeSemigroup.of.{u1} α))) -> (Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) f g)
 Case conversion may be inaccurate. Consider using '#align free_semigroup.hom_ext FreeSemigroup.hom_extₓ'. -/
 @[ext, to_additive]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeSemigroup α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
@@ -861,7 +861,7 @@ def lift : (α → β) ≃ (FreeSemigroup α →ₙ* β)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) => (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f) (FreeSemigroup.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) (FreeSemigroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f) (FreeSemigroup.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) (FreeSemigroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f) (FreeSemigroup.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_semigroup.lift_of FreeSemigroup.lift_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_of (x : α) : lift f (of x) = f x :=
@@ -873,7 +873,7 @@ theorem lift_of (x : α) : lift f (of x) = f x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) => (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f)) (FreeSemigroup.of.{u1} α)) f
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f)) (FreeSemigroup.of.{u1} α)) f
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f)) (FreeSemigroup.of.{u1} α)) f
 Case conversion may be inaccurate. Consider using '#align free_semigroup.lift_comp_of FreeSemigroup.lift_comp_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of : lift f ∘ of = f :=
@@ -885,7 +885,7 @@ theorem lift_comp_of : lift f ∘ of = f :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)), Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) => (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) f) (FreeSemigroup.of.{u1} α))) f
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (a : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) (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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) f
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (a : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) (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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) f
 Case conversion may be inaccurate. Consider using '#align free_semigroup.lift_comp_of' FreeSemigroup.lift_comp_of'ₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of' (f : FreeSemigroup α →ₙ* β) : lift (f ∘ of) = f :=
@@ -1013,7 +1013,7 @@ theorem mul_bind (f : α → FreeSemigroup β) (x y : FreeSemigroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Applicative.toHasSeq.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.monad.{u1})) α β (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Applicative.toHasPure.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) (Monad.toApplicative.{u1, u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.monad.{u1})) (α -> β) f) x) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.Algebra.Free._hyg.5485 : Unit) => x)) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f x)
+  forall {α : Type.{u1}} {β : Type.{u1}} {f : α -> β} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β (Pure.pure.{u1, u1} FreeSemigroup.{u1} (Applicative.toPure.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) (α -> β) f) (fun (x._@.Mathlib.Algebra.Free._hyg.5531 : Unit) => x)) (Functor.map.{u1, u1} FreeSemigroup.{u1} (Applicative.toFunctor.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f x)
 Case conversion may be inaccurate. Consider using '#align free_semigroup.pure_seq FreeSemigroup.pure_seqₓ'. -/
 @[simp, to_additive]
 theorem pure_seq {f : α → β} {x : FreeSemigroup α} : pure f <*> x = f <$> x :=
@@ -1025,7 +1025,7 @@ theorem pure_seq {f : α → β} {x : FreeSemigroup α} : pure f <*> x = f <$> x
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeSemigroup.{u1} (α -> β)} {g : FreeSemigroup.{u1} (α -> β)} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (instHMul.{u1} (FreeSemigroup.{u1} (α -> β)) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.semigroup.{u1} (α -> β)))) f g) x) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.semigroup.{u1} β))) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β f x) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toHasSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.monad.{u1})) α β g x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeSemigroup.{u1} (α -> β)} {g : FreeSemigroup.{u1} (α -> β)} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (instHMul.{u1} (FreeSemigroup.{u1} (α -> β)) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} (α -> β)))) f g) (fun (x._@.Mathlib.Algebra.Free._hyg.5525 : Unit) => x)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f (fun (x._@.Mathlib.Algebra.Free._hyg.5536 : Unit) => x)) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β g (fun (x._@.Mathlib.Algebra.Free._hyg.5546 : Unit) => x)))
+  forall {α : Type.{u1}} {β : Type.{u1}} {f : FreeSemigroup.{u1} (α -> β)} {g : FreeSemigroup.{u1} (α -> β)} {x : FreeSemigroup.{u1} α}, Eq.{succ u1} (FreeSemigroup.{u1} β) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.{u1} (α -> β)) (instHMul.{u1} (FreeSemigroup.{u1} (α -> β)) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} (α -> β)) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} (α -> β)))) f g) (fun (x._@.Mathlib.Algebra.Free._hyg.5571 : Unit) => x)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β f (fun (x._@.Mathlib.Algebra.Free._hyg.5582 : Unit) => x)) (Seq.seq.{u1, u1} FreeSemigroup.{u1} (Applicative.toSeq.{u1, u1} FreeSemigroup.{u1} (Monad.toApplicative.{u1, u1} FreeSemigroup.{u1} FreeSemigroup.instMonadFreeSemigroup.{u1})) α β g (fun (x._@.Mathlib.Algebra.Free._hyg.5592 : Unit) => x)))
 Case conversion may be inaccurate. Consider using '#align free_semigroup.mul_seq FreeSemigroup.mul_seqₓ'. -/
 @[simp, to_additive]
 theorem mul_seq {f g : FreeSemigroup (α → β)} {x : FreeSemigroup α} :
@@ -1090,7 +1090,7 @@ variable [LawfulApplicative m]
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1] (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.traversable.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) x y)) (Seq.seq.{u1, u1} m (Applicative.toHasSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.semigroup.{u1} β)))) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.traversable.{u1} m _inst_1 α β F x)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.traversable.{u1} m _inst_1 α β F y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1] (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)) (Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.5973 : FreeSemigroup.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.5975 : FreeSemigroup.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) x._@.Mathlib.Algebra.Free._hyg.5973 x._@.Mathlib.Algebra.Free._hyg.5975) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.5992 : Unit) => Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F y))
+  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1] (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)) (Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.6019 : FreeSemigroup.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.6021 : FreeSemigroup.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) x._@.Mathlib.Algebra.Free._hyg.6019 x._@.Mathlib.Algebra.Free._hyg.6021) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.6038 : Unit) => Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F y))
 Case conversion may be inaccurate. Consider using '#align free_semigroup.traverse_mul FreeSemigroup.traverse_mulₓ'. -/
 @[simp, to_additive]
 theorem traverse_mul (x y : FreeSemigroup α) :
@@ -1111,7 +1111,7 @@ theorem traverse_mul (x y : FreeSemigroup α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1], Eq.{succ u1} ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) ((FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} (fun {α : Type.{u1}} => FreeSemigroup.{u1} α) FreeSemigroup.traversable.{u1} m _inst_1 α β F)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))))) (fun (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toHasSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.semigroup.{u1} β)))) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.traversable.{u1} m _inst_1 α β F x)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.traversable.{u1} m _inst_1 α β F y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1], Eq.{succ u1} ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) ((FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F)) (Mul.mul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)))) (fun (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.6268 : FreeSemigroup.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.6270 : FreeSemigroup.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) x._@.Mathlib.Algebra.Free._hyg.6268 x._@.Mathlib.Algebra.Free._hyg.6270) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.6287 : Unit) => Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F y))
+  forall {α : Type.{u1}} {β : Type.{u1}} {m : Type.{u1} -> Type.{u1}} [_inst_1 : Applicative.{u1, u1} m] (F : α -> (m β)) [_inst_2 : LawfulApplicative.{u1, u1} m _inst_1], Eq.{succ u1} ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) ((FreeSemigroup.{u1} α) -> (m (FreeSemigroup.{u1} β))) (Function.comp.{succ u1, succ u1, succ u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (m (FreeSemigroup.{u1} β)) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F)) (Mul.mul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)))) (fun (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α) => Seq.seq.{u1, u1} m (Applicative.toSeq.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (Functor.map.{u1, u1} m (Applicative.toFunctor.{u1, u1} m _inst_1) (FreeSemigroup.{u1} β) ((FreeSemigroup.{u1} β) -> (FreeSemigroup.{u1} β)) (fun (x._@.Mathlib.Algebra.Free._hyg.6314 : FreeSemigroup.{u1} β) (x._@.Mathlib.Algebra.Free._hyg.6316 : FreeSemigroup.{u1} β) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (FreeSemigroup.{u1} β) (instHMul.{u1} (FreeSemigroup.{u1} β) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} β) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} β))) x._@.Mathlib.Algebra.Free._hyg.6314 x._@.Mathlib.Algebra.Free._hyg.6316) (Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F x)) (fun (x._@.Mathlib.Algebra.Free._hyg.6333 : Unit) => Traversable.traverse.{u1} FreeSemigroup.{u1} FreeSemigroup.instTraversableFreeSemigroup.{u1} m _inst_1 α β F y))
 Case conversion may be inaccurate. Consider using '#align free_semigroup.traverse_mul' FreeSemigroup.traverse_mul'ₓ'. -/
 @[simp, to_additive]
 theorem traverse_mul' :
@@ -1135,7 +1135,7 @@ theorem traverse_eq (x) : FreeSemigroup.traverse F x = traverse F x :=
 lean 3 declaration is
   forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (id.{succ (succ u1)} Type.{u1} (FreeSemigroup.{u1} α)) (Seq.seq.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Applicative.toHasSeq.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Monad.toApplicative.{u1, u1} (id.{succ (succ u1)} Type.{u1}) id.monad.{u1})) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (Functor.map.{u1, u1} (id.{succ (succ u1)} Type.{u1}) (Traversable.toFunctor.{u1} (id.{succ (succ u1)} Type.{u1}) id.traversable.{u1}) (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)))) x) y) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α))) x y)
 but is expected to have type
-  forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (Id.{u1} (FreeSemigroup.{u1} α)) (Seq.seq.{u1, u1} Id.{u1} (Applicative.toSeq.{u1, u1} Id.{u1} (Monad.toApplicative.{u1, u1} Id.{u1} Id.instMonadId.{u1})) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (Functor.map.{u1, u1} Id.{u1} (Traversable.toFunctor.{u1} Id.{u1} instTraversableId.{u1}) (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) (fun (x._@.Mathlib.Algebra.Free._hyg.6368 : FreeSemigroup.{u1} α) (x._@.Mathlib.Algebra.Free._hyg.6370 : FreeSemigroup.{u1} α) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x._@.Mathlib.Algebra.Free._hyg.6368 x._@.Mathlib.Algebra.Free._hyg.6370) x) (fun (x._@.Mathlib.Algebra.Free._hyg.6385 : Unit) => y)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)
+  forall {α : Type.{u1}} (x : FreeSemigroup.{u1} α) (y : FreeSemigroup.{u1} α), Eq.{succ u1} (Id.{u1} (FreeSemigroup.{u1} α)) (Seq.seq.{u1, u1} Id.{u1} (Applicative.toSeq.{u1, u1} Id.{u1} (Monad.toApplicative.{u1, u1} Id.{u1} Id.instMonadId.{u1})) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (Functor.map.{u1, u1} Id.{u1} (Traversable.toFunctor.{u1} Id.{u1} instTraversableId.{u1}) (FreeSemigroup.{u1} α) ((FreeSemigroup.{u1} α) -> (FreeSemigroup.{u1} α)) (fun (x._@.Mathlib.Algebra.Free._hyg.6414 : FreeSemigroup.{u1} α) (x._@.Mathlib.Algebra.Free._hyg.6416 : FreeSemigroup.{u1} α) => HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x._@.Mathlib.Algebra.Free._hyg.6414 x._@.Mathlib.Algebra.Free._hyg.6416) x) (fun (x._@.Mathlib.Algebra.Free._hyg.6431 : Unit) => y)) (HMul.hMul.{u1, u1, u1} (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (FreeSemigroup.{u1} α) (instHMul.{u1} (FreeSemigroup.{u1} α) (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α))) x y)
 Case conversion may be inaccurate. Consider using '#align free_semigroup.mul_map_seq FreeSemigroup.mul_map_seqₓ'. -/
 @[simp, to_additive]
 theorem mul_map_seq (x y : FreeSemigroup α) :

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

@@ -152,7 +152,7 @@ def lift : (α → β) ≃ (FreeMagma α →ₙ* β)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) => (FreeMagma.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) => (α -> β) -> (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f) (FreeMagma.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeMagma.{u1} α) => β) (FreeMagma.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f) (FreeMagma.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeMagma.{u1} α) => β) (FreeMagma.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f) (FreeMagma.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_magma.lift_of FreeMagma.lift_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_of (x) : lift f (of x) = f x :=
@@ -164,7 +164,7 @@ theorem lift_of (x) : lift f (of x) = f x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeMagma.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1) => (FreeMagma.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) => (α -> β) -> (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.hasMul.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f)) (FreeMagma.of.{u1} α)) f
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeMagma.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f)) (FreeMagma.of.{u1} α)) f
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeMagma.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) (fun (_x : FreeMagma.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeMagma.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) f) (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{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)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeMagma.{u1} α) β (FreeMagma.instMulFreeMagma.{u1} α) _inst_1)) (FreeMagma.lift.{u1, u2} α β _inst_1) f)) (FreeMagma.of.{u1} α)) f
 Case conversion may be inaccurate. Consider using '#align free_magma.lift_comp_of FreeMagma.lift_comp_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of : lift f ∘ of = f :=
@@ -631,7 +631,7 @@ def lift : (α →ₙ* β) ≃ (AssocQuotient α →ₙ* β)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) => (Magma.AssocQuotient.{u1} α _inst_1) -> β) (MulHom.hasCoeToFun.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2)) (coeFn.{max 1 (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (fun (_x : Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) => (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) -> (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Equiv.hasCoeToFun.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1)) (Semigroup.toHasMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (coeFn.{succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))) (fun (_x : MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))) => α -> (Magma.AssocQuotient.{u1} α _inst_1)) (MulHom.hasCoeToFun.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toHasMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.semigroup.{u1} α _inst_1))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) => α -> β) (MulHom.hasCoeToFun.{u1, u2} α β _inst_1 (Semigroup.toHasMul.{u2} β _inst_2)) f x)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Magma.AssocQuotient.{u1} α _inst_1) => β) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => Magma.AssocQuotient.{u1} α _inst_1) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) (fun (_x : Magma.AssocQuotient.{u1} α _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Magma.AssocQuotient.{u1} α _inst_1) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => Magma.AssocQuotient.{u1} α _inst_1) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α β _inst_1 (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2))) f x)
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {β : Type.{u2}} [_inst_2 : Semigroup.{u2} β] (f : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Magma.AssocQuotient.{u1} α _inst_1) => β) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (a : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => Magma.AssocQuotient.{u1} α _inst_1) a) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) (fun (_x : Magma.AssocQuotient.{u1} α _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Magma.AssocQuotient.{u1} α _inst_1) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) f) (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (fun (_x : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) => MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) (MulHom.{u1, u2} (Magma.AssocQuotient.{u1} α _inst_1) β (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (Semigroup.toMul.{u2} β _inst_2))) (Magma.AssocQuotient.lift.{u1, u2} α _inst_1 β _inst_2) f) (FunLike.coe.{succ u1, succ u1, succ u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => Magma.AssocQuotient.{u1} α _inst_1) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MulHom.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1))) α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)) (MulHom.mulHomClass.{u1, u1} α (Magma.AssocQuotient.{u1} α _inst_1) _inst_1 (Semigroup.toMul.{u1} (Magma.AssocQuotient.{u1} α _inst_1) (Magma.AssocQuotient.instSemigroupAssocQuotient.{u1} α _inst_1)))) (Magma.AssocQuotient.of.{u1} α _inst_1) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2)) α β _inst_1 (Semigroup.toMul.{u2} β _inst_2) (MulHom.mulHomClass.{u1, u2} α β _inst_1 (Semigroup.toMul.{u2} β _inst_2))) f x)
 Case conversion may be inaccurate. Consider using '#align magma.assoc_quotient.lift_of Magma.AssocQuotient.lift_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_of (x : α) : lift f (of x) = f x :=
@@ -820,7 +820,7 @@ protected def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (of
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] {f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1} {g : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1}, (Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) f) (FreeSemigroup.of.{u1} α)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) g) (FreeSemigroup.of.{u1} α))) -> (Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) _inst_1) f g)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] {f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1} {g : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1}, (Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) f) (FreeSemigroup.of.{u1} α)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) g) (FreeSemigroup.of.{u1} α))) -> (Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) f g)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] {f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1} {g : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1}, (Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) f) (FreeSemigroup.of.{u1} α)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1 (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1)) g) (FreeSemigroup.of.{u1} α))) -> (Eq.{max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) _inst_1) f g)
 Case conversion may be inaccurate. Consider using '#align free_semigroup.hom_ext FreeSemigroup.hom_extₓ'. -/
 @[ext, to_additive]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeSemigroup α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
@@ -861,7 +861,7 @@ def lift : (α → β) ≃ (FreeSemigroup α →ₙ* β)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) => (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f) (FreeSemigroup.of.{u1} α x)) (f x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeSemigroup.{u1} α) => β) (FreeSemigroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f) (FreeSemigroup.of.{u1} α x)) (f x)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β) (x : α), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) (FreeSemigroup.of.{u1} α x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f) (FreeSemigroup.of.{u1} α x)) (f x)
 Case conversion may be inaccurate. Consider using '#align free_semigroup.lift_of FreeSemigroup.lift_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_of (x : α) : lift f (of x) = f x :=
@@ -873,7 +873,7 @@ theorem lift_of (x : α) : lift f (of x) = f x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) => (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f)) (FreeSemigroup.of.{u1} α)) f
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f)) (FreeSemigroup.of.{u1} α)) f
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : α -> β), Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) f) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) f)) (FreeSemigroup.of.{u1} α)) f
 Case conversion may be inaccurate. Consider using '#align free_semigroup.lift_comp_of FreeSemigroup.lift_comp_ofₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of : lift f ∘ of = f :=
@@ -885,7 +885,7 @@ theorem lift_comp_of : lift f ∘ of = f :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)), Eq.{max (succ u2) (succ u1)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) => (α -> β) -> (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) (fun (_x : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) => (FreeSemigroup.{u1} α) -> β) (MulHom.hasCoeToFun.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toHasMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.semigroup.{u1} α)) (Semigroup.toHasMul.{u2} β _inst_1)) f) (FreeSemigroup.of.{u1} α))) f
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (a : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeSemigroup.{u1} α) => β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) (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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) f
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semigroup.{u2} β] (f : MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (a : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) a) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) (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)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (α -> β) (fun (_x : α -> β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α -> β) => MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) (FreeSemigroup.lift.{u1, u2} α β _inst_1) (Function.comp.{succ u1, succ u1, succ u2} α (FreeSemigroup.{u1} α) β (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) (fun (_x : FreeSemigroup.{u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : FreeSemigroup.{u1} α) => β) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MulHom.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1)) (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1) (MulHom.mulHomClass.{u1, u2} (FreeSemigroup.{u1} α) β (Semigroup.toMul.{u1} (FreeSemigroup.{u1} α) (FreeSemigroup.instSemigroupFreeSemigroup.{u1} α)) (Semigroup.toMul.{u2} β _inst_1))) f) (FreeSemigroup.of.{u1} α))) f
 Case conversion may be inaccurate. Consider using '#align free_semigroup.lift_comp_of' FreeSemigroup.lift_comp_of'ₓ'. -/
 @[simp, to_additive]
 theorem lift_comp_of' (f : FreeSemigroup α →ₙ* β) : lift (f ∘ of) = f :=

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

This adds a length_pos lemma for multiplicative and additive free magmas.

Indeed, it sometimes happens in proofs that we need to know that the length of any element is indeed strictly positive.

@@ -328,6 +328,13 @@ def FreeAddMagma.length {α : Type u} : FreeAddMagma α → ℕ
 
 attribute [to_additive existing (attr := simp)] FreeMagma.length
 
+/-- The length of an element of a free magma is positive. -/
+@[to_additive "The length of an element of a free additive magma is positive."]
+lemma FreeMagma.length_pos {α : Type u} (x : FreeMagma α) : 0 < x.length :=
+  match x with
+  | FreeMagma.of _ => Nat.succ_pos 0
+  | mul y z => Nat.add_pos_left (length_pos y) z.length
+
 /-- Associativity relations for an additive magma. -/
 inductive AddMagma.AssocRel (α : Type u) [Add α] : α → α → Prop
   | intro : ∀ x y z, AddMagma.AssocRel α (x + y + z) (x + (y + z))

Make use of Nat-specific lemmas from Std rather than the general ones provided by mathlib. Also reverse the dependency between Multiset.Nodup/Multiset.dedup and Multiset.sum since only the latter needs algebra. Also rename Algebra.BigOperators.Multiset.Abs to Algebra.BigOperators.Multiset.Order and move some lemmas from Algebra.BigOperators.Multiset.Basic to it.

The ultimate goal here is to carve out Data, Algebra and Order sublibraries.

@@ -498,7 +498,7 @@ def length (x : FreeSemigroup α) : ℕ := x.tail.length + 1
 
 @[to_additive (attr := simp)]
 theorem length_mul (x y : FreeSemigroup α) : (x * y).length = x.length + y.length := by
-  simp [length, ← add_assoc, add_right_comm, List.length, List.length_append]
+  simp [length, Nat.add_right_comm, List.length, List.length_append]
 #align free_semigroup.length_mul FreeSemigroup.length_mul
 
 @[to_additive (attr := simp)]

This is a very large PR, but it has been reviewed piecemeal already in PRs to the bump/v4.7.0 branch as we update to intermediate nightlies.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: damiano <adomani@gmail.com>

@@ -88,7 +88,9 @@ end FreeMagma
 /-- Lifts a function `α → β` to a magma homomorphism `FreeMagma α → β` given a magma `β`. -/
 def FreeMagma.liftAux {α : Type u} {β : Type v} [Mul β] (f : α → β) : FreeMagma α → β
   | FreeMagma.of x => f x
-  | x * y => liftAux f x * liftAux f y
+  -- Adaptation note: around nightly-2024-02-25, we need to write `mul x y` in the pattern here,
+  -- instead of `x * y`.
+  | mul x y => liftAux f x * liftAux f y
 #align free_magma.lift_aux FreeMagma.liftAux
 
 /-- Lifts a function `α → β` to an additive magma homomorphism `FreeAddMagma α → β` given
@@ -209,7 +211,9 @@ end FreeMagma
 protected def FreeMagma.traverse {m : Type u → Type u} [Applicative m] {α β : Type u}
     (F : α → m β) : FreeMagma α → m (FreeMagma β)
   | FreeMagma.of x => FreeMagma.of <$> F x
-  | x * y => (· * ·) <$> x.traverse F <*> y.traverse F
+  -- Adaptation note: around nightly-2024-02-25, we need to write `mul x y` in the pattern here,
+  -- instead of `x * y`.
+  | mul x y => (· * ·) <$> x.traverse F <*> y.traverse F
 #align free_magma.traverse FreeMagma.traverse
 
 /-- `FreeAddMagma` is traversable. -/
@@ -292,7 +296,9 @@ end FreeMagma
 /-- Representation of an element of a free magma. -/
 protected def FreeMagma.repr {α : Type u} [Repr α] : FreeMagma α → Lean.Format
   | FreeMagma.of x => repr x
-  | x * y => "( " ++ x.repr ++ " * " ++ y.repr ++ " )"
+  -- Adaptation note: around nightly-2024-02-25, we need to write `mul x y` in the pattern here,
+  -- instead of `x * y`.
+  | mul x y => "( " ++ x.repr ++ " * " ++ y.repr ++ " )"
 #align free_magma.repr FreeMagma.repr
 
 /-- Representation of an element of a free additive magma. -/
@@ -309,7 +315,9 @@ instance {α : Type u} [Repr α] : Repr (FreeMagma α) := ⟨fun o _ => FreeMagm
 /-- Length of an element of a free magma. -/
 def FreeMagma.length {α : Type u} : FreeMagma α → ℕ
   | FreeMagma.of _x => 1
-  | x * y => x.length + y.length
+  -- Adaptation note: around nightly-2024-02-25, we need to write `mul x y` in the pattern here,
+  -- instead of `x * y`.
+  | mul x y => x.length + y.length
 #align free_magma.length FreeMagma.length
 
 /-- Length of an element of a free additive magma. -/
@@ -526,7 +534,7 @@ def lift : (α → β) ≃ (FreeSemigroup α →ₙ* β) where
   toFun f :=
     { toFun := fun x ↦ x.2.foldl (fun a b ↦ a * f b) (f x.1)
       map_mul' := fun x y ↦ by
-        simp only [head_mul, tail_mul, ← List.foldl_map f, List.foldl_append, List.foldl_cons,
+        simp [head_mul, tail_mul, ← List.foldl_map, List.foldl_append, List.foldl_cons,
           List.foldl_assoc] }
   invFun f := f ∘ of
   left_inv f := rfl

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

@@ -165,7 +165,7 @@ protected def recOnPure {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (pure
   FreeMagma.recOnMul x ih1 ih2
 #align free_magma.rec_on_pure FreeMagma.recOnPure
 
--- Porting note: dsimp can not prove this
+-- Porting note (#10675): dsimp can not prove this
 @[to_additive (attr := simp, nolint simpNF)]
 theorem map_pure (f : α → β) (x) : (f <$> pure x : FreeMagma β) = pure (f x) := rfl
 #align free_magma.map_pure FreeMagma.map_pure
@@ -174,7 +174,7 @@ theorem map_pure (f : α → β) (x) : (f <$> pure x : FreeMagma β) = pure (f x
 theorem map_mul' (f : α → β) (x y : FreeMagma α) : f <$> (x * y) = f <$> x * f <$> y := rfl
 #align free_magma.map_mul' FreeMagma.map_mul'
 
--- Porting note: dsimp can not prove this
+-- Porting note (#10675): dsimp can not prove this
 @[to_additive (attr := simp, nolint simpNF)]
 theorem pure_bind (f : α → FreeMagma β) (x) : pure x >>= f = f x := rfl
 #align free_magma.pure_bind FreeMagma.pure_bind
@@ -257,7 +257,7 @@ theorem traverse_mul' :
 theorem traverse_eq (x) : FreeMagma.traverse F x = traverse F x := rfl
 #align free_magma.traverse_eq FreeMagma.traverse_eq
 
--- Porting note: dsimp can not prove this
+-- Porting note (#10675): dsimp can not prove this
 @[to_additive (attr := simp, nolint simpNF)]
 theorem mul_map_seq (x y : FreeMagma α) :
     ((· * ·) <$> x <*> y : Id (FreeMagma α)) = (x * y : FreeMagma α) := rfl
@@ -588,7 +588,7 @@ def recOnPure {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (pure x))
   FreeSemigroup.recOnMul x ih1 ih2
 #align free_semigroup.rec_on_pure FreeSemigroup.recOnPure
 
--- Porting note: dsimp can not prove this
+-- Porting note (#10675): dsimp can not prove this
 @[to_additive (attr := simp, nolint simpNF)]
 theorem map_pure (f : α → β) (x) : (f <$> pure x : FreeSemigroup β) = pure (f x) := rfl
 #align free_semigroup.map_pure FreeSemigroup.map_pure
@@ -598,7 +598,7 @@ theorem map_mul' (f : α → β) (x y : FreeSemigroup α) : f <$> (x * y) = f <$
   map_mul (map f) _ _
 #align free_semigroup.map_mul' FreeSemigroup.map_mul'
 
--- Porting note: dsimp can not prove this
+-- Porting note (#10675): dsimp can not prove this
 @[to_additive (attr := simp, nolint simpNF)]
 theorem pure_bind (f : α → FreeSemigroup β) (x) : pure x >>= f = f x := rfl
 #align free_semigroup.pure_bind FreeSemigroup.pure_bind
@@ -674,7 +674,7 @@ end
 theorem traverse_eq (x) : FreeSemigroup.traverse F x = traverse F x := rfl
 #align free_semigroup.traverse_eq FreeSemigroup.traverse_eq
 
--- Porting note: dsimp can not prove this
+-- Porting note (#10675): dsimp can not prove this
 @[to_additive (attr := simp, nolint simpNF)]
 theorem mul_map_seq (x y : FreeSemigroup α) :
     ((· * ·) <$> x <*> y : Id (FreeSemigroup α)) = (x * y : FreeSemigroup α) := rfl

MonoidWithZeroHom confusingly pulled Algebra.GroupWithZero.Defs in Algebra.Group.Hom.Defs.

@@ -4,7 +4,6 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
 -/
 import Mathlib.Algebra.Group.Equiv.Basic
-import Mathlib.Algebra.Group.Hom.Defs
 import Mathlib.Control.Applicative
 import Mathlib.Control.Traversable.Basic
 import Mathlib.Data.List.Basic

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>

@@ -81,7 +81,7 @@ def recOnMul {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (of x))
 
 @[to_additive (attr := ext 1100)]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeMagma α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
-  (FunLike.ext _ _) fun x ↦ recOnMul x (congr_fun h) <| by intros; simp only [map_mul, *]
+  (DFunLike.ext _ _) fun x ↦ recOnMul x (congr_fun h) <| by intros; simp only [map_mul, *]
 #align free_magma.hom_ext FreeMagma.hom_ext
 
 end FreeMagma
@@ -390,7 +390,7 @@ variable {β : Type v} [Semigroup β] (f : α →ₙ* β)
 
 @[to_additive (attr := ext 1100)]
 theorem hom_ext {f g : AssocQuotient α →ₙ* β} (h : f.comp of = g.comp of) : f = g :=
-  (FunLike.ext _ _) fun x => AssocQuotient.induction_on x <| FunLike.congr_fun h
+  (DFunLike.ext _ _) fun x => AssocQuotient.induction_on x <| DFunLike.congr_fun h
 #align magma.assoc_quotient.hom_ext Magma.AssocQuotient.hom_ext
 
 /-- Lifts a magma homomorphism `α → β` to a semigroup homomorphism `Magma.AssocQuotient α → β`
@@ -403,8 +403,8 @@ def lift : (α →ₙ* β) ≃ (AssocQuotient α →ₙ* β) where
       Quot.liftOn x f <| by rintro a b (⟨c, d, e⟩ | ⟨c, d, e, f⟩) <;> simp only [map_mul, mul_assoc]
     map_mul' := fun x y ↦ Quot.induction_on₂ x y (map_mul f) }
   invFun f := f.comp of
-  left_inv f := (FunLike.ext _ _) fun x ↦ rfl
-  right_inv f := hom_ext <| (FunLike.ext _ _) fun x ↦ rfl
+  left_inv f := (DFunLike.ext _ _) fun x ↦ rfl
+  right_inv f := hom_ext <| (DFunLike.ext _ _) fun x ↦ rfl
 #align magma.assoc_quotient.lift Magma.AssocQuotient.lift
 
 @[to_additive (attr := simp)]
@@ -511,7 +511,7 @@ protected def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (of
 
 @[to_additive (attr := ext 1100)]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeSemigroup α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
-  (FunLike.ext _ _) fun x ↦
+  (DFunLike.ext _ _) fun x ↦
     FreeSemigroup.recOnMul x (congr_fun h) fun x y hx hy ↦ by simp only [map_mul, *]
 #align free_semigroup.hom_ext FreeSemigroup.hom_ext
 
@@ -731,7 +731,7 @@ theorem toFreeSemigroup_comp_map (f : α → β) :
 @[to_additive]
 theorem toFreeSemigroup_map (f : α → β) (x : FreeMagma α) :
     toFreeSemigroup (map f x) = FreeSemigroup.map f (toFreeSemigroup x) :=
-  FunLike.congr_fun (toFreeSemigroup_comp_map f) x
+  DFunLike.congr_fun (toFreeSemigroup_comp_map f) x
 #align free_magma.to_free_semigroup_map FreeMagma.toFreeSemigroup_map
 
 @[to_additive (attr := simp)]

Some of these are likely porting errors. Statements should always be about the heterogenous versions because these are the ones with notation.

For places where we are abusing defeq, this debuts the trick of using (by exact a : B) = (by exact a1) + (by exact b2) to ensure the = and + are typed as B instead of A.

@@ -250,7 +250,7 @@ theorem traverse_mul (x y : FreeMagma α) :
 
 @[to_additive (attr := simp)]
 theorem traverse_mul' :
-    Function.comp (traverse F) ∘ @Mul.mul (FreeMagma α) _ = fun x y ↦
+    Function.comp (traverse F) ∘ (HMul.hMul : FreeMagma α → FreeMagma α → FreeMagma α) = fun x y ↦
       (· * ·) <$> traverse F x <*> traverse F y := rfl
 #align free_magma.traverse_mul' FreeMagma.traverse_mul'
 
@@ -664,8 +664,9 @@ theorem traverse_mul (x y : FreeSemigroup α) :
 
 @[to_additive (attr := simp)]
 theorem traverse_mul' :
-    Function.comp (traverse F) ∘ @Mul.mul (FreeSemigroup α) _ = fun x y ↦
-      (· * ·) <$> traverse F x <*> traverse F y := funext fun x ↦ funext fun y ↦ traverse_mul F x y
+    Function.comp (traverse F) ∘ (HMul.hMul : FreeSemigroup α → FreeSemigroup α → FreeSemigroup α) =
+      fun x y ↦ (· * ·) <$> traverse F x <*> traverse F y :=
+  funext fun x ↦ funext fun y ↦ traverse_mul F x y
 #align free_semigroup.traverse_mul' FreeSemigroup.traverse_mul'
 
 end

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -724,8 +724,7 @@ theorem toFreeSemigroup_comp_of : @toFreeSemigroup α ∘ of = FreeSemigroup.of
 
 @[to_additive]
 theorem toFreeSemigroup_comp_map (f : α → β) :
-    toFreeSemigroup.comp (map f) = (FreeSemigroup.map f).comp toFreeSemigroup :=
-  by ext1; rfl
+    toFreeSemigroup.comp (map f) = (FreeSemigroup.map f).comp toFreeSemigroup := by ext1; rfl
 #align free_magma.to_free_semigroup_comp_map FreeMagma.toFreeSemigroup_comp_map
 
 @[to_additive]

I believe the file defining a type of morphisms belongs alongside the file defining the structure this morphism works on. So I would like to reorganize the files in the Mathlib.Algebra.Hom folder so that e.g. Mathlib.Algebra.Hom.Ring becomes Mathlib.Algebra.Ring.Hom and Mathlib.Algebra.Hom.NonUnitalAlg becomes Mathlib.Algebra.Algebra.NonUnitalHom.

While fixing the imports I went ahead and sorted them for good luck.

The full list of changes is: renamed: Mathlib/Algebra/Hom/NonUnitalAlg.lean -> Mathlib/Algebra/Algebra/NonUnitalHom.lean renamed: Mathlib/Algebra/Hom/Aut.lean -> Mathlib/Algebra/Group/Aut.lean renamed: Mathlib/Algebra/Hom/Commute.lean -> Mathlib/Algebra/Group/Commute/Hom.lean renamed: Mathlib/Algebra/Hom/Embedding.lean -> Mathlib/Algebra/Group/Embedding.lean renamed: Mathlib/Algebra/Hom/Equiv/Basic.lean -> Mathlib/Algebra/Group/Equiv/Basic.lean renamed: Mathlib/Algebra/Hom/Equiv/TypeTags.lean -> Mathlib/Algebra/Group/Equiv/TypeTags.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/Basic.lean -> Mathlib/Algebra/Group/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/GroupWithZero.lean -> Mathlib/Algebra/GroupWithZero/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Freiman.lean -> Mathlib/Algebra/Group/Freiman.lean renamed: Mathlib/Algebra/Hom/Group/Basic.lean -> Mathlib/Algebra/Group/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Group/Defs.lean -> Mathlib/Algebra/Group/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/GroupAction.lean -> Mathlib/GroupTheory/GroupAction/Hom.lean renamed: Mathlib/Algebra/Hom/GroupInstances.lean -> Mathlib/Algebra/Group/Hom/Instances.lean renamed: Mathlib/Algebra/Hom/Iterate.lean -> Mathlib/Algebra/GroupPower/IterateHom.lean renamed: Mathlib/Algebra/Hom/Centroid.lean -> Mathlib/Algebra/Ring/CentroidHom.lean renamed: Mathlib/Algebra/Hom/Ring/Basic.lean -> Mathlib/Algebra/Ring/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Ring/Defs.lean -> Mathlib/Algebra/Ring/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/Units.lean -> Mathlib/Algebra/Group/Units/Hom.lean

Zulip thread: https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Reorganizing.20.60Mathlib.2EAlgebra.2EHom.60

@@ -3,12 +3,12 @@ Copyright (c) 2019 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
 -/
-import Mathlib.Algebra.Hom.Group.Defs
-import Mathlib.Algebra.Hom.Equiv.Basic
+import Mathlib.Algebra.Group.Equiv.Basic
+import Mathlib.Algebra.Group.Hom.Defs
 import Mathlib.Control.Applicative
 import Mathlib.Control.Traversable.Basic
-import Mathlib.Logic.Equiv.Defs
 import Mathlib.Data.List.Basic
+import Mathlib.Logic.Equiv.Defs
 
 #align_import algebra.free from "leanprover-community/mathlib"@"6d0adfa76594f304b4650d098273d4366edeb61b"
 

This makes it easier to refactor the order or inheritance structure of morphisms without having to change all of the anonymous constructors.

This is far from exhaustive.

@@ -373,7 +373,7 @@ instance : Semigroup (AssocQuotient α) where
 
 /-- Embedding from magma to its free semigroup. -/
 @[to_additive "Embedding from additive magma to its free additive semigroup."]
-def of : α →ₙ* AssocQuotient α := ⟨Quot.mk _, fun _x _y ↦ rfl⟩
+def of : α →ₙ* AssocQuotient α where toFun := Quot.mk _; map_mul' _x _y := rfl
 #align magma.assoc_quotient.of Magma.AssocQuotient.of
 
 @[to_additive]

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

@@ -3,7 +3,7 @@ Copyright (c) 2019 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau
 -/
-import Mathlib.Algebra.Hom.Group
+import Mathlib.Algebra.Hom.Group.Defs
 import Mathlib.Algebra.Hom.Equiv.Basic
 import Mathlib.Control.Applicative
 import Mathlib.Control.Traversable.Basic

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

@@ -115,7 +115,7 @@ def lift : (α → β) ≃ (FreeMagma α →ₙ* β) where
   { toFun := liftAux f
     map_mul' := fun x y ↦ rfl }
   invFun F := F ∘ of
-  left_inv f := by rfl
+  left_inv f := rfl
   right_inv F := by ext; rfl
 #align free_magma.lift FreeMagma.lift
 

@@ -195,7 +195,7 @@ theorem mul_seq {α β : Type u} {f g : FreeMagma (α → β)} {x : FreeMagma α
 #align free_magma.mul_seq FreeMagma.mul_seq
 
 @[to_additive]
-instance instLawfulMonadFreeMagma : LawfulMonad FreeMagma.{u} := LawfulMonad.mk'
+instance instLawfulMonad : LawfulMonad FreeMagma.{u} := LawfulMonad.mk'
   (pure_bind := fun f x ↦ rfl)
   (bind_assoc := fun x f g ↦ FreeMagma.recOnPure x (fun x ↦ rfl) fun x y ih1 ih2 ↦ by
     rw [mul_bind, mul_bind, mul_bind, ih1, ih2])
@@ -266,7 +266,7 @@ theorem mul_map_seq (x y : FreeMagma α) :
 
 @[to_additive]
 instance : LawfulTraversable FreeMagma.{u} :=
-  { instLawfulMonadFreeMagma with
+  { instLawfulMonad with
     id_traverse := fun x ↦
       FreeMagma.recOnPure x (fun x ↦ rfl) fun x y ih1 ih2 ↦ by
         rw [traverse_mul, ih1, ih2, mul_map_seq]
@@ -619,7 +619,7 @@ theorem mul_seq {f g : FreeSemigroup (α → β)} {x : FreeSemigroup α} :
 #align free_semigroup.mul_seq FreeSemigroup.mul_seq
 
 @[to_additive]
-instance instLawfulMonadFreeSemigroup : LawfulMonad FreeSemigroup.{u} := LawfulMonad.mk'
+instance instLawfulMonad : LawfulMonad FreeSemigroup.{u} := LawfulMonad.mk'
   (pure_bind := fun _ _ ↦ rfl)
   (bind_assoc := fun x g f ↦
     recOnPure x (fun x ↦ rfl) fun x y ih1 ih2 ↦ by rw [mul_bind, mul_bind, mul_bind, ih1, ih2])
@@ -682,7 +682,7 @@ theorem mul_map_seq (x y : FreeSemigroup α) :
 
 @[to_additive]
 instance : LawfulTraversable FreeSemigroup.{u} :=
-  { instLawfulMonadFreeSemigroup with
+  { instLawfulMonad with
     id_traverse := fun x ↦
       FreeSemigroup.recOnMul x (fun x ↦ rfl) fun x y ih1 ih2 ↦ by
         rw [traverse_mul, ih1, ih2, mul_map_seq]

Per https://github.com/leanprover/lean4/issues/2343, we are going to need to change the automatic generation of instance names, as they become too long.

This PR ensures that everywhere in Mathlib that refers to an instance by name, that name is given explicitly, rather than being automatically generated.

There are four exceptions, which are now commented, with links to https://github.com/leanprover/lean4/issues/2343.

This was implemented by running Mathlib against a modified Lean that appended _ᾰ to all automatically generated names, and fixing everything.

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

@@ -195,7 +195,7 @@ theorem mul_seq {α β : Type u} {f g : FreeMagma (α → β)} {x : FreeMagma α
 #align free_magma.mul_seq FreeMagma.mul_seq
 
 @[to_additive]
-instance : LawfulMonad FreeMagma.{u} := LawfulMonad.mk'
+instance instLawfulMonadFreeMagma : LawfulMonad FreeMagma.{u} := LawfulMonad.mk'
   (pure_bind := fun f x ↦ rfl)
   (bind_assoc := fun x f g ↦ FreeMagma.recOnPure x (fun x ↦ rfl) fun x y ih1 ih2 ↦ by
     rw [mul_bind, mul_bind, mul_bind, ih1, ih2])
@@ -266,7 +266,7 @@ theorem mul_map_seq (x y : FreeMagma α) :
 
 @[to_additive]
 instance : LawfulTraversable FreeMagma.{u} :=
-  { instLawfulMonadFreeMagmaInstMonadFreeMagma with
+  { instLawfulMonadFreeMagma with
     id_traverse := fun x ↦
       FreeMagma.recOnPure x (fun x ↦ rfl) fun x y ih1 ih2 ↦ by
         rw [traverse_mul, ih1, ih2, mul_map_seq]
@@ -619,7 +619,7 @@ theorem mul_seq {f g : FreeSemigroup (α → β)} {x : FreeSemigroup α} :
 #align free_semigroup.mul_seq FreeSemigroup.mul_seq
 
 @[to_additive]
-instance : LawfulMonad FreeSemigroup.{u} := LawfulMonad.mk'
+instance instLawfulMonadFreeSemigroup : LawfulMonad FreeSemigroup.{u} := LawfulMonad.mk'
   (pure_bind := fun _ _ ↦ rfl)
   (bind_assoc := fun x g f ↦
     recOnPure x (fun x ↦ rfl) fun x y ih1 ih2 ↦ by rw [mul_bind, mul_bind, mul_bind, ih1, ih2])
@@ -682,7 +682,7 @@ theorem mul_map_seq (x y : FreeSemigroup α) :
 
 @[to_additive]
 instance : LawfulTraversable FreeSemigroup.{u} :=
-  { instLawfulMonadFreeSemigroupInstMonadFreeSemigroup with
+  { instLawfulMonadFreeSemigroup with
     id_traverse := fun x ↦
       FreeSemigroup.recOnMul x (fun x ↦ rfl) fun x y ih1 ih2 ↦ by
         rw [traverse_mul, ih1, ih2, mul_map_seq]

@@ -272,10 +272,10 @@ instance : LawfulTraversable FreeMagma.{u} :=
         rw [traverse_mul, ih1, ih2, mul_map_seq]
     comp_traverse := fun f g x ↦
       FreeMagma.recOnPure x
-        (fun x ↦ by simp only [(. ∘ .), traverse_pure, traverse_pure', functor_norm])
+        (fun x ↦ by simp only [(· ∘ ·), traverse_pure, traverse_pure', functor_norm])
         (fun x y ih1 ih2 ↦ by
           rw [traverse_mul, ih1, ih2, traverse_mul];
-          simp [Functor.Comp.map_mk, Functor.map_map, (. ∘ .), Comp.seq_mk, seq_map_assoc,
+          simp [Functor.Comp.map_mk, Functor.map_map, (· ∘ ·), Comp.seq_mk, seq_map_assoc,
             map_seq, traverse_mul])
     naturality := fun η α β f x ↦
       FreeMagma.recOnPure x
@@ -687,7 +687,7 @@ instance : LawfulTraversable FreeSemigroup.{u} :=
       FreeSemigroup.recOnMul x (fun x ↦ rfl) fun x y ih1 ih2 ↦ by
         rw [traverse_mul, ih1, ih2, mul_map_seq]
     comp_traverse := fun f g x ↦
-      recOnPure x (fun x ↦ by simp only [traverse_pure, functor_norm, (. ∘ .)])
+      recOnPure x (fun x ↦ by simp only [traverse_pure, functor_norm, (· ∘ ·)])
         fun x y ih1 ih2 ↦ by (rw [traverse_mul, ih1, ih2,
           traverse_mul, Functor.Comp.map_mk]; simp only [Function.comp, functor_norm, traverse_mul])
     naturality := fun η α β f x ↦

• depends on: #5966

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

@@ -2,11 +2,6 @@
 Copyright (c) 2019 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 algebra.free
-! leanprover-community/mathlib commit 6d0adfa76594f304b4650d098273d4366edeb61b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Hom.Group
 import Mathlib.Algebra.Hom.Equiv.Basic
@@ -15,6 +10,8 @@ import Mathlib.Control.Traversable.Basic
 import Mathlib.Logic.Equiv.Defs
 import Mathlib.Data.List.Basic
 
+#align_import algebra.free from "leanprover-community/mathlib"@"6d0adfa76594f304b4650d098273d4366edeb61b"
+
 /-!
 # Free constructions
 

@@ -268,7 +268,7 @@ theorem mul_map_seq (x y : FreeMagma α) :
 #align free_magma.mul_map_seq FreeMagma.mul_map_seq
 
 @[to_additive]
-instance : IsLawfulTraversable FreeMagma.{u} :=
+instance : LawfulTraversable FreeMagma.{u} :=
   { instLawfulMonadFreeMagmaInstMonadFreeMagma with
     id_traverse := fun x ↦
       FreeMagma.recOnPure x (fun x ↦ rfl) fun x y ih1 ih2 ↦ by
@@ -684,7 +684,7 @@ theorem mul_map_seq (x y : FreeSemigroup α) :
 #align free_semigroup.mul_map_seq FreeSemigroup.mul_map_seq
 
 @[to_additive]
-instance : IsLawfulTraversable FreeSemigroup.{u} :=
+instance : LawfulTraversable FreeSemigroup.{u} :=
   { instLawfulMonadFreeSemigroupInstMonadFreeSemigroup with
     id_traverse := fun x ↦
       FreeSemigroup.recOnMul x (fun x ↦ rfl) fun x y ih1 ih2 ↦ by

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.

@@ -84,7 +84,7 @@ def recOnMul {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (of x))
 
 @[to_additive (attr := ext 1100)]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeMagma α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
-  (FunLike.ext _ _) fun x ↦ recOnMul x (congr_fun h) <| by intros ; simp only [map_mul, *]
+  (FunLike.ext _ _) fun x ↦ recOnMul x (congr_fun h) <| by intros; simp only [map_mul, *]
 #align free_magma.hom_ext FreeMagma.hom_ext
 
 end FreeMagma
@@ -661,7 +661,7 @@ theorem traverse_mul (x y : FreeSemigroup α) :
     (fun hd tl ih x ↦ show
         (· * ·) <$> pure <$> F x <*> traverse F (mk hd tl * mk y L2) =
           (· * ·) <$> ((· * ·) <$> pure <$> F x <*> traverse F (mk hd tl)) <*> traverse F (mk y L2)
-        by rw [ih] ; simp only [(· ∘ ·), (mul_assoc _ _ _).symm, functor_norm])
+        by rw [ih]; simp only [(· ∘ ·), (mul_assoc _ _ _).symm, functor_norm])
     x
 #align free_semigroup.traverse_mul FreeSemigroup.traverse_mul
 

@@ -483,7 +483,7 @@ theorem mk_mul_mk (x y : α) (L1 L2 : List α) : mk x L1 * mk y L2 = mk x (L1 ++
 #align free_semigroup.mk_mul_mk FreeSemigroup.mk_mul_mk
 
 /-- The embedding `α → FreeSemigroup α`. -/
-@[to_additive (attr := simps) "The embedding `α → free_add_semigroup α`."]
+@[to_additive (attr := simps) "The embedding `α → FreeAddSemigroup α`."]
 def of (x : α) : FreeSemigroup α := ⟨x, []⟩
 #align free_semigroup.of FreeSemigroup.of
 

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

@@ -119,8 +119,7 @@ def lift : (α → β) ≃ (FreeMagma α →ₙ* β) where
     map_mul' := fun x y ↦ rfl }
   invFun F := F ∘ of
   left_inv f := by rfl
--- Porting note: replaced ext by FreeMagma.hom_ext
-  right_inv F := FreeMagma.hom_ext (rfl)
+  right_inv F := by ext; rfl
 #align free_magma.lift FreeMagma.lift
 
 @[to_additive (attr := simp)]
@@ -468,7 +467,7 @@ variable {α : Type u}
 @[to_additive]
 instance : Semigroup (FreeSemigroup α) where
   mul L1 L2 := ⟨L1.1, L1.2 ++ L2.1 :: L2.2⟩
--- Porting note: replaced ext by FreeSemigroup.ext
+  -- Porting note: replaced ext by FreeSemigroup.ext
   mul_assoc _L1 _L2 _L3 := FreeSemigroup.ext _ _ rfl <| List.append_assoc _ _ _
 
 @[to_additive (attr := simp)]

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

@@ -444,9 +444,9 @@ end Magma
 
 /-- Free additive semigroup over a given alphabet. -/
 structure FreeAddSemigroup (α : Type u) where
-/-- The head of the element -/
+  /-- The head of the element -/
   head : α
-/-- The tail of the element -/
+  /-- The tail of the element -/
   tail : List α
 #align free_add_semigroup FreeAddSemigroup
 compile_inductive% FreeAddSemigroup
@@ -454,9 +454,9 @@ compile_inductive% FreeAddSemigroup
 /-- Free semigroup over a given alphabet. -/
 @[to_additive (attr := ext)]
 structure FreeSemigroup (α : Type u) where
-/-- The head of the element -/
+  /-- The head of the element -/
   head : α
-/-- The tail of the element -/
+  /-- The tail of the element -/
   tail : List α
 #align free_semigroup FreeSemigroup
 compile_inductive% FreeSemigroup

Add a #compile inductive command to compile the recursors of an inductive type, which works by creating a recursive definition and using @[csimp].

Co-authored-by: Parth Shastri <31370288+cppio@users.noreply.github.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -39,6 +39,7 @@ inductive FreeAddMagma (α : Type u) : Type u
   | add : FreeAddMagma α → FreeAddMagma α → FreeAddMagma α
   deriving DecidableEq
 #align free_add_magma FreeAddMagma
+compile_inductive% FreeAddMagma
 
 /-- Free magma over a given alphabet. -/
 @[to_additive]
@@ -47,6 +48,7 @@ inductive FreeMagma (α : Type u) : Type u
   | mul : FreeMagma α → FreeMagma α → FreeMagma α
   deriving DecidableEq
 #align free_magma FreeMagma
+compile_inductive% FreeMagma
 
 namespace FreeMagma
 
@@ -75,8 +77,7 @@ attribute [nolint simpNF] FreeMagma.mul.injEq
 /-- Recursor for `FreeMagma` using `x * y` instead of `FreeMagma.mul x y`. -/
 @[to_additive (attr := elab_as_elim) "Recursor for `FreeAddMagma` using `x + y` instead of
 `FreeAddMagma.add x y`."]
--- Porting note: added noncomputable
-noncomputable def recOnMul {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (of x))
+def recOnMul {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (of x))
     (ih2 : ∀ x y, C x → C y → C (x * y)) : C x :=
   FreeMagma.recOn x ih1 ih2
 #align free_magma.rec_on_mul FreeMagma.recOnMul
@@ -164,8 +165,7 @@ instance : Monad FreeMagma where
 
 /-- Recursor on `FreeMagma` using `pure` instead of `of`. -/
 @[to_additive (attr := elab_as_elim) "Recursor on `FreeAddMagma` using `pure` instead of `of`."]
--- Porting note: added noncomputable
-protected noncomputable def recOnPure {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (pure x))
+protected def recOnPure {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (pure x))
     (ih2 : ∀ x y, C x → C y → C (x * y)) : C x :=
   FreeMagma.recOnMul x ih1 ih2
 #align free_magma.rec_on_pure FreeMagma.recOnPure
@@ -449,6 +449,7 @@ structure FreeAddSemigroup (α : Type u) where
 /-- The tail of the element -/
   tail : List α
 #align free_add_semigroup FreeAddSemigroup
+compile_inductive% FreeAddSemigroup
 
 /-- Free semigroup over a given alphabet. -/
 @[to_additive (attr := ext)]
@@ -458,6 +459,7 @@ structure FreeSemigroup (α : Type u) where
 /-- The tail of the element -/
   tail : List α
 #align free_semigroup FreeSemigroup
+compile_inductive% FreeSemigroup
 
 namespace FreeSemigroup
 
@@ -505,8 +507,7 @@ instance [Inhabited α] : Inhabited (FreeSemigroup α) := ⟨of default⟩
 
 /-- Recursor for free semigroup using `of` and `*`. -/
 @[to_additive (attr := elab_as_elim) "Recursor for free additive semigroup using `of` and `+`."]
--- Porting note: added noncomputable
-protected noncomputable def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (of x))
+protected def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (of x))
     (ih2 : ∀ x y, C (of x) → C y → C (of x * y)) : C x :=
       FreeSemigroup.recOn x fun f s ↦
       List.recOn s ih1 (fun hd tl ih f ↦ ih2 f ⟨hd, tl⟩ (ih1 f) (ih hd)) f
@@ -587,8 +588,7 @@ instance : Monad FreeSemigroup where
 
 /-- Recursor that uses `pure` instead of `of`. -/
 @[to_additive (attr := elab_as_elim) "Recursor that uses `pure` instead of `of`."]
--- Porting note: added noncomputable
-noncomputable def recOnPure {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (pure x))
+def recOnPure {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (pure x))
     (ih2 : ∀ x y, C (pure x) → C y → C (pure x * y)) : C x :=
   FreeSemigroup.recOnMul x ih1 ih2
 #align free_semigroup.rec_on_pure FreeSemigroup.recOnPure
@@ -631,15 +631,13 @@ instance : LawfulMonad FreeSemigroup.{u} := LawfulMonad.mk'
 
 /-- `FreeSemigroup` is traversable. -/
 @[to_additive "`FreeAddSemigroup` is traversable."]
--- Porting note: added noncomputable
-protected noncomputable def traverse {m : Type u → Type u} [Applicative m] {α β : Type u}
+protected def traverse {m : Type u → Type u} [Applicative m] {α β : Type u}
     (F : α → m β) (x : FreeSemigroup α) : m (FreeSemigroup β) :=
   recOnPure x (fun x ↦ pure <$> F x) fun _x _y ihx ihy ↦ (· * ·) <$> ihx <*> ihy
 #align free_semigroup.traverse FreeSemigroup.traverse
 
 @[to_additive]
--- Porting note: added noncomputable
-noncomputable instance : Traversable FreeSemigroup := ⟨@FreeSemigroup.traverse⟩
+instance : Traversable FreeSemigroup := ⟨@FreeSemigroup.traverse⟩
 
 variable {m : Type u → Type u} [Applicative m] (F : α → m β)
 
@@ -686,9 +684,8 @@ theorem mul_map_seq (x y : FreeSemigroup α) :
     ((· * ·) <$> x <*> y : Id (FreeSemigroup α)) = (x * y : FreeSemigroup α) := rfl
 #align free_semigroup.mul_map_seq FreeSemigroup.mul_map_seq
 
--- Porting note: Added noncomputable
 @[to_additive]
-noncomputable instance : IsLawfulTraversable FreeSemigroup.{u} :=
+instance : IsLawfulTraversable FreeSemigroup.{u} :=
   { instLawfulMonadFreeSemigroupInstMonadFreeSemigroup with
     id_traverse := fun x ↦
       FreeSemigroup.recOnMul x (fun x ↦ rfl) fun x y ih1 ih2 ↦ by

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

@@ -24,7 +24,7 @@ import Mathlib.Data.List.Basic
   defined inductively, with traversable instance and decidable equality.
 * `MagmaAssocQuotient α`: quotient of a magma `α` by the associativity equivalence relation.
 * `FreeSemigroup α`: free semigroup over alphabet `α`, defined as a structure with two fields
-  `head : α` and `tail : list α` (i.e. nonempty lists), with traversable instance and decidable
+  `head : α` and `tail : List α` (i.e. nonempty lists), with traversable instance and decidable
   equality.
 * `FreeMagmaAssocQuotientEquiv α`: isomorphism between `MagmaAssocQuotient (FreeMagma α)` and
   `FreeSemigroup α`.

• Warn about all simp-attributes
• Warn about elab_as_elim

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -312,20 +312,18 @@ attribute [to_additive existing] FreeMagma.repr
 instance {α : Type u} [Repr α] : Repr (FreeMagma α) := ⟨fun o _ => FreeMagma.repr o⟩
 
 /-- Length of an element of a free magma. -/
-@[simp]
 def FreeMagma.length {α : Type u} : FreeMagma α → ℕ
   | FreeMagma.of _x => 1
   | x * y => x.length + y.length
 #align free_magma.length FreeMagma.length
 
 /-- Length of an element of a free additive magma. -/
-@[simp]
 def FreeAddMagma.length {α : Type u} : FreeAddMagma α → ℕ
   | FreeAddMagma.of _x => 1
   | x + y => x.length + y.length
 #align free_add_magma.length FreeAddMagma.length
 
-attribute [to_additive existing] FreeMagma.length
+attribute [to_additive existing (attr := simp)] FreeMagma.length
 
 /-- Associativity relations for an additive magma. -/
 inductive AddMagma.AssocRel (α : Type u) [Add α] : α → α → Prop

@@ -81,7 +81,7 @@ noncomputable def recOnMul {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (of
   FreeMagma.recOn x ih1 ih2
 #align free_magma.rec_on_mul FreeMagma.recOnMul
 
-@[to_additive (attr := ext 1001)]
+@[to_additive (attr := ext 1100)]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeMagma α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
   (FunLike.ext _ _) fun x ↦ recOnMul x (congr_fun h) <| by intros ; simp only [map_mul, *]
 #align free_magma.hom_ext FreeMagma.hom_ext
@@ -394,7 +394,7 @@ section lift
 
 variable {β : Type v} [Semigroup β] (f : α →ₙ* β)
 
-@[to_additive (attr := ext 1001)]
+@[to_additive (attr := ext 1100)]
 theorem hom_ext {f g : AssocQuotient α →ₙ* β} (h : f.comp of = g.comp of) : f = g :=
   (FunLike.ext _ _) fun x => AssocQuotient.induction_on x <| FunLike.congr_fun h
 #align magma.assoc_quotient.hom_ext Magma.AssocQuotient.hom_ext
@@ -514,7 +514,7 @@ protected noncomputable def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1
       List.recOn s ih1 (fun hd tl ih f ↦ ih2 f ⟨hd, tl⟩ (ih1 f) (ih hd)) f
 #align free_semigroup.rec_on_mul FreeSemigroup.recOnMul
 
-@[to_additive (attr := ext 1001)]
+@[to_additive (attr := ext 1100)]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeSemigroup α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
   (FunLike.ext _ _) fun x ↦
     FreeSemigroup.recOnMul x (congr_fun h) fun x y hx hy ↦ by simp only [map_mul, *]

@@ -445,7 +445,6 @@ end AssocQuotient
 end Magma
 
 /-- Free additive semigroup over a given alphabet. -/
-@[ext]
 structure FreeAddSemigroup (α : Type u) where
 /-- The head of the element -/
   head : α
@@ -454,7 +453,7 @@ structure FreeAddSemigroup (α : Type u) where
 #align free_add_semigroup FreeAddSemigroup
 
 /-- Free semigroup over a given alphabet. -/
-@[ext, to_additive]
+@[to_additive (attr := ext)]
 structure FreeSemigroup (α : Type u) where
 /-- The head of the element -/
   head : α
@@ -589,7 +588,7 @@ instance : Monad FreeSemigroup where
   bind x f := lift f x
 
 /-- Recursor that uses `pure` instead of `of`. -/
-@[elab_as_elim, to_additive "Recursor that uses `pure` instead of `of`."]
+@[to_additive (attr := elab_as_elim) "Recursor that uses `pure` instead of `of`."]
 -- Porting note: added noncomputable
 noncomputable def recOnPure {C : FreeSemigroup α → Sort l} (x) (ih1 : ∀ x, C (pure x))
     (ih2 : ∀ x y, C (pure x) → C y → C (pure x * y)) : C x :=

• Force the user to specify whether the additive declaration already exists.
• Will raise a linter error if the user specified it wrongly
• Requested on Zulip

@@ -101,7 +101,7 @@ def FreeAddMagma.liftAux {α : Type u} {β : Type v} [Add β] (f : α → β) :
   | x + y => liftAux f x + liftAux f y
 #align free_add_magma.lift_aux FreeAddMagma.liftAux
 
-attribute [to_additive] FreeMagma.liftAux
+attribute [to_additive existing] FreeMagma.liftAux
 
 namespace FreeMagma
 
@@ -224,7 +224,7 @@ protected def FreeAddMagma.traverse {m : Type u → Type u} [Applicative m] {α
   | x + y => (· + ·) <$> x.traverse F <*> y.traverse F
 #align free_add_magma.traverse FreeAddMagma.traverse
 
-attribute [to_additive] FreeMagma.traverse
+attribute [to_additive existing] FreeMagma.traverse
 
 namespace FreeMagma
 
@@ -306,7 +306,7 @@ protected def FreeAddMagma.repr {α : Type u} [Repr α] : FreeAddMagma α → Le
   | x + y => "( " ++ x.repr ++ " + " ++ y.repr ++ " )"
 #align free_add_magma.repr FreeAddMagma.repr
 
-attribute [to_additive] FreeMagma.repr
+attribute [to_additive existing] FreeMagma.repr
 
 @[to_additive]
 instance {α : Type u} [Repr α] : Repr (FreeMagma α) := ⟨fun o _ => FreeMagma.repr o⟩
@@ -325,7 +325,7 @@ def FreeAddMagma.length {α : Type u} : FreeAddMagma α → ℕ
   | x + y => x.length + y.length
 #align free_add_magma.length FreeAddMagma.length
 
-attribute [to_additive] FreeMagma.length
+attribute [to_additive existing] FreeMagma.length
 
 /-- Associativity relations for an additive magma. -/
 inductive AddMagma.AssocRel (α : Type u) [Add α] : α → α → Prop

@@ -81,7 +81,7 @@ noncomputable def recOnMul {C : FreeMagma α → Sort l} (x) (ih1 : ∀ x, C (of
   FreeMagma.recOn x ih1 ih2
 #align free_magma.rec_on_mul FreeMagma.recOnMul
 
-@[to_additive (attr := ext)]
+@[to_additive (attr := ext 1001)]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeMagma α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
   (FunLike.ext _ _) fun x ↦ recOnMul x (congr_fun h) <| by intros ; simp only [map_mul, *]
 #align free_magma.hom_ext FreeMagma.hom_ext
@@ -394,7 +394,7 @@ section lift
 
 variable {β : Type v} [Semigroup β] (f : α →ₙ* β)
 
-@[to_additive (attr := ext)]
+@[to_additive (attr := ext 1001)]
 theorem hom_ext {f g : AssocQuotient α →ₙ* β} (h : f.comp of = g.comp of) : f = g :=
   (FunLike.ext _ _) fun x => AssocQuotient.induction_on x <| FunLike.congr_fun h
 #align magma.assoc_quotient.hom_ext Magma.AssocQuotient.hom_ext
@@ -515,7 +515,7 @@ protected noncomputable def recOnMul {C : FreeSemigroup α → Sort l} (x) (ih1
       List.recOn s ih1 (fun hd tl ih f ↦ ih2 f ⟨hd, tl⟩ (ih1 f) (ih hd)) f
 #align free_semigroup.rec_on_mul FreeSemigroup.recOnMul
 
-@[to_additive (attr := ext)]
+@[to_additive (attr := ext 1001)]
 theorem hom_ext {β : Type v} [Mul β] {f g : FreeSemigroup α →ₙ* β} (h : f ∘ of = g ∘ of) : f = g :=
   (FunLike.ext _ _) fun x ↦
     FreeSemigroup.recOnMul x (congr_fun h) fun x y hx hy ↦ by simp only [map_mul, *]
@@ -735,8 +735,7 @@ theorem toFreeSemigroup_comp_of : @toFreeSemigroup α ∘ of = FreeSemigroup.of
 @[to_additive]
 theorem toFreeSemigroup_comp_map (f : α → β) :
     toFreeSemigroup.comp (map f) = (FreeSemigroup.map f).comp toFreeSemigroup :=
--- Porting note: replaced ext1 by FreeMagma.hom_ext
-    FreeMagma.hom_ext rfl
+  by ext1; rfl
 #align free_magma.to_free_semigroup_comp_map FreeMagma.toFreeSemigroup_comp_map
 
 @[to_additive]
@@ -760,8 +759,6 @@ def FreeMagmaAssocQuotientEquiv (α : Type u) :
     Magma.AssocQuotient (FreeMagma α) ≃* FreeSemigroup α :=
       (Magma.AssocQuotient.lift FreeMagma.toFreeSemigroup).toMulEquiv
       (FreeSemigroup.lift (Magma.AssocQuotient.of ∘ FreeMagma.of))
--- Porting note: replaced ext by Magma.AssocQuotient.hom_ext FreeMagma.hom_ext
-      (Magma.AssocQuotient.hom_ext (FreeMagma.hom_ext rfl))
--- Porting note: replaced ext by FreeSemigroup.hom_ext
-      (FreeSemigroup.hom_ext rfl)
+      (by ext; rfl)
+      (by ext1; rfl)
 #align free_magma_assoc_quotient_equiv FreeMagmaAssocQuotientEquiv

@@ -485,7 +485,7 @@ theorem mk_mul_mk (x y : α) (L1 L2 : List α) : mk x L1 * mk y L2 = mk x (L1 ++
 #align free_semigroup.mk_mul_mk FreeSemigroup.mk_mul_mk
 
 /-- The embedding `α → FreeSemigroup α`. -/
-@[to_additive "The embedding `α → free_add_semigroup α`.", simps]
+@[to_additive (attr := simps) "The embedding `α → free_add_semigroup α`."]
 def of (x : α) : FreeSemigroup α := ⟨x, []⟩
 #align free_semigroup.of FreeSemigroup.of
 

Co-authored-by: Lukas Miaskiwskyi <lukas.mias@gmail.com>