algebra.hom.units | Mathlib porting status

(last sync)

refactor(algebra): Redefine a ≡ b [PMOD p] (#18958)

as ∃ n : ℤ, b - a = n • p instead of ∀ n : ℤ, b - n • p ∉ set.Ioo a (a + p). Since this new definition doesn't require an order on α, we move it to a new file algebra.modeq. Expand the API.

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

Diff

@@ -278,7 +278,9 @@ h.eq_div_iff.2
 @[to_additive] protected lemma div_eq_one_iff_eq (h : is_unit b) : a / b = 1 ↔ a = b :=
 ⟨eq_of_div_eq_one, λ hab, hab.symm ▸ h.div_self⟩
 
-@[to_additive] protected lemma div_mul_left (h : is_unit b) : b / (a * b) = 1 / a :=
+/-- The `group` version of this lemma is `div_mul_cancel'''` -/ 
+@[to_additive "The `add_group` version of this lemma is `sub_add_cancel''`"]
+protected lemma div_mul_left (h : is_unit b) : b / (a * b) = 1 / a :=
 by rw [div_eq_mul_inv, mul_inv_rev, h.mul_inv_cancel_left, one_div]
 
 @[to_additive] protected lemma mul_div_mul_right (h : is_unit c) (a b : α) :

chore(algebra/group_with_zero/units/lemmas): div_div_cancel_left' (#18421)

This is the group_with_zero version of div_div_cancel_left.

Forward-ported in https://github.com/leanprover-community/mathlib4/pull/2191

Diff

@@ -318,5 +318,9 @@ by rw [←(hb.mul hd).mul_left_inj, ←mul_assoc, hb.div_mul_cancel, ←mul_asso
 @[to_additive] protected lemma div_div_cancel (h : is_unit a) : a / (a / b) = b :=
 by rw [div_div_eq_mul_div, h.mul_div_cancel_left]
 
+@[to_additive] protected lemma div_div_cancel_left (h : is_unit a) :
+  a / b / a = b⁻¹ :=
+by rw [div_eq_mul_inv, div_eq_mul_inv, mul_right_comm, h.mul_inv_cancel, one_mul]
+
 end division_comm_monoid
 end is_unit

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2018 Johan Commelin All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin, Chris Hughes, Kevin Buzzard
 -/
-import Algebra.Hom.Group
+import Algebra.Group.Hom.Defs
 import Algebra.Group.Units
 
 #align_import algebra.hom.units from "leanprover-community/mathlib"@"a07d750983b94c530ab69a726862c2ab6802b38c"
@@ -453,12 +453,14 @@ protected theorem div_mul_cancel (h : IsUnit b) (a : α) : a / b * b = a := by
 #align is_add_unit.sub_add_cancel IsAddUnit.sub_add_cancel
 -/
 
-#print IsUnit.mul_div_cancel /-
+/- warning: is_unit.mul_div_cancel clashes with mul_div_cancel'' -> mul_div_cancel_right
+Case conversion may be inaccurate. Consider using '#align is_unit.mul_div_cancel mul_div_cancel_rightₓ'. -/
+#print mul_div_cancel_right /-
 @[simp, to_additive]
-protected theorem mul_div_cancel (h : IsUnit b) (a : α) : a * b / b = a := by
+protected theorem mul_div_cancel_right (h : IsUnit b) (a : α) : a * b / b = a := by
   rw [div_eq_mul_inv, h.mul_inv_cancel_right]
-#align is_unit.mul_div_cancel IsUnit.mul_div_cancel
-#align is_add_unit.add_sub_cancel IsAddUnit.add_sub_cancel
+#align is_unit.mul_div_cancel mul_div_cancel_right
+#align add_sub_cancel add_sub_cancel_right
 -/
 
 #print IsUnit.mul_one_div_cancel /-
@@ -577,20 +579,22 @@ protected theorem div_mul_right (h : IsUnit a) (b : α) : a / (a * b) = 1 / b :=
 #align is_add_unit.sub_add_right IsAddUnit.sub_add_right
 -/
 
-#print IsUnit.mul_div_cancel_left /-
+/- warning: is_unit.mul_div_cancel_left clashes with mul_div_cancel''' -> mul_div_cancel_left
+Case conversion may be inaccurate. Consider using '#align is_unit.mul_div_cancel_left mul_div_cancel_leftₓ'. -/
+#print mul_div_cancel_left /-
 @[to_additive]
 protected theorem mul_div_cancel_left (h : IsUnit a) (b : α) : a * b / a = b := by
   rw [mul_comm, h.mul_div_cancel]
-#align is_unit.mul_div_cancel_left IsUnit.mul_div_cancel_left
-#align is_add_unit.add_sub_cancel_left IsAddUnit.add_sub_cancel_left
+#align is_unit.mul_div_cancel_left mul_div_cancel_left
+#align add_sub_cancel' add_sub_cancel_left
 -/
 
-#print IsUnit.mul_div_cancel' /-
+#print IsUnit.mul_div_cancel /-
 @[to_additive]
-protected theorem mul_div_cancel' (h : IsUnit a) (b : α) : a * (b / a) = b := by
+protected theorem mul_div_cancel (h : IsUnit a) (b : α) : a * (b / a) = b := by
   rw [mul_comm, h.div_mul_cancel]
-#align is_unit.mul_div_cancel' IsUnit.mul_div_cancel'
-#align is_add_unit.add_sub_cancel' IsAddUnit.add_sub_cancel'
+#align is_unit.mul_div_cancel' IsUnit.mul_div_cancel
+#align is_add_unit.add_sub_cancel' IsAddUnit.add_sub_cancel
 -/
 
 #print IsUnit.mul_div_mul_left /-

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2018 Johan Commelin All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin, Chris Hughes, Kevin Buzzard
 -/
-import Mathbin.Algebra.Hom.Group
-import Mathbin.Algebra.Group.Units
+import Algebra.Hom.Group
+import Algebra.Group.Units
 
 #align_import algebra.hom.units from "leanprover-community/mathlib"@"a07d750983b94c530ab69a726862c2ab6802b38c"

bump to nightly-2023-08-17-09

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

60285dcc

Diff

@@ -82,7 +82,7 @@ def map (f : M →* N) : Mˣ →* Nˣ :=
     (fun u =>
       ⟨f u.val, f u.inv, by rw [← f.map_mul, u.val_inv, f.map_one], by
         rw [← f.map_mul, u.inv_val, f.map_one]⟩)
-    fun x y => ext (f.map_mul x y)
+    fun x y => ext (f.map_hMul x y)
 #align units.map Units.map
 #align add_units.map AddUnits.map
 -/

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Johan Commelin All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin, Chris Hughes, Kevin Buzzard
-
-! This file was ported from Lean 3 source module algebra.hom.units
-! leanprover-community/mathlib commit a07d750983b94c530ab69a726862c2ab6802b38c
-! 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.Group.Units
 
+#align_import algebra.hom.units from "leanprover-community/mathlib"@"a07d750983b94c530ab69a726862c2ab6802b38c"
+
 /-!
 # Monoid homomorphisms and units

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -47,6 +47,7 @@ theorem Group.isUnit {G} [Group G] (g : G) : IsUnit g :=
 
 section MonoidHomClass
 
+#print IsUnit.eq_on_inv /-
 /-- If two homomorphisms from a division monoid to a monoid are equal at a unit `x`, then they are
 equal at `x⁻¹`. -/
 @[to_additive
@@ -57,7 +58,9 @@ theorem IsUnit.eq_on_inv {F G N} [DivisionMonoid G] [Monoid N] [MonoidHomClass F
     h.symm ▸ map_mul_eq_one g <| hx.mul_inv_cancel
 #align is_unit.eq_on_inv IsUnit.eq_on_inv
 #align is_add_unit.eq_on_neg IsAddUnit.eq_on_neg
+-/
 
+#print eq_on_inv /-
 /-- If two homomorphism from a group to a monoid are equal at `x`, then they are equal at `x⁻¹`. -/
 @[to_additive
       "If two homomorphism from an additive group to an additive monoid are equal at `x`,\nthen they are equal at `-x`."]
@@ -66,6 +69,7 @@ theorem eq_on_inv {F G M} [Group G] [Monoid M] [MonoidHomClass F G M] (f g : F)
   (Group.isUnit x).eq_on_inv f g h
 #align eq_on_inv eq_on_inv
 #align eq_on_neg eq_on_neg
+-/
 
 end MonoidHomClass
 
@@ -73,6 +77,7 @@ namespace Units
 
 variable {α : Type _} {M : Type u} {N : Type v} {P : Type w} [Monoid M] [Monoid N] [Monoid P]
 
+#print Units.map /-
 /-- The group homomorphism on units induced by a `monoid_hom`. -/
 @[to_additive "The `add_group` homomorphism on `add_unit`s induced by an `add_monoid_hom`."]
 def map (f : M →* N) : Mˣ →* Nˣ :=
@@ -83,81 +88,105 @@ def map (f : M →* N) : Mˣ →* Nˣ :=
     fun x y => ext (f.map_mul x y)
 #align units.map Units.map
 #align add_units.map AddUnits.map
+-/
 
+#print Units.coe_map /-
 @[simp, to_additive]
 theorem coe_map (f : M →* N) (x : Mˣ) : ↑(map f x) = f x :=
   rfl
 #align units.coe_map Units.coe_map
 #align add_units.coe_map AddUnits.coe_map
+-/
 
+#print Units.coe_map_inv /-
 @[simp, to_additive]
 theorem coe_map_inv (f : M →* N) (u : Mˣ) : ↑(map f u)⁻¹ = f ↑u⁻¹ :=
   rfl
 #align units.coe_map_inv Units.coe_map_inv
 #align add_units.coe_map_neg AddUnits.coe_map_neg
+-/
 
+#print Units.map_comp /-
 @[simp, to_additive]
 theorem map_comp (f : M →* N) (g : N →* P) : map (g.comp f) = (map g).comp (map f) :=
   rfl
 #align units.map_comp Units.map_comp
 #align add_units.map_comp AddUnits.map_comp
+-/
 
 variable (M)
 
+#print Units.map_id /-
 @[simp, to_additive]
 theorem map_id : map (MonoidHom.id M) = MonoidHom.id Mˣ := by ext <;> rfl
 #align units.map_id Units.map_id
 #align add_units.map_id AddUnits.map_id
+-/
 
+#print Units.coeHom /-
 /-- Coercion `Mˣ → M` as a monoid homomorphism. -/
 @[to_additive "Coercion `add_units M → M` as an add_monoid homomorphism."]
 def coeHom : Mˣ →* M :=
   ⟨coe, val_one, val_mul⟩
 #align units.coe_hom Units.coeHom
 #align add_units.coe_hom AddUnits.coeHom
+-/
 
 variable {M}
 
+#print Units.coeHom_apply /-
 @[simp, to_additive]
 theorem coeHom_apply (x : Mˣ) : coeHom M x = ↑x :=
   rfl
 #align units.coe_hom_apply Units.coeHom_apply
 #align add_units.coe_hom_apply AddUnits.coeHom_apply
+-/
 
+#print Units.val_pow_eq_pow_val /-
 @[simp, norm_cast, to_additive]
 theorem val_pow_eq_pow_val (u : Mˣ) (n : ℕ) : ((u ^ n : Mˣ) : M) = u ^ n :=
   (Units.coeHom M).map_pow u n
 #align units.coe_pow Units.val_pow_eq_pow_val
 #align add_units.coe_nsmul AddUnits.val_nsmul_eq_nsmul_val
+-/
 
 section DivisionMonoid
 
 variable [DivisionMonoid α]
 
+#print Units.val_div_eq_div_val /-
 @[simp, norm_cast, to_additive]
 theorem val_div_eq_div_val : ∀ u₁ u₂ : αˣ, ↑(u₁ / u₂) = (u₁ / u₂ : α) :=
   (Units.coeHom α).map_div
 #align units.coe_div Units.val_div_eq_div_val
+-/
 
+#print Units.val_zpow_eq_zpow_val /-
 @[simp, norm_cast, to_additive]
 theorem val_zpow_eq_zpow_val : ∀ (u : αˣ) (n : ℤ), ((u ^ n : αˣ) : α) = u ^ n :=
   (Units.coeHom α).map_zpow
 #align units.coe_zpow Units.val_zpow_eq_zpow_val
 #align add_units.coe_zsmul AddUnits.val_zsmul_eq_zsmul_val
+-/
 
+#print divp_eq_div /-
 @[field_simps]
 theorem divp_eq_div (a : α) (u : αˣ) : a /ₚ u = a / u := by rw [div_eq_mul_inv, divp, u.coe_inv]
 #align divp_eq_div divp_eq_div
+-/
 
+#print map_units_inv /-
 @[simp, to_additive]
 theorem map_units_inv {F : Type _} [MonoidHomClass F M α] (f : F) (u : Units M) :
     f ↑u⁻¹ = (f u)⁻¹ :=
   ((f : M →* α).comp (Units.coeHom M)).map_inv u
 #align map_units_inv map_units_inv
 #align map_add_units_neg map_addUnits_neg
+-/
 
 end DivisionMonoid
 
+#print Units.liftRight /-
 /-- If a map `g : M → Nˣ` agrees with a homomorphism `f : M →* N`, then
 this map is a monoid homomorphism too. -/
 @[to_additive
@@ -169,30 +198,38 @@ def liftRight (f : M →* N) (g : M → Nˣ) (h : ∀ x, ↑(g x) = f x) : M →
   map_mul' x y := Units.ext <| by simp only [h, coe_mul, f.map_mul]
 #align units.lift_right Units.liftRight
 #align add_units.lift_right AddUnits.liftRight
+-/
 
+#print Units.coe_liftRight /-
 @[simp, to_additive]
 theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
     (liftRight f g h x : N) = f x :=
   h x
 #align units.coe_lift_right Units.coe_liftRight
 #align add_units.coe_lift_right AddUnits.coe_liftRight
+-/
 
+#print Units.mul_liftRight_inv /-
 @[simp, to_additive]
 theorem mul_liftRight_inv {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
     f x * ↑(liftRight f g h x)⁻¹ = 1 := by rw [Units.mul_inv_eq_iff_eq_mul, one_mul, coe_lift_right]
 #align units.mul_lift_right_inv Units.mul_liftRight_inv
 #align add_units.add_lift_right_neg AddUnits.add_liftRight_neg
+-/
 
+#print Units.liftRight_inv_mul /-
 @[simp, to_additive]
 theorem liftRight_inv_mul {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
     ↑(liftRight f g h x)⁻¹ * f x = 1 := by rw [Units.inv_mul_eq_iff_eq_mul, mul_one, coe_lift_right]
 #align units.lift_right_inv_mul Units.liftRight_inv_mul
 #align add_units.lift_right_neg_add AddUnits.liftRight_neg_add
+-/
 
 end Units
 
 namespace MonoidHom
 
+#print MonoidHom.toHomUnits /-
 /-- If `f` is a homomorphism from a group `G` to a monoid `M`,
 then its image lies in the units of `M`,
 and `f.to_hom_units` is the corresponding monoid homomorphism from `G` to `Mˣ`. -/
@@ -204,13 +241,16 @@ def toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) : G →* Mˣ :
     fun g => rfl
 #align monoid_hom.to_hom_units MonoidHom.toHomUnits
 #align add_monoid_hom.to_hom_add_units AddMonoidHom.toHomAddUnits
+-/
 
+#print MonoidHom.coe_toHomUnits /-
 @[simp, to_additive]
 theorem coe_toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) (g : G) :
     (f.toHomUnits g : M) = f g :=
   rfl
 #align monoid_hom.coe_to_hom_units MonoidHom.coe_toHomUnits
 #align add_monoid_hom.coe_to_hom_add_units AddMonoidHom.coe_toHomAddUnits
+-/
 
 end MonoidHom
 
@@ -222,26 +262,33 @@ section Monoid
 
 variable [Monoid M] [Monoid N]
 
+#print IsUnit.map /-
 @[to_additive]
 theorem map [MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x) : IsUnit (f x) := by
   rcases h with ⟨y, rfl⟩ <;> exact (Units.map (f : M →* N) y).IsUnit
 #align is_unit.map IsUnit.map
 #align is_add_unit.map IsAddUnit.map
+-/
 
+#print IsUnit.of_leftInverse /-
 @[to_additive]
 theorem of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x : M} (g : G)
     (hfg : Function.LeftInverse g f) (h : IsUnit (f x)) : IsUnit x := by
   simpa only [hfg x] using h.map g
 #align is_unit.of_left_inverse IsUnit.of_leftInverse
 #align is_add_unit.of_left_inverse IsAddUnit.of_leftInverse
+-/
 
+#print isUnit_map_of_leftInverse /-
 @[to_additive]
 theorem isUnit_map_of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x : M}
     (g : G) (hfg : Function.LeftInverse g f) : IsUnit (f x) ↔ IsUnit x :=
   ⟨of_leftInverse g hfg, map _⟩
 #align is_unit_map_of_left_inverse isUnit_map_of_leftInverse
 #align is_add_unit_map_of_left_inverse isAddUnit_map_of_leftInverse
+-/
 
+#print IsUnit.liftRight /-
 /-- If a homomorphism `f : M →* N` sends each element to an `is_unit`, then it can be lifted
 to `f : M →* Nˣ`. See also `units.lift_right` for a computable version. -/
 @[to_additive
@@ -250,27 +297,34 @@ noncomputable def liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) : M →* N
   Units.liftRight f (fun x => (hf x).Unit) fun x => rfl
 #align is_unit.lift_right IsUnit.liftRight
 #align is_add_unit.lift_right IsAddUnit.liftRight
+-/
 
+#print IsUnit.coe_liftRight /-
 @[to_additive]
 theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
     (IsUnit.liftRight f hf x : N) = f x :=
   rfl
 #align is_unit.coe_lift_right IsUnit.coe_liftRight
 #align is_add_unit.coe_lift_right IsAddUnit.coe_liftRight
+-/
 
+#print IsUnit.mul_liftRight_inv /-
 @[simp, to_additive]
 theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
     f x * ↑(IsUnit.liftRight f h x)⁻¹ = 1 :=
   Units.mul_liftRight_inv (fun y => rfl) x
 #align is_unit.mul_lift_right_inv IsUnit.mul_liftRight_inv
 #align is_add_unit.add_lift_right_neg IsAddUnit.add_liftRight_neg
+-/
 
+#print IsUnit.liftRight_inv_mul /-
 @[simp, to_additive]
 theorem liftRight_inv_mul (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
     ↑(IsUnit.liftRight f h x)⁻¹ * f x = 1 :=
   Units.liftRight_inv_mul (fun y => rfl) x
 #align is_unit.lift_right_inv_mul IsUnit.liftRight_inv_mul
 #align is_add_unit.lift_right_neg_add IsAddUnit.liftRight_neg_add
+-/
 
 end Monoid
 
@@ -291,170 +345,226 @@ def unit' (h : IsUnit a) : αˣ :=
 #align is_add_unit.add_unit' IsAddUnit.addUnit'
 -/
 
+#print IsUnit.mul_inv_cancel_left /-
 @[simp, to_additive]
 protected theorem mul_inv_cancel_left (h : IsUnit a) : ∀ b, a * (a⁻¹ * b) = b :=
   h.unit'.mul_inv_cancel_left
 #align is_unit.mul_inv_cancel_left IsUnit.mul_inv_cancel_left
 #align is_add_unit.add_neg_cancel_left IsAddUnit.add_neg_cancel_left
+-/
 
+#print IsUnit.inv_mul_cancel_left /-
 @[simp, to_additive]
 protected theorem inv_mul_cancel_left (h : IsUnit a) : ∀ b, a⁻¹ * (a * b) = b :=
   h.unit'.inv_mul_cancel_left
 #align is_unit.inv_mul_cancel_left IsUnit.inv_mul_cancel_left
 #align is_add_unit.neg_add_cancel_left IsAddUnit.neg_add_cancel_left
+-/
 
+#print IsUnit.mul_inv_cancel_right /-
 @[simp, to_additive]
 protected theorem mul_inv_cancel_right (h : IsUnit b) (a : α) : a * b * b⁻¹ = a :=
   h.unit'.mul_inv_cancel_right _
 #align is_unit.mul_inv_cancel_right IsUnit.mul_inv_cancel_right
 #align is_add_unit.add_neg_cancel_right IsAddUnit.add_neg_cancel_right
+-/
 
+#print IsUnit.inv_mul_cancel_right /-
 @[simp, to_additive]
 protected theorem inv_mul_cancel_right (h : IsUnit b) (a : α) : a * b⁻¹ * b = a :=
   h.unit'.inv_mul_cancel_right _
 #align is_unit.inv_mul_cancel_right IsUnit.inv_mul_cancel_right
 #align is_add_unit.neg_add_cancel_right IsAddUnit.neg_add_cancel_right
+-/
 
+#print IsUnit.div_self /-
 @[to_additive]
 protected theorem div_self (h : IsUnit a) : a / a = 1 := by rw [div_eq_mul_inv, h.mul_inv_cancel]
 #align is_unit.div_self IsUnit.div_self
 #align is_add_unit.sub_self IsAddUnit.sub_self
+-/
 
+#print IsUnit.eq_mul_inv_iff_mul_eq /-
 @[to_additive]
 protected theorem eq_mul_inv_iff_mul_eq (h : IsUnit c) : a = b * c⁻¹ ↔ a * c = b :=
   h.unit'.eq_mul_inv_iff_mul_eq
 #align is_unit.eq_mul_inv_iff_mul_eq IsUnit.eq_mul_inv_iff_mul_eq
 #align is_add_unit.eq_add_neg_iff_add_eq IsAddUnit.eq_add_neg_iff_add_eq
+-/
 
+#print IsUnit.eq_inv_mul_iff_mul_eq /-
 @[to_additive]
 protected theorem eq_inv_mul_iff_mul_eq (h : IsUnit b) : a = b⁻¹ * c ↔ b * a = c :=
   h.unit'.eq_inv_mul_iff_mul_eq
 #align is_unit.eq_inv_mul_iff_mul_eq IsUnit.eq_inv_mul_iff_mul_eq
 #align is_add_unit.eq_neg_add_iff_add_eq IsAddUnit.eq_neg_add_iff_add_eq
+-/
 
+#print IsUnit.inv_mul_eq_iff_eq_mul /-
 @[to_additive]
 protected theorem inv_mul_eq_iff_eq_mul (h : IsUnit a) : a⁻¹ * b = c ↔ b = a * c :=
   h.unit'.inv_mul_eq_iff_eq_mul
 #align is_unit.inv_mul_eq_iff_eq_mul IsUnit.inv_mul_eq_iff_eq_mul
 #align is_add_unit.neg_add_eq_iff_eq_add IsAddUnit.neg_add_eq_iff_eq_add
+-/
 
+#print IsUnit.mul_inv_eq_iff_eq_mul /-
 @[to_additive]
 protected theorem mul_inv_eq_iff_eq_mul (h : IsUnit b) : a * b⁻¹ = c ↔ a = c * b :=
   h.unit'.mul_inv_eq_iff_eq_mul
 #align is_unit.mul_inv_eq_iff_eq_mul IsUnit.mul_inv_eq_iff_eq_mul
 #align is_add_unit.add_neg_eq_iff_eq_add IsAddUnit.add_neg_eq_iff_eq_add
+-/
 
+#print IsUnit.mul_inv_eq_one /-
 @[to_additive]
 protected theorem mul_inv_eq_one (h : IsUnit b) : a * b⁻¹ = 1 ↔ a = b :=
   @Units.mul_inv_eq_one _ _ h.unit' _
 #align is_unit.mul_inv_eq_one IsUnit.mul_inv_eq_one
 #align is_add_unit.add_neg_eq_zero IsAddUnit.add_neg_eq_zero
+-/
 
+#print IsUnit.inv_mul_eq_one /-
 @[to_additive]
 protected theorem inv_mul_eq_one (h : IsUnit a) : a⁻¹ * b = 1 ↔ a = b :=
   @Units.inv_mul_eq_one _ _ h.unit' _
 #align is_unit.inv_mul_eq_one IsUnit.inv_mul_eq_one
 #align is_add_unit.neg_add_eq_zero IsAddUnit.neg_add_eq_zero
+-/
 
+#print IsUnit.mul_eq_one_iff_eq_inv /-
 @[to_additive]
 protected theorem mul_eq_one_iff_eq_inv (h : IsUnit b) : a * b = 1 ↔ a = b⁻¹ :=
   @Units.mul_eq_one_iff_eq_inv _ _ h.unit' _
 #align is_unit.mul_eq_one_iff_eq_inv IsUnit.mul_eq_one_iff_eq_inv
 #align is_add_unit.add_eq_zero_iff_eq_neg IsAddUnit.add_eq_zero_iff_eq_neg
+-/
 
+#print IsUnit.mul_eq_one_iff_inv_eq /-
 @[to_additive]
 protected theorem mul_eq_one_iff_inv_eq (h : IsUnit a) : a * b = 1 ↔ a⁻¹ = b :=
   @Units.mul_eq_one_iff_inv_eq _ _ h.unit' _
 #align is_unit.mul_eq_one_iff_inv_eq IsUnit.mul_eq_one_iff_inv_eq
 #align is_add_unit.add_eq_zero_iff_neg_eq IsAddUnit.add_eq_zero_iff_neg_eq
+-/
 
+#print IsUnit.div_mul_cancel /-
 @[simp, to_additive]
 protected theorem div_mul_cancel (h : IsUnit b) (a : α) : a / b * b = a := by
   rw [div_eq_mul_inv, h.inv_mul_cancel_right]
 #align is_unit.div_mul_cancel IsUnit.div_mul_cancel
 #align is_add_unit.sub_add_cancel IsAddUnit.sub_add_cancel
+-/
 
+#print IsUnit.mul_div_cancel /-
 @[simp, to_additive]
 protected theorem mul_div_cancel (h : IsUnit b) (a : α) : a * b / b = a := by
   rw [div_eq_mul_inv, h.mul_inv_cancel_right]
 #align is_unit.mul_div_cancel IsUnit.mul_div_cancel
 #align is_add_unit.add_sub_cancel IsAddUnit.add_sub_cancel
+-/
 
+#print IsUnit.mul_one_div_cancel /-
 @[to_additive]
 protected theorem mul_one_div_cancel (h : IsUnit a) : a * (1 / a) = 1 := by simp [h]
 #align is_unit.mul_one_div_cancel IsUnit.mul_one_div_cancel
 #align is_add_unit.add_zero_sub_cancel IsAddUnit.add_zero_sub_cancel
+-/
 
+#print IsUnit.one_div_mul_cancel /-
 @[to_additive]
 protected theorem one_div_mul_cancel (h : IsUnit a) : 1 / a * a = 1 := by simp [h]
 #align is_unit.one_div_mul_cancel IsUnit.one_div_mul_cancel
 #align is_add_unit.zero_sub_add_cancel IsAddUnit.zero_sub_add_cancel
+-/
 
+#print IsUnit.inv /-
 @[to_additive]
 theorem inv : IsUnit a → IsUnit a⁻¹ := by rintro ⟨u, rfl⟩; rw [← Units.val_inv_eq_inv_val];
   exact Units.isUnit _
 #align is_unit.inv IsUnit.inv
 #align is_add_unit.neg IsAddUnit.neg
+-/
 
+#print IsUnit.div /-
 @[to_additive]
 theorem div (ha : IsUnit a) (hb : IsUnit b) : IsUnit (a / b) := by rw [div_eq_mul_inv];
   exact ha.mul hb.inv
 #align is_unit.div IsUnit.div
 #align is_add_unit.sub IsAddUnit.sub
+-/
 
+#print IsUnit.div_left_inj /-
 @[to_additive]
 protected theorem div_left_inj (h : IsUnit c) : a / c = b / c ↔ a = b := by
   simp_rw [div_eq_mul_inv]; exact Units.mul_left_inj h.inv.unit'
 #align is_unit.div_left_inj IsUnit.div_left_inj
 #align is_add_unit.sub_left_inj IsAddUnit.sub_left_inj
+-/
 
+#print IsUnit.div_eq_iff /-
 @[to_additive]
 protected theorem div_eq_iff (h : IsUnit b) : a / b = c ↔ a = c * b := by
   rw [div_eq_mul_inv, h.mul_inv_eq_iff_eq_mul]
 #align is_unit.div_eq_iff IsUnit.div_eq_iff
 #align is_add_unit.sub_eq_iff IsAddUnit.sub_eq_iff
+-/
 
+#print IsUnit.eq_div_iff /-
 @[to_additive]
 protected theorem eq_div_iff (h : IsUnit c) : a = b / c ↔ a * c = b := by
   rw [div_eq_mul_inv, h.eq_mul_inv_iff_mul_eq]
 #align is_unit.eq_div_iff IsUnit.eq_div_iff
 #align is_add_unit.eq_sub_iff IsAddUnit.eq_sub_iff
+-/
 
+#print IsUnit.div_eq_of_eq_mul /-
 @[to_additive]
 protected theorem div_eq_of_eq_mul (h : IsUnit b) : a = c * b → a / b = c :=
   h.div_eq_iff.2
 #align is_unit.div_eq_of_eq_mul IsUnit.div_eq_of_eq_mul
 #align is_add_unit.sub_eq_of_eq_add IsAddUnit.sub_eq_of_eq_add
+-/
 
+#print IsUnit.eq_div_of_mul_eq /-
 @[to_additive]
 protected theorem eq_div_of_mul_eq (h : IsUnit c) : a * c = b → a = b / c :=
   h.eq_div_iff.2
 #align is_unit.eq_div_of_mul_eq IsUnit.eq_div_of_mul_eq
 #align is_add_unit.eq_sub_of_add_eq IsAddUnit.eq_sub_of_add_eq
+-/
 
+#print IsUnit.div_eq_one_iff_eq /-
 @[to_additive]
 protected theorem div_eq_one_iff_eq (h : IsUnit b) : a / b = 1 ↔ a = b :=
   ⟨eq_of_div_eq_one, fun hab => hab.symm ▸ h.div_self⟩
 #align is_unit.div_eq_one_iff_eq IsUnit.div_eq_one_iff_eq
 #align is_add_unit.sub_eq_zero_iff_eq IsAddUnit.sub_eq_zero_iff_eq
+-/
 
+#print IsUnit.div_mul_left /-
 /-- The `group` version of this lemma is `div_mul_cancel'''` -/
 @[to_additive "The `add_group` version of this lemma is `sub_add_cancel''`"]
 protected theorem div_mul_left (h : IsUnit b) : b / (a * b) = 1 / a := by
   rw [div_eq_mul_inv, mul_inv_rev, h.mul_inv_cancel_left, one_div]
 #align is_unit.div_mul_left IsUnit.div_mul_left
 #align is_add_unit.sub_add_left IsAddUnit.sub_add_left
+-/
 
+#print IsUnit.mul_div_mul_right /-
 @[to_additive]
 protected theorem mul_div_mul_right (h : IsUnit c) (a b : α) : a * c / (b * c) = a / b := by
   simp only [div_eq_mul_inv, mul_inv_rev, mul_assoc, h.mul_inv_cancel_left]
 #align is_unit.mul_div_mul_right IsUnit.mul_div_mul_right
 #align is_add_unit.add_sub_add_right IsAddUnit.add_sub_add_right
+-/
 
+#print IsUnit.mul_mul_div /-
 @[to_additive]
 protected theorem mul_mul_div (a : α) (h : IsUnit b) : a * b * (1 / b) = a := by simp [h]
 #align is_unit.mul_mul_div IsUnit.mul_mul_div
 #align is_add_unit.add_add_sub IsAddUnit.add_add_sub
+-/
 
 end DivisionMonoid
 
@@ -462,37 +572,48 @@ section DivisionCommMonoid
 
 variable [DivisionCommMonoid α] {a b c d : α}
 
+#print IsUnit.div_mul_right /-
 @[to_additive]
 protected theorem div_mul_right (h : IsUnit a) (b : α) : a / (a * b) = 1 / b := by
   rw [mul_comm, h.div_mul_left]
 #align is_unit.div_mul_right IsUnit.div_mul_right
 #align is_add_unit.sub_add_right IsAddUnit.sub_add_right
+-/
 
+#print IsUnit.mul_div_cancel_left /-
 @[to_additive]
 protected theorem mul_div_cancel_left (h : IsUnit a) (b : α) : a * b / a = b := by
   rw [mul_comm, h.mul_div_cancel]
 #align is_unit.mul_div_cancel_left IsUnit.mul_div_cancel_left
 #align is_add_unit.add_sub_cancel_left IsAddUnit.add_sub_cancel_left
+-/
 
+#print IsUnit.mul_div_cancel' /-
 @[to_additive]
 protected theorem mul_div_cancel' (h : IsUnit a) (b : α) : a * (b / a) = b := by
   rw [mul_comm, h.div_mul_cancel]
 #align is_unit.mul_div_cancel' IsUnit.mul_div_cancel'
 #align is_add_unit.add_sub_cancel' IsAddUnit.add_sub_cancel'
+-/
 
+#print IsUnit.mul_div_mul_left /-
 @[to_additive]
 protected theorem mul_div_mul_left (h : IsUnit c) (a b : α) : c * a / (c * b) = a / b := by
   rw [mul_comm c, mul_comm c, h.mul_div_mul_right]
 #align is_unit.mul_div_mul_left IsUnit.mul_div_mul_left
 #align is_add_unit.add_sub_add_left IsAddUnit.add_sub_add_left
+-/
 
+#print IsUnit.mul_eq_mul_of_div_eq_div /-
 @[to_additive]
 protected theorem mul_eq_mul_of_div_eq_div (hb : IsUnit b) (hd : IsUnit d) (a c : α)
     (h : a / b = c / d) : a * d = c * b := by
   rw [← mul_one a, ← hb.div_self, ← mul_comm_div, h, div_mul_eq_mul_div, hd.div_mul_cancel]
 #align is_unit.mul_eq_mul_of_div_eq_div IsUnit.mul_eq_mul_of_div_eq_div
 #align is_add_unit.add_eq_add_of_sub_eq_sub IsAddUnit.add_eq_add_of_sub_eq_sub
+-/
 
+#print IsUnit.div_eq_div_iff /-
 @[to_additive]
 protected theorem div_eq_div_iff (hb : IsUnit b) (hd : IsUnit d) : a / b = c / d ↔ a * d = c * b :=
   by
@@ -500,18 +621,23 @@ protected theorem div_eq_div_iff (hb : IsUnit b) (hd : IsUnit d) : a / b = c / d
     hd.div_mul_cancel]
 #align is_unit.div_eq_div_iff IsUnit.div_eq_div_iff
 #align is_add_unit.sub_eq_sub_iff IsAddUnit.sub_eq_sub_iff
+-/
 
+#print IsUnit.div_div_cancel /-
 @[to_additive]
 protected theorem div_div_cancel (h : IsUnit a) : a / (a / b) = b := by
   rw [div_div_eq_mul_div, h.mul_div_cancel_left]
 #align is_unit.div_div_cancel IsUnit.div_div_cancel
 #align is_add_unit.sub_sub_cancel IsAddUnit.sub_sub_cancel
+-/
 
+#print IsUnit.div_div_cancel_left /-
 @[to_additive]
 protected theorem div_div_cancel_left (h : IsUnit a) : a / b / a = b⁻¹ := by
   rw [div_eq_mul_inv, div_eq_mul_inv, mul_right_comm, h.mul_inv_cancel, one_mul]
 #align is_unit.div_div_cancel_left IsUnit.div_div_cancel_left
 #align is_add_unit.sub_sub_cancel_left IsAddUnit.sub_sub_cancel_left
+-/
 
 end DivisionCommMonoid

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -47,12 +47,6 @@ theorem Group.isUnit {G} [Group G] (g : G) : IsUnit g :=
 
 section MonoidHomClass
 
-/- warning: is_unit.eq_on_inv -> IsUnit.eq_on_inv is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {G : Type.{u2}} {N : Type.{u3}} [_inst_1 : DivisionMonoid.{u2} G] [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2)] {x : G}, (IsUnit.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x) -> (forall (f : F) (g : F), (Eq.{succ u3} N (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) f x) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) g x)) -> (Eq.{succ u3} N (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) f (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x)) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) g (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x))))
-but is expected to have type
-  forall {F : Type.{u3}} {G : Type.{u2}} {N : Type.{u1}} [_inst_1 : DivisionMonoid.{u2} G] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2)] {x : G}, (IsUnit.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x) -> (forall (f : F) (g : F), (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x))))
-Case conversion may be inaccurate. Consider using '#align is_unit.eq_on_inv IsUnit.eq_on_invₓ'. -/
 /-- If two homomorphisms from a division monoid to a monoid are equal at a unit `x`, then they are
 equal at `x⁻¹`. -/
 @[to_additive
@@ -64,12 +58,6 @@ theorem IsUnit.eq_on_inv {F G N} [DivisionMonoid G] [Monoid N] [MonoidHomClass F
 #align is_unit.eq_on_inv IsUnit.eq_on_inv
 #align is_add_unit.eq_on_neg IsAddUnit.eq_on_neg
 
-/- warning: eq_on_inv -> eq_on_inv is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {G : Type.{u2}} {M : Type.{u3}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u3} M] [_inst_3 : MonoidHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2)] (f : F) (g : F) {x : G}, (Eq.{succ u3} M (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) f x) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) g x)) -> (Eq.{succ u3} M (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) f (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) x)) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) g (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) x)))
-but is expected to have type
-  forall {F : Type.{u3}} {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)] (f : F) (g : F) {x : G}, (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)))
-Case conversion may be inaccurate. Consider using '#align eq_on_inv eq_on_invₓ'. -/
 /-- If two homomorphism from a group to a monoid are equal at `x`, then they are equal at `x⁻¹`. -/
 @[to_additive
       "If two homomorphism from an additive group to an additive monoid are equal at `x`,\nthen they are equal at `-x`."]
@@ -85,12 +73,6 @@ namespace Units
 
 variable {α : Type _} {M : Type u} {N : Type v} {P : Type w} [Monoid M] [Monoid N] [Monoid P]
 
-/- warning: units.map -> Units.map is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N], (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) -> (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2))
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N], (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) -> (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
-Case conversion may be inaccurate. Consider using '#align units.map Units.mapₓ'. -/
 /-- The group homomorphism on units induced by a `monoid_hom`. -/
 @[to_additive "The `add_group` homomorphism on `add_unit`s induced by an `add_monoid_hom`."]
 def map (f : M →* N) : Mˣ →* Nˣ :=
@@ -102,36 +84,18 @@ def map (f : M →* N) : Mˣ →* Nˣ :=
 #align units.map Units.map
 #align add_units.map AddUnits.map
 
-/- warning: units.coe_map -> Units.coe_map is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (x : Units.{u1} M _inst_1), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => (Units.{u1} M _inst_1) -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) x))
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (x : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) (Units.val.{u1} M _inst_1 x)) (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 x))
-Case conversion may be inaccurate. Consider using '#align units.coe_map Units.coe_mapₓ'. -/
 @[simp, to_additive]
 theorem coe_map (f : M →* N) (x : Mˣ) : ↑(map f x) = f x :=
   rfl
 #align units.coe_map Units.coe_map
 #align add_units.coe_map AddUnits.coe_map
 
-/- warning: units.coe_map_inv -> Units.coe_map_inv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => (Units.{u1} M _inst_1) -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) u)))
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInv.{u1} M _inst_1) u))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) u) (Units.instInv.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInv.{u1} M _inst_1) u)))
-Case conversion may be inaccurate. Consider using '#align units.coe_map_inv Units.coe_map_invₓ'. -/
 @[simp, to_additive]
 theorem coe_map_inv (f : M →* N) (u : Mˣ) : ↑(map f u)⁻¹ = f ↑u⁻¹ :=
   rfl
 #align units.coe_map_inv Units.coe_map_inv
 #align add_units.coe_map_neg AddUnits.coe_map_neg
 
-/- warning: units.map_comp -> Units.map_comp is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} {P : Type.{u3}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : Monoid.{u3} P] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : MonoidHom.{u2, u3} N P (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} P _inst_3)), Eq.{max (succ u3) (succ u1)} (MonoidHom.{u1, u3} (Units.{u1} M _inst_1) (Units.{u3} P _inst_3) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u3} P _inst_3)) (Units.map.{u1, u3} M P _inst_1 _inst_3 (MonoidHom.comp.{u1, u2, u3} M N P (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} P _inst_3) g f)) (MonoidHom.comp.{u1, u2, u3} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.{u3} P _inst_3) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2) (Units.mulOneClass.{u3} P _inst_3) (Units.map.{u2, u3} N P _inst_2 _inst_3 g) (Units.map.{u1, u2} M N _inst_1 _inst_2 f))
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} {P : Type.{u3}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : Monoid.{u3} P] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : MonoidHom.{u2, u3} N P (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} P _inst_3)), Eq.{max (succ u1) (succ u3)} (MonoidHom.{u1, u3} (Units.{u1} M _inst_1) (Units.{u3} P _inst_3) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u3} P _inst_3)) (Units.map.{u1, u3} M P _inst_1 _inst_3 (MonoidHom.comp.{u1, u2, u3} M N P (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} P _inst_3) g f)) (MonoidHom.comp.{u1, u2, u3} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.{u3} P _inst_3) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (Units.instMulOneClassUnits.{u3} P _inst_3) (Units.map.{u2, u3} N P _inst_2 _inst_3 g) (Units.map.{u1, u2} M N _inst_1 _inst_2 f))
-Case conversion may be inaccurate. Consider using '#align units.map_comp Units.map_compₓ'. -/
 @[simp, to_additive]
 theorem map_comp (f : M →* N) (g : N →* P) : map (g.comp f) = (map g).comp (map f) :=
   rfl
@@ -140,23 +104,11 @@ theorem map_comp (f : M →* N) (g : N →* P) : map (g.comp f) = (map g).comp (
 
 variable (M)
 
-/- warning: units.map_id -> Units.map_id is a dubious translation:
-lean 3 declaration is
-  forall (M : Type.{u1}) [_inst_1 : Monoid.{u1} M], Eq.{succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) (Units.{u1} M _inst_1) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u1} M _inst_1)) (Units.map.{u1, u1} M M _inst_1 _inst_1 (MonoidHom.id.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (MonoidHom.id.{u1} (Units.{u1} M _inst_1) (Units.mulOneClass.{u1} M _inst_1))
-but is expected to have type
-  forall (M : Type.{u1}) [_inst_1 : Monoid.{u1} M], Eq.{succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (Units.map.{u1, u1} M M _inst_1 _inst_1 (MonoidHom.id.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (MonoidHom.id.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1))
-Case conversion may be inaccurate. Consider using '#align units.map_id Units.map_idₓ'. -/
 @[simp, to_additive]
 theorem map_id : map (MonoidHom.id M) = MonoidHom.id Mˣ := by ext <;> rfl
 #align units.map_id Units.map_id
 #align add_units.map_id AddUnits.map_id
 
-/- warning: units.coe_hom -> Units.coeHom is a dubious translation:
-lean 3 declaration is
-  forall (M : Type.{u1}) [_inst_1 : Monoid.{u1} M], MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)
-but is expected to have type
-  forall (M : Type.{u1}) [_inst_1 : Monoid.{u1} M], MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)
-Case conversion may be inaccurate. Consider using '#align units.coe_hom Units.coeHomₓ'. -/
 /-- Coercion `Mˣ → M` as a monoid homomorphism. -/
 @[to_additive "Coercion `add_units M → M` as an add_monoid homomorphism."]
 def coeHom : Mˣ →* M :=
@@ -166,24 +118,12 @@ def coeHom : Mˣ →* M :=
 
 variable {M}
 
-/- warning: units.coe_hom_apply -> Units.coeHom_apply is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : Units.{u1} M _inst_1), Eq.{succ u1} M (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) => (Units.{u1} M _inst_1) -> M) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.coeHom.{u1} M _inst_1) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) x)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : Units.{u1} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_1) => M) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_1) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)))) (Units.coeHom.{u1} M _inst_1) x) (Units.val.{u1} M _inst_1 x)
-Case conversion may be inaccurate. Consider using '#align units.coe_hom_apply Units.coeHom_applyₓ'. -/
 @[simp, to_additive]
 theorem coeHom_apply (x : Mˣ) : coeHom M x = ↑x :=
   rfl
 #align units.coe_hom_apply Units.coeHom_apply
 #align add_units.coe_hom_apply AddUnits.coeHom_apply
 
-/- warning: units.coe_pow -> Units.val_pow_eq_pow_val is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (u : Units.{u1} M _inst_1) (n : Nat), Eq.{succ u1} M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (HPow.hPow.{u1, 0, u1} (Units.{u1} M _inst_1) Nat (Units.{u1} M _inst_1) (instHPow.{u1, 0} (Units.{u1} M _inst_1) Nat (Monoid.Pow.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.group.{u1} M _inst_1))))) u n)) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) u) n)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (u : Units.{u1} M _inst_1) (n : Nat), Eq.{succ u1} M (Units.val.{u1} M _inst_1 (HPow.hPow.{u1, 0, u1} (Units.{u1} M _inst_1) Nat (Units.{u1} M _inst_1) (instHPow.{u1, 0} (Units.{u1} M _inst_1) Nat (Monoid.Pow.{u1} (Units.{u1} M _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} M _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} M _inst_1) (Units.instGroupUnits.{u1} M _inst_1))))) u n)) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) (Units.val.{u1} M _inst_1 u) n)
-Case conversion may be inaccurate. Consider using '#align units.coe_pow Units.val_pow_eq_pow_valₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem val_pow_eq_pow_val (u : Mˣ) (n : ℕ) : ((u ^ n : Mˣ) : M) = u ^ n :=
   (Units.coeHom M).map_pow u n
@@ -194,45 +134,21 @@ section DivisionMonoid
 
 variable [DivisionMonoid α]
 
-/- warning: units.coe_div -> Units.val_div_eq_div_val is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_4 : DivisionMonoid.{u1} α] (u₁ : Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (u₂ : Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (coeBase.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (Units.hasCoe.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))))) (HDiv.hDiv.{u1, u1, u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (instHDiv.{u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (DivInvMonoid.toHasDiv.{u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Group.toDivInvMonoid.{u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Units.group.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))))) u₁ u₂)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (coeBase.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (Units.hasCoe.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))))) u₁) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (coeBase.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (Units.hasCoe.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))))) u₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_4 : DivisionMonoid.{u1} α] (u₁ : Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (u₂ : Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))), Eq.{succ u1} α (Units.val.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)) (HDiv.hDiv.{u1, u1, u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (instHDiv.{u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (DivInvMonoid.toDiv.{u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Group.toDivInvMonoid.{u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Units.instGroupUnits.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))))) u₁ u₂)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Units.val.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)) u₁) (Units.val.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)) u₂))
-Case conversion may be inaccurate. Consider using '#align units.coe_div Units.val_div_eq_div_valₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem val_div_eq_div_val : ∀ u₁ u₂ : αˣ, ↑(u₁ / u₂) = (u₁ / u₂ : α) :=
   (Units.coeHom α).map_div
 #align units.coe_div Units.val_div_eq_div_val
 
-/- warning: units.coe_zpow -> Units.val_zpow_eq_zpow_val is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_4 : DivisionMonoid.{u1} α] (u : Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (n : Int), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (coeBase.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (Units.hasCoe.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))))) (HPow.hPow.{u1, 0, u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) Int (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (instHPow.{u1, 0} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) Int (DivInvMonoid.Pow.{u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Group.toDivInvMonoid.{u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Units.group.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))))) u n)) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (coeBase.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (Units.hasCoe.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))))) u) n)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_4 : DivisionMonoid.{u1} α] (u : Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (n : Int), Eq.{succ u1} α (Units.val.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)) (HPow.hPow.{u1, 0, u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) Int (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (instHPow.{u1, 0} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) Int (DivInvMonoid.Pow.{u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Group.toDivInvMonoid.{u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Units.instGroupUnits.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))))) u n)) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) (Units.val.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)) u) n)
-Case conversion may be inaccurate. Consider using '#align units.coe_zpow Units.val_zpow_eq_zpow_valₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem val_zpow_eq_zpow_val : ∀ (u : αˣ) (n : ℤ), ((u ^ n : αˣ) : α) = u ^ n :=
   (Units.coeHom α).map_zpow
 #align units.coe_zpow Units.val_zpow_eq_zpow_val
 #align add_units.coe_zsmul AddUnits.val_zsmul_eq_zsmul_val
 
-/- warning: divp_eq_div -> divp_eq_div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_4 : DivisionMonoid.{u1} α] (a : α) (u : Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))), Eq.{succ u1} α (divp.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)) a u) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) a ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (coeBase.{succ u1, succ u1} (Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) α (Units.hasCoe.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))))) u))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_4 : DivisionMonoid.{u1} α] (a : α) (u : Units.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))), Eq.{succ u1} α (divp.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)) a u) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) a (Units.val.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)) u))
-Case conversion may be inaccurate. Consider using '#align divp_eq_div divp_eq_divₓ'. -/
 @[field_simps]
 theorem divp_eq_div (a : α) (u : αˣ) : a /ₚ u = a / u := by rw [div_eq_mul_inv, divp, u.coe_inv]
 #align divp_eq_div divp_eq_div
 
-/- warning: map_units_inv -> map_units_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : DivisionMonoid.{u2} α] {F : Type.{u3}} [_inst_5 : MonoidHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))] (f : F) (u : Units.{u1} M _inst_1), Eq.{succ u2} α (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> α) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => α) (MulHomClass.toFunLike.{u3, u1, u2} F M α (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4))) _inst_5))) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) u))) (Inv.inv.{u2} α (DivInvMonoid.toHasInv.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> α) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => α) (MulHomClass.toFunLike.{u3, u1, u2} F M α (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4))) _inst_5))) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) u)))
-but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u3}} [_inst_1 : Monoid.{u3} M] [_inst_4 : DivisionMonoid.{u1} α] {F : Type.{u2}} [_inst_5 : MonoidHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))] (f : F) (u : Units.{u3} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInv.{u3} M _inst_1) u))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInv.{u3} M _inst_1) u))) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) (Units.val.{u3} M _inst_1 u)) (InvOneClass.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) (Units.val.{u3} M _inst_1 u)) _inst_4))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 u)))
-Case conversion may be inaccurate. Consider using '#align map_units_inv map_units_invₓ'. -/
 @[simp, to_additive]
 theorem map_units_inv {F : Type _} [MonoidHomClass F M α] (f : F) (u : Units M) :
     f ↑u⁻¹ = (f u)⁻¹ :=
@@ -242,12 +158,6 @@ theorem map_units_inv {F : Type _} [MonoidHomClass F M α] (f : F) (u : Units M)
 
 end DivisionMonoid
 
-/- warning: units.lift_right -> Units.liftRight is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : M -> (Units.{u2} N _inst_2)), (forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2))
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : M -> (Units.{u2} N _inst_2)), (forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
-Case conversion may be inaccurate. Consider using '#align units.lift_right Units.liftRightₓ'. -/
 /-- If a map `g : M → Nˣ` agrees with a homomorphism `f : M →* N`, then
 this map is a monoid homomorphism too. -/
 @[to_additive
@@ -260,12 +170,6 @@ def liftRight (f : M →* N) (g : M → Nˣ) (h : ∀ x, ↑(g x) = f x) : M →
 #align units.lift_right Units.liftRight
 #align add_units.lift_right AddUnits.liftRight
 
-/- warning: units.coe_lift_right -> Units.coe_liftRight is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} N (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)
-Case conversion may be inaccurate. Consider using '#align units.coe_lift_right Units.coe_liftRightₓ'. -/
 @[simp, to_additive]
 theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
     (liftRight f g h x : N) = f x :=
@@ -273,24 +177,12 @@ theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x)
 #align units.coe_lift_right Units.coe_liftRight
 #align add_units.coe_lift_right AddUnits.coe_liftRight
 
-/- warning: units.mul_lift_right_inv -> Units.mul_liftRight_inv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u2} N _inst_2) x) (Units.instInv.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align units.mul_lift_right_inv Units.mul_liftRight_invₓ'. -/
 @[simp, to_additive]
 theorem mul_liftRight_inv {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
     f x * ↑(liftRight f g h x)⁻¹ = 1 := by rw [Units.mul_inv_eq_iff_eq_mul, one_mul, coe_lift_right]
 #align units.mul_lift_right_inv Units.mul_liftRight_inv
 #align add_units.add_lift_right_neg AddUnits.add_liftRight_neg
 
-/- warning: units.lift_right_inv_mul -> Units.liftRight_inv_mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u2} N _inst_2) x) (Units.instInv.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align units.lift_right_inv_mul Units.liftRight_inv_mulₓ'. -/
 @[simp, to_additive]
 theorem liftRight_inv_mul {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
     ↑(liftRight f g h x)⁻¹ * f x = 1 := by rw [Units.inv_mul_eq_iff_eq_mul, mul_one, coe_lift_right]
@@ -301,12 +193,6 @@ end Units
 
 namespace MonoidHom
 
-/- warning: monoid_hom.to_hom_units -> MonoidHom.toHomUnits is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {M : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Monoid.{u2} M], (MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) -> (MonoidHom.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2))
-but is expected to have type
-  forall {G : Type.{u1}} {M : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Monoid.{u2} M], (MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) -> (MonoidHom.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.instMulOneClassUnits.{u2} M _inst_2))
-Case conversion may be inaccurate. Consider using '#align monoid_hom.to_hom_units MonoidHom.toHomUnitsₓ'. -/
 /-- If `f` is a homomorphism from a group `G` to a monoid `M`,
 then its image lies in the units of `M`,
 and `f.to_hom_units` is the corresponding monoid homomorphism from `G` to `Mˣ`. -/
@@ -319,12 +205,6 @@ def toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) : G →* Mˣ :
 #align monoid_hom.to_hom_units MonoidHom.toHomUnits
 #align add_monoid_hom.to_hom_add_units AddMonoidHom.toHomAddUnits
 
-/- warning: monoid_hom.coe_to_hom_units -> MonoidHom.coe_toHomUnits is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {M : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Monoid.{u2} M] (f : MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) (g : G), Eq.{succ u2} M ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} M _inst_2) M (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} M _inst_2) M (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} M _inst_2) M (coeBase.{succ u2, succ u2} (Units.{u2} M _inst_2) M (Units.hasCoe.{u2} M _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2)) (fun (_x : MonoidHom.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2)) => G -> (Units.{u2} M _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2)) (MonoidHom.toHomUnits.{u1, u2} G M _inst_1 _inst_2 f) g)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) (fun (_x : MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) => G -> M) (MonoidHom.hasCoeToFun.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) f g)
-but is expected to have type
-  forall {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] (f : MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) (g : G), Eq.{succ u1} M (Units.val.{u1} M _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => Units.{u1} M _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)))) (MonoidHom.toHomUnits.{u2, u1} G M _inst_1 _inst_2 f) g)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)))) f g)
-Case conversion may be inaccurate. Consider using '#align monoid_hom.coe_to_hom_units MonoidHom.coe_toHomUnitsₓ'. -/
 @[simp, to_additive]
 theorem coe_toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) (g : G) :
     (f.toHomUnits g : M) = f g :=
@@ -342,24 +222,12 @@ section Monoid
 
 variable [Monoid M] [Monoid N]
 
-/- warning: is_unit.map -> IsUnit.map is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {M : Type.{u2}} {N : Type.{u3}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u1, u2, u3} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (f : F) {x : M}, (IsUnit.{u2} M _inst_1 x) -> (IsUnit.{u3} N _inst_2 (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u2, u3} F M N (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) f x))
-but is expected to have type
-  forall {F : Type.{u3}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) {x : M}, (IsUnit.{u2} M _inst_1 x) -> (IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x))
-Case conversion may be inaccurate. Consider using '#align is_unit.map IsUnit.mapₓ'. -/
 @[to_additive]
 theorem map [MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x) : IsUnit (f x) := by
   rcases h with ⟨y, rfl⟩ <;> exact (Units.map (f : M →* N) y).IsUnit
 #align is_unit.map IsUnit.map
 #align is_add_unit.map IsAddUnit.map
 
-/- warning: is_unit.of_left_inverse -> IsUnit.of_leftInverse is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {G : Type.{u2}} {M : Type.{u3}} {N : Type.{u4}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u4} N] [_inst_3 : MonoidHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2)] [_inst_4 : MonoidHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u4} M N (coeFn.{succ u2, max (succ u4) (succ u3)} G (fun (_x : G) => N -> M) (FunLike.hasCoeToFun.{succ u2, succ u4, succ u3} G N (fun (_x : N) => M) (MulHomClass.toFunLike.{u2, u4, u3} G N M (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4))) g) (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f)) -> (IsUnit.{u4} N _inst_2 (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f x)) -> (IsUnit.{u3} M _inst_1 x)
-but is expected to have type
-  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) -> (IsUnit.{u3} M _inst_1 x)
-Case conversion may be inaccurate. Consider using '#align is_unit.of_left_inverse IsUnit.of_leftInverseₓ'. -/
 @[to_additive]
 theorem of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x : M} (g : G)
     (hfg : Function.LeftInverse g f) (h : IsUnit (f x)) : IsUnit x := by
@@ -367,12 +235,6 @@ theorem of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x
 #align is_unit.of_left_inverse IsUnit.of_leftInverse
 #align is_add_unit.of_left_inverse IsAddUnit.of_leftInverse
 
-/- warning: is_unit_map_of_left_inverse -> isUnit_map_of_leftInverse is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {G : Type.{u2}} {M : Type.{u3}} {N : Type.{u4}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u4} N] [_inst_3 : MonoidHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2)] [_inst_4 : MonoidHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u4} M N (coeFn.{succ u2, max (succ u4) (succ u3)} G (fun (_x : G) => N -> M) (FunLike.hasCoeToFun.{succ u2, succ u4, succ u3} G N (fun (_x : N) => M) (MulHomClass.toFunLike.{u2, u4, u3} G N M (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4))) g) (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f)) -> (Iff (IsUnit.{u4} N _inst_2 (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f x)) (IsUnit.{u3} M _inst_1 x))
-but is expected to have type
-  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (Iff (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) (IsUnit.{u3} M _inst_1 x))
-Case conversion may be inaccurate. Consider using '#align is_unit_map_of_left_inverse isUnit_map_of_leftInverseₓ'. -/
 @[to_additive]
 theorem isUnit_map_of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x : M}
     (g : G) (hfg : Function.LeftInverse g f) : IsUnit (f x) ↔ IsUnit x :=
@@ -380,12 +242,6 @@ theorem isUnit_map_of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M]
 #align is_unit_map_of_left_inverse isUnit_map_of_leftInverse
 #align is_add_unit_map_of_left_inverse isAddUnit_map_of_leftInverse
 
-/- warning: is_unit.lift_right -> IsUnit.liftRight is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)), (forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2))
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)), (forall (x : M), IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
-Case conversion may be inaccurate. Consider using '#align is_unit.lift_right IsUnit.liftRightₓ'. -/
 /-- If a homomorphism `f : M →* N` sends each element to an `is_unit`, then it can be lifted
 to `f : M →* Nˣ`. See also `units.lift_right` for a computable version. -/
 @[to_additive
@@ -395,12 +251,6 @@ noncomputable def liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) : M →* N
 #align is_unit.lift_right IsUnit.liftRight
 #align is_add_unit.lift_right IsAddUnit.liftRight
 
-/- warning: is_unit.coe_lift_right -> IsUnit.coe_liftRight is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (hf : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f hf) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (hf : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} N (Units.val.{u1} N _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f hf) x)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)
-Case conversion may be inaccurate. Consider using '#align is_unit.coe_lift_right IsUnit.coe_liftRightₓ'. -/
 @[to_additive]
 theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
     (IsUnit.liftRight f hf x : N) = f x :=
@@ -408,12 +258,6 @@ theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
 #align is_unit.coe_lift_right IsUnit.coe_liftRight
 #align is_add_unit.coe_lift_right IsAddUnit.coe_liftRight
 
-/- warning: is_unit.mul_lift_right_inv -> IsUnit.mul_liftRight_inv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (h : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u1} N _inst_2) x) (Units.instInv.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_lift_right_inv IsUnit.mul_liftRight_invₓ'. -/
 @[simp, to_additive]
 theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
     f x * ↑(IsUnit.liftRight f h x)⁻¹ = 1 :=
@@ -421,12 +265,6 @@ theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
 #align is_unit.mul_lift_right_inv IsUnit.mul_liftRight_inv
 #align is_add_unit.add_lift_right_neg IsAddUnit.add_liftRight_neg
 
-/- warning: is_unit.lift_right_inv_mul -> IsUnit.liftRight_inv_mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (h : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f h) x))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2))) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u1} N _inst_2) x) (Units.instInv.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align is_unit.lift_right_inv_mul IsUnit.liftRight_inv_mulₓ'. -/
 @[simp, to_additive]
 theorem liftRight_inv_mul (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
     ↑(IsUnit.liftRight f h x)⁻¹ * f x = 1 :=
@@ -453,309 +291,153 @@ def unit' (h : IsUnit a) : αˣ :=
 #align is_add_unit.add_unit' IsAddUnit.addUnit'
 -/
 
-/- warning: is_unit.mul_inv_cancel_left -> IsUnit.mul_inv_cancel_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (forall (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) b)) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (forall (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) a) b)) b)
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_inv_cancel_left IsUnit.mul_inv_cancel_leftₓ'. -/
 @[simp, to_additive]
 protected theorem mul_inv_cancel_left (h : IsUnit a) : ∀ b, a * (a⁻¹ * b) = b :=
   h.unit'.mul_inv_cancel_left
 #align is_unit.mul_inv_cancel_left IsUnit.mul_inv_cancel_left
 #align is_add_unit.add_neg_cancel_left IsAddUnit.add_neg_cancel_left
 
-/- warning: is_unit.inv_mul_cancel_left -> IsUnit.inv_mul_cancel_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (forall (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b)) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (forall (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b)) b)
-Case conversion may be inaccurate. Consider using '#align is_unit.inv_mul_cancel_left IsUnit.inv_mul_cancel_leftₓ'. -/
 @[simp, to_additive]
 protected theorem inv_mul_cancel_left (h : IsUnit a) : ∀ b, a⁻¹ * (a * b) = b :=
   h.unit'.inv_mul_cancel_left
 #align is_unit.inv_mul_cancel_left IsUnit.inv_mul_cancel_left
 #align is_add_unit.neg_add_cancel_left IsAddUnit.neg_add_cancel_left
 
-/- warning: is_unit.mul_inv_cancel_right -> IsUnit.mul_inv_cancel_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (forall (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (forall (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) b)) a)
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_inv_cancel_right IsUnit.mul_inv_cancel_rightₓ'. -/
 @[simp, to_additive]
 protected theorem mul_inv_cancel_right (h : IsUnit b) (a : α) : a * b * b⁻¹ = a :=
   h.unit'.mul_inv_cancel_right _
 #align is_unit.mul_inv_cancel_right IsUnit.mul_inv_cancel_right
 #align is_add_unit.add_neg_cancel_right IsAddUnit.add_neg_cancel_right
 
-/- warning: is_unit.inv_mul_cancel_right -> IsUnit.inv_mul_cancel_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (forall (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b)) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (forall (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) b)) b) a)
-Case conversion may be inaccurate. Consider using '#align is_unit.inv_mul_cancel_right IsUnit.inv_mul_cancel_rightₓ'. -/
 @[simp, to_additive]
 protected theorem inv_mul_cancel_right (h : IsUnit b) (a : α) : a * b⁻¹ * b = a :=
   h.unit'.inv_mul_cancel_right _
 #align is_unit.inv_mul_cancel_right IsUnit.inv_mul_cancel_right
 #align is_add_unit.neg_add_cancel_right IsAddUnit.neg_add_cancel_right
 
-/- warning: is_unit.div_self -> IsUnit.div_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align is_unit.div_self IsUnit.div_selfₓ'. -/
 @[to_additive]
 protected theorem div_self (h : IsUnit a) : a / a = 1 := by rw [div_eq_mul_inv, h.mul_inv_cancel]
 #align is_unit.div_self IsUnit.div_self
 #align is_add_unit.sub_self IsAddUnit.sub_self
 
-/- warning: is_unit.eq_mul_inv_iff_mul_eq -> IsUnit.eq_mul_inv_iff_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) c) -> (Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) b (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) c))) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a c) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) c) -> (Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) b (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) c))) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a c) b))
-Case conversion may be inaccurate. Consider using '#align is_unit.eq_mul_inv_iff_mul_eq IsUnit.eq_mul_inv_iff_mul_eqₓ'. -/
 @[to_additive]
 protected theorem eq_mul_inv_iff_mul_eq (h : IsUnit c) : a = b * c⁻¹ ↔ a * c = b :=
   h.unit'.eq_mul_inv_iff_mul_eq
 #align is_unit.eq_mul_inv_iff_mul_eq IsUnit.eq_mul_inv_iff_mul_eq
 #align is_add_unit.eq_add_neg_iff_add_eq IsAddUnit.eq_add_neg_iff_add_eq
 
-/- warning: is_unit.eq_inv_mul_iff_mul_eq -> IsUnit.eq_inv_mul_iff_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) c)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) b a) c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Iff (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) b) c)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) b a) c))
-Case conversion may be inaccurate. Consider using '#align is_unit.eq_inv_mul_iff_mul_eq IsUnit.eq_inv_mul_iff_mul_eqₓ'. -/
 @[to_additive]
 protected theorem eq_inv_mul_iff_mul_eq (h : IsUnit b) : a = b⁻¹ * c ↔ b * a = c :=
   h.unit'.eq_inv_mul_iff_mul_eq
 #align is_unit.eq_inv_mul_iff_mul_eq IsUnit.eq_inv_mul_iff_mul_eq
 #align is_add_unit.eq_neg_add_iff_add_eq IsAddUnit.eq_neg_add_iff_add_eq
 
-/- warning: is_unit.inv_mul_eq_iff_eq_mul -> IsUnit.inv_mul_eq_iff_eq_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) b) c) (Eq.{succ u1} α b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a c)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) a) b) c) (Eq.{succ u1} α b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a c)))
-Case conversion may be inaccurate. Consider using '#align is_unit.inv_mul_eq_iff_eq_mul IsUnit.inv_mul_eq_iff_eq_mulₓ'. -/
 @[to_additive]
 protected theorem inv_mul_eq_iff_eq_mul (h : IsUnit a) : a⁻¹ * b = c ↔ b = a * c :=
   h.unit'.inv_mul_eq_iff_eq_mul
 #align is_unit.inv_mul_eq_iff_eq_mul IsUnit.inv_mul_eq_iff_eq_mul
 #align is_add_unit.neg_add_eq_iff_eq_add IsAddUnit.neg_add_eq_iff_eq_add
 
-/- warning: is_unit.mul_inv_eq_iff_eq_mul -> IsUnit.mul_inv_eq_iff_eq_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b)) c) (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) c b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) b)) c) (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) c b)))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_inv_eq_iff_eq_mul IsUnit.mul_inv_eq_iff_eq_mulₓ'. -/
 @[to_additive]
 protected theorem mul_inv_eq_iff_eq_mul (h : IsUnit b) : a * b⁻¹ = c ↔ a = c * b :=
   h.unit'.mul_inv_eq_iff_eq_mul
 #align is_unit.mul_inv_eq_iff_eq_mul IsUnit.mul_inv_eq_iff_eq_mul
 #align is_add_unit.add_neg_eq_iff_eq_add IsAddUnit.add_neg_eq_iff_eq_add
 
-/- warning: is_unit.mul_inv_eq_one -> IsUnit.mul_inv_eq_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)))))))) (Eq.{succ u1} α a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) b)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1)))))) (Eq.{succ u1} α a b))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_inv_eq_one IsUnit.mul_inv_eq_oneₓ'. -/
 @[to_additive]
 protected theorem mul_inv_eq_one (h : IsUnit b) : a * b⁻¹ = 1 ↔ a = b :=
   @Units.mul_inv_eq_one _ _ h.unit' _
 #align is_unit.mul_inv_eq_one IsUnit.mul_inv_eq_one
 #align is_add_unit.add_neg_eq_zero IsAddUnit.add_neg_eq_zero
 
-/- warning: is_unit.inv_mul_eq_one -> IsUnit.inv_mul_eq_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)))))))) (Eq.{succ u1} α a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) a) b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1)))))) (Eq.{succ u1} α a b))
-Case conversion may be inaccurate. Consider using '#align is_unit.inv_mul_eq_one IsUnit.inv_mul_eq_oneₓ'. -/
 @[to_additive]
 protected theorem inv_mul_eq_one (h : IsUnit a) : a⁻¹ * b = 1 ↔ a = b :=
   @Units.inv_mul_eq_one _ _ h.unit' _
 #align is_unit.inv_mul_eq_one IsUnit.inv_mul_eq_one
 #align is_add_unit.neg_add_eq_zero IsAddUnit.neg_add_eq_zero
 
-/- warning: is_unit.mul_eq_one_iff_eq_inv -> IsUnit.mul_eq_one_iff_eq_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)))))))) (Eq.{succ u1} α a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1)))))) (Eq.{succ u1} α a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) b)))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_eq_one_iff_eq_inv IsUnit.mul_eq_one_iff_eq_invₓ'. -/
 @[to_additive]
 protected theorem mul_eq_one_iff_eq_inv (h : IsUnit b) : a * b = 1 ↔ a = b⁻¹ :=
   @Units.mul_eq_one_iff_eq_inv _ _ h.unit' _
 #align is_unit.mul_eq_one_iff_eq_inv IsUnit.mul_eq_one_iff_eq_inv
 #align is_add_unit.add_eq_zero_iff_eq_neg IsAddUnit.add_eq_zero_iff_eq_neg
 
-/- warning: is_unit.mul_eq_one_iff_inv_eq -> IsUnit.mul_eq_one_iff_inv_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)))))))) (Eq.{succ u1} α (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1)))))) (Eq.{succ u1} α (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) a) b))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_eq_one_iff_inv_eq IsUnit.mul_eq_one_iff_inv_eqₓ'. -/
 @[to_additive]
 protected theorem mul_eq_one_iff_inv_eq (h : IsUnit a) : a * b = 1 ↔ a⁻¹ = b :=
   @Units.mul_eq_one_iff_inv_eq _ _ h.unit' _
 #align is_unit.mul_eq_one_iff_inv_eq IsUnit.mul_eq_one_iff_inv_eq
 #align is_add_unit.add_eq_zero_iff_neg_eq IsAddUnit.add_eq_zero_iff_neg_eq
 
-/- warning: is_unit.div_mul_cancel -> IsUnit.div_mul_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (forall (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (forall (a : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b) b) a)
-Case conversion may be inaccurate. Consider using '#align is_unit.div_mul_cancel IsUnit.div_mul_cancelₓ'. -/
 @[simp, to_additive]
 protected theorem div_mul_cancel (h : IsUnit b) (a : α) : a / b * b = a := by
   rw [div_eq_mul_inv, h.inv_mul_cancel_right]
 #align is_unit.div_mul_cancel IsUnit.div_mul_cancel
 #align is_add_unit.sub_add_cancel IsAddUnit.sub_add_cancel
 
-/- warning: is_unit.mul_div_cancel -> IsUnit.mul_div_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (forall (a : α), Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (forall (a : α), Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b) b) a)
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_div_cancel IsUnit.mul_div_cancelₓ'. -/
 @[simp, to_additive]
 protected theorem mul_div_cancel (h : IsUnit b) (a : α) : a * b / b = a := by
   rw [div_eq_mul_inv, h.mul_inv_cancel_right]
 #align is_unit.mul_div_cancel IsUnit.mul_div_cancel
 #align is_add_unit.add_sub_cancel IsAddUnit.add_sub_cancel
 
-/- warning: is_unit.mul_one_div_cancel -> IsUnit.mul_one_div_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))))) a)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))))) a)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_one_div_cancel IsUnit.mul_one_div_cancelₓ'. -/
 @[to_additive]
 protected theorem mul_one_div_cancel (h : IsUnit a) : a * (1 / a) = 1 := by simp [h]
 #align is_unit.mul_one_div_cancel IsUnit.mul_one_div_cancel
 #align is_add_unit.add_zero_sub_cancel IsAddUnit.add_zero_sub_cancel
 
-/- warning: is_unit.one_div_mul_cancel -> IsUnit.one_div_mul_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))))) a) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))))) a) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align is_unit.one_div_mul_cancel IsUnit.one_div_mul_cancelₓ'. -/
 @[to_additive]
 protected theorem one_div_mul_cancel (h : IsUnit a) : 1 / a * a = 1 := by simp [h]
 #align is_unit.one_div_mul_cancel IsUnit.one_div_mul_cancel
 #align is_add_unit.zero_sub_add_cancel IsAddUnit.zero_sub_add_cancel
 
-/- warning: is_unit.inv -> IsUnit.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) a))
-Case conversion may be inaccurate. Consider using '#align is_unit.inv IsUnit.invₓ'. -/
 @[to_additive]
 theorem inv : IsUnit a → IsUnit a⁻¹ := by rintro ⟨u, rfl⟩; rw [← Units.val_inv_eq_inv_val];
   exact Units.isUnit _
 #align is_unit.inv IsUnit.inv
 #align is_add_unit.neg IsAddUnit.neg
 
-/- warning: is_unit.div -> IsUnit.div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b))
-Case conversion may be inaccurate. Consider using '#align is_unit.div IsUnit.divₓ'. -/
 @[to_additive]
 theorem div (ha : IsUnit a) (hb : IsUnit b) : IsUnit (a / b) := by rw [div_eq_mul_inv];
   exact ha.mul hb.inv
 #align is_unit.div IsUnit.div
 #align is_add_unit.sub IsAddUnit.sub
 
-/- warning: is_unit.div_left_inj -> IsUnit.div_left_inj is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) c) -> (Iff (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a c) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) b c)) (Eq.{succ u1} α a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) c) -> (Iff (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a c) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) b c)) (Eq.{succ u1} α a b))
-Case conversion may be inaccurate. Consider using '#align is_unit.div_left_inj IsUnit.div_left_injₓ'. -/
 @[to_additive]
 protected theorem div_left_inj (h : IsUnit c) : a / c = b / c ↔ a = b := by
   simp_rw [div_eq_mul_inv]; exact Units.mul_left_inj h.inv.unit'
 #align is_unit.div_left_inj IsUnit.div_left_inj
 #align is_add_unit.sub_left_inj IsAddUnit.sub_left_inj
 
-/- warning: is_unit.div_eq_iff -> IsUnit.div_eq_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Iff (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b) c) (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) c b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Iff (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b) c) (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) c b)))
-Case conversion may be inaccurate. Consider using '#align is_unit.div_eq_iff IsUnit.div_eq_iffₓ'. -/
 @[to_additive]
 protected theorem div_eq_iff (h : IsUnit b) : a / b = c ↔ a = c * b := by
   rw [div_eq_mul_inv, h.mul_inv_eq_iff_eq_mul]
 #align is_unit.div_eq_iff IsUnit.div_eq_iff
 #align is_add_unit.sub_eq_iff IsAddUnit.sub_eq_iff
 
-/- warning: is_unit.eq_div_iff -> IsUnit.eq_div_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) c) -> (Iff (Eq.{succ u1} α a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) b c)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a c) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) c) -> (Iff (Eq.{succ u1} α a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) b c)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a c) b))
-Case conversion may be inaccurate. Consider using '#align is_unit.eq_div_iff IsUnit.eq_div_iffₓ'. -/
 @[to_additive]
 protected theorem eq_div_iff (h : IsUnit c) : a = b / c ↔ a * c = b := by
   rw [div_eq_mul_inv, h.eq_mul_inv_iff_mul_eq]
 #align is_unit.eq_div_iff IsUnit.eq_div_iff
 #align is_add_unit.eq_sub_iff IsAddUnit.eq_sub_iff
 
-/- warning: is_unit.div_eq_of_eq_mul -> IsUnit.div_eq_of_eq_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) c b)) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) c b)) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b) c)
-Case conversion may be inaccurate. Consider using '#align is_unit.div_eq_of_eq_mul IsUnit.div_eq_of_eq_mulₓ'. -/
 @[to_additive]
 protected theorem div_eq_of_eq_mul (h : IsUnit b) : a = c * b → a / b = c :=
   h.div_eq_iff.2
 #align is_unit.div_eq_of_eq_mul IsUnit.div_eq_of_eq_mul
 #align is_add_unit.sub_eq_of_eq_add IsAddUnit.sub_eq_of_eq_add
 
-/- warning: is_unit.eq_div_of_mul_eq -> IsUnit.eq_div_of_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) c) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a c) b) -> (Eq.{succ u1} α a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) c) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a c) b) -> (Eq.{succ u1} α a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) b c))
-Case conversion may be inaccurate. Consider using '#align is_unit.eq_div_of_mul_eq IsUnit.eq_div_of_mul_eqₓ'. -/
 @[to_additive]
 protected theorem eq_div_of_mul_eq (h : IsUnit c) : a * c = b → a = b / c :=
   h.eq_div_iff.2
 #align is_unit.eq_div_of_mul_eq IsUnit.eq_div_of_mul_eq
 #align is_add_unit.eq_sub_of_add_eq IsAddUnit.eq_sub_of_add_eq
 
-/- warning: is_unit.div_eq_one_iff_eq -> IsUnit.div_eq_one_iff_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Iff (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)))))))) (Eq.{succ u1} α a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Iff (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1)))))) (Eq.{succ u1} α a b))
-Case conversion may be inaccurate. Consider using '#align is_unit.div_eq_one_iff_eq IsUnit.div_eq_one_iff_eqₓ'. -/
 @[to_additive]
 protected theorem div_eq_one_iff_eq (h : IsUnit b) : a / b = 1 ↔ a = b :=
   ⟨eq_of_div_eq_one, fun hab => hab.symm ▸ h.div_self⟩
 #align is_unit.div_eq_one_iff_eq IsUnit.div_eq_one_iff_eq
 #align is_add_unit.sub_eq_zero_iff_eq IsAddUnit.sub_eq_zero_iff_eq
 
-/- warning: is_unit.div_mul_left -> IsUnit.div_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))))) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))))) a))
-Case conversion may be inaccurate. Consider using '#align is_unit.div_mul_left IsUnit.div_mul_leftₓ'. -/
 /-- The `group` version of this lemma is `div_mul_cancel'''` -/
 @[to_additive "The `add_group` version of this lemma is `sub_add_cancel''`"]
 protected theorem div_mul_left (h : IsUnit b) : b / (a * b) = 1 / a := by
@@ -763,24 +445,12 @@ protected theorem div_mul_left (h : IsUnit b) : b / (a * b) = 1 / a := by
 #align is_unit.div_mul_left IsUnit.div_mul_left
 #align is_add_unit.sub_add_left IsAddUnit.sub_add_left
 
-/- warning: is_unit.mul_div_mul_right -> IsUnit.mul_div_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) c) -> (forall (a : α) (b : α), Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) b c)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) c) -> (forall (a : α) (b : α), Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) b c)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_div_mul_right IsUnit.mul_div_mul_rightₓ'. -/
 @[to_additive]
 protected theorem mul_div_mul_right (h : IsUnit c) (a b : α) : a * c / (b * c) = a / b := by
   simp only [div_eq_mul_inv, mul_inv_rev, mul_assoc, h.mul_inv_cancel_left]
 #align is_unit.mul_div_mul_right IsUnit.mul_div_mul_right
 #align is_add_unit.add_sub_add_right IsAddUnit.add_sub_add_right
 
-/- warning: is_unit.mul_mul_div -> IsUnit.mul_mul_div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {b : α} (a : α), (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))))) b)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {b : α} (a : α), (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))))) b)) a)
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_mul_div IsUnit.mul_mul_divₓ'. -/
 @[to_additive]
 protected theorem mul_mul_div (a : α) (h : IsUnit b) : a * b * (1 / b) = a := by simp [h]
 #align is_unit.mul_mul_div IsUnit.mul_mul_div
@@ -792,60 +462,30 @@ section DivisionCommMonoid
 
 variable [DivisionCommMonoid α] {a b c d : α}
 
-/- warning: is_unit.div_mul_right -> IsUnit.div_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) a) -> (forall (b : α), Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) a b)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))))) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) a) -> (forall (b : α), Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) a b)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) b))
-Case conversion may be inaccurate. Consider using '#align is_unit.div_mul_right IsUnit.div_mul_rightₓ'. -/
 @[to_additive]
 protected theorem div_mul_right (h : IsUnit a) (b : α) : a / (a * b) = 1 / b := by
   rw [mul_comm, h.div_mul_left]
 #align is_unit.div_mul_right IsUnit.div_mul_right
 #align is_add_unit.sub_add_right IsAddUnit.sub_add_right
 
-/- warning: is_unit.mul_div_cancel_left -> IsUnit.mul_div_cancel_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) a) -> (forall (b : α), Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) a b) a) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) a) -> (forall (b : α), Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) a b) a) b)
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_div_cancel_left IsUnit.mul_div_cancel_leftₓ'. -/
 @[to_additive]
 protected theorem mul_div_cancel_left (h : IsUnit a) (b : α) : a * b / a = b := by
   rw [mul_comm, h.mul_div_cancel]
 #align is_unit.mul_div_cancel_left IsUnit.mul_div_cancel_left
 #align is_add_unit.add_sub_cancel_left IsAddUnit.add_sub_cancel_left
 
-/- warning: is_unit.mul_div_cancel' -> IsUnit.mul_div_cancel' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) a) -> (forall (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) b a)) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) a) -> (forall (b : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) b a)) b)
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_div_cancel' IsUnit.mul_div_cancel'ₓ'. -/
 @[to_additive]
 protected theorem mul_div_cancel' (h : IsUnit a) (b : α) : a * (b / a) = b := by
   rw [mul_comm, h.div_mul_cancel]
 #align is_unit.mul_div_cancel' IsUnit.mul_div_cancel'
 #align is_add_unit.add_sub_cancel' IsAddUnit.add_sub_cancel'
 
-/- warning: is_unit.mul_div_mul_left -> IsUnit.mul_div_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) c) -> (forall (a : α) (b : α), Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) c a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) c b)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) c) -> (forall (a : α) (b : α), Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) c a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) c b)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a b))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_div_mul_left IsUnit.mul_div_mul_leftₓ'. -/
 @[to_additive]
 protected theorem mul_div_mul_left (h : IsUnit c) (a b : α) : c * a / (c * b) = a / b := by
   rw [mul_comm c, mul_comm c, h.mul_div_mul_right]
 #align is_unit.mul_div_mul_left IsUnit.mul_div_mul_left
 #align is_add_unit.add_sub_add_left IsAddUnit.add_sub_add_left
 
-/- warning: is_unit.mul_eq_mul_of_div_eq_div -> IsUnit.mul_eq_mul_of_div_eq_div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {b : α} {d : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) b) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) d) -> (forall (a : α) (c : α), (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) c d)) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) a d) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) c b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {b : α} {d : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) b) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) d) -> (forall (a : α) (c : α), (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) c d)) -> (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) a d) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) c b)))
-Case conversion may be inaccurate. Consider using '#align is_unit.mul_eq_mul_of_div_eq_div IsUnit.mul_eq_mul_of_div_eq_divₓ'. -/
 @[to_additive]
 protected theorem mul_eq_mul_of_div_eq_div (hb : IsUnit b) (hd : IsUnit d) (a c : α)
     (h : a / b = c / d) : a * d = c * b := by
@@ -853,12 +493,6 @@ protected theorem mul_eq_mul_of_div_eq_div (hb : IsUnit b) (hd : IsUnit d) (a c
 #align is_unit.mul_eq_mul_of_div_eq_div IsUnit.mul_eq_mul_of_div_eq_div
 #align is_add_unit.add_eq_add_of_sub_eq_sub IsAddUnit.add_eq_add_of_sub_eq_sub
 
-/- warning: is_unit.div_eq_div_iff -> IsUnit.div_eq_div_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α} {b : α} {c : α} {d : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) b) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) d) -> (Iff (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) c d)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) a d) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) c b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α} {b : α} {c : α} {d : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) b) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) d) -> (Iff (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) c d)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) a d) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))))) c b)))
-Case conversion may be inaccurate. Consider using '#align is_unit.div_eq_div_iff IsUnit.div_eq_div_iffₓ'. -/
 @[to_additive]
 protected theorem div_eq_div_iff (hb : IsUnit b) (hd : IsUnit d) : a / b = c / d ↔ a * d = c * b :=
   by
@@ -867,24 +501,12 @@ protected theorem div_eq_div_iff (hb : IsUnit b) (hd : IsUnit d) : a / b = c / d
 #align is_unit.div_eq_div_iff IsUnit.div_eq_div_iff
 #align is_add_unit.sub_eq_sub_iff IsAddUnit.sub_eq_sub_iff
 
-/- warning: is_unit.div_div_cancel -> IsUnit.div_div_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) a) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a b)) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) a) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a b)) b)
-Case conversion may be inaccurate. Consider using '#align is_unit.div_div_cancel IsUnit.div_div_cancelₓ'. -/
 @[to_additive]
 protected theorem div_div_cancel (h : IsUnit a) : a / (a / b) = b := by
   rw [div_div_eq_mul_div, h.mul_div_cancel_left]
 #align is_unit.div_div_cancel IsUnit.div_div_cancel
 #align is_add_unit.sub_sub_cancel IsAddUnit.sub_sub_cancel
 
-/- warning: is_unit.div_div_cancel_left -> IsUnit.div_div_cancel_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) a) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a b) a) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) a) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a b) a) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) b))
-Case conversion may be inaccurate. Consider using '#align is_unit.div_div_cancel_left IsUnit.div_div_cancel_leftₓ'. -/
 @[to_additive]
 protected theorem div_div_cancel_left (h : IsUnit a) : a / b / a = b⁻¹ := by
   rw [div_eq_mul_inv, div_eq_mul_inv, mul_right_comm, h.mul_inv_cancel, one_mul]

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -661,9 +661,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))) a))
 Case conversion may be inaccurate. Consider using '#align is_unit.inv IsUnit.invₓ'. -/
 @[to_additive]
-theorem inv : IsUnit a → IsUnit a⁻¹ := by
-  rintro ⟨u, rfl⟩
-  rw [← Units.val_inv_eq_inv_val]
+theorem inv : IsUnit a → IsUnit a⁻¹ := by rintro ⟨u, rfl⟩; rw [← Units.val_inv_eq_inv_val];
   exact Units.isUnit _
 #align is_unit.inv IsUnit.inv
 #align is_add_unit.neg IsAddUnit.neg
@@ -675,9 +673,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) a) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a b))
 Case conversion may be inaccurate. Consider using '#align is_unit.div IsUnit.divₓ'. -/
 @[to_additive]
-theorem div (ha : IsUnit a) (hb : IsUnit b) : IsUnit (a / b) :=
-  by
-  rw [div_eq_mul_inv]
+theorem div (ha : IsUnit a) (hb : IsUnit b) : IsUnit (a / b) := by rw [div_eq_mul_inv];
   exact ha.mul hb.inv
 #align is_unit.div IsUnit.div
 #align is_add_unit.sub IsAddUnit.sub
@@ -689,10 +685,8 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α} {c : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) c) -> (Iff (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) a c) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) b c)) (Eq.{succ u1} α a b))
 Case conversion may be inaccurate. Consider using '#align is_unit.div_left_inj IsUnit.div_left_injₓ'. -/
 @[to_additive]
-protected theorem div_left_inj (h : IsUnit c) : a / c = b / c ↔ a = b :=
-  by
-  simp_rw [div_eq_mul_inv]
-  exact Units.mul_left_inj h.inv.unit'
+protected theorem div_left_inj (h : IsUnit c) : a / c = b / c ↔ a = b := by
+  simp_rw [div_eq_mul_inv]; exact Units.mul_left_inj h.inv.unit'
 #align is_unit.div_left_inj IsUnit.div_left_inj
 #align is_add_unit.sub_left_inj IsAddUnit.sub_left_inj

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -51,7 +51,7 @@ section MonoidHomClass
 lean 3 declaration is
   forall {F : Type.{u1}} {G : Type.{u2}} {N : Type.{u3}} [_inst_1 : DivisionMonoid.{u2} G] [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2)] {x : G}, (IsUnit.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x) -> (forall (f : F) (g : F), (Eq.{succ u3} N (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) f x) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) g x)) -> (Eq.{succ u3} N (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) f (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x)) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) g (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x))))
 but is expected to have type
-  forall {F : Type.{u3}} {G : Type.{u2}} {N : Type.{u1}} [_inst_1 : DivisionMonoid.{u2} G] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2)] {x : G}, (IsUnit.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x) -> (forall (f : F) (g : F), (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x))))
+  forall {F : Type.{u3}} {G : Type.{u2}} {N : Type.{u1}} [_inst_1 : DivisionMonoid.{u2} G] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2)] {x : G}, (IsUnit.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x) -> (forall (f : F) (g : F), (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x))))
 Case conversion may be inaccurate. Consider using '#align is_unit.eq_on_inv IsUnit.eq_on_invₓ'. -/
 /-- If two homomorphisms from a division monoid to a monoid are equal at a unit `x`, then they are
 equal at `x⁻¹`. -/
@@ -68,7 +68,7 @@ theorem IsUnit.eq_on_inv {F G N} [DivisionMonoid G] [Monoid N] [MonoidHomClass F
 lean 3 declaration is
   forall {F : Type.{u1}} {G : Type.{u2}} {M : Type.{u3}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u3} M] [_inst_3 : MonoidHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2)] (f : F) (g : F) {x : G}, (Eq.{succ u3} M (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) f x) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) g x)) -> (Eq.{succ u3} M (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) f (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) x)) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) g (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) x)))
 but is expected to have type
-  forall {F : Type.{u3}} {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)] (f : F) (g : F) {x : G}, (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)))
+  forall {F : Type.{u3}} {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)] (f : F) (g : F) {x : G}, (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)))
 Case conversion may be inaccurate. Consider using '#align eq_on_inv eq_on_invₓ'. -/
 /-- If two homomorphism from a group to a monoid are equal at `x`, then they are equal at `x⁻¹`. -/
 @[to_additive
@@ -106,7 +106,7 @@ def map (f : M →* N) : Mˣ →* Nˣ :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (x : Units.{u1} M _inst_1), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => (Units.{u1} M _inst_1) -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) x))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (x : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) (Units.val.{u1} M _inst_1 x)) (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 x))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (x : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) (Units.val.{u1} M _inst_1 x)) (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 x))
 Case conversion may be inaccurate. Consider using '#align units.coe_map Units.coe_mapₓ'. -/
 @[simp, to_additive]
 theorem coe_map (f : M →* N) (x : Mˣ) : ↑(map f x) = f x :=
@@ -118,7 +118,7 @@ theorem coe_map (f : M →* N) (x : Mˣ) : ↑(map f x) = f x :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => (Units.{u1} M _inst_1) -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) u)))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInv.{u1} M _inst_1) u))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) u) (Units.instInv.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInv.{u1} M _inst_1) u)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInv.{u1} M _inst_1) u))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) u) (Units.instInv.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInv.{u1} M _inst_1) u)))
 Case conversion may be inaccurate. Consider using '#align units.coe_map_inv Units.coe_map_invₓ'. -/
 @[simp, to_additive]
 theorem coe_map_inv (f : M →* N) (u : Mˣ) : ↑(map f u)⁻¹ = f ↑u⁻¹ :=
@@ -170,7 +170,7 @@ variable {M}
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : Units.{u1} M _inst_1), Eq.{succ u1} M (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) => (Units.{u1} M _inst_1) -> M) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.coeHom.{u1} M _inst_1) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) x)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : Units.{u1} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => M) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)))) (Units.coeHom.{u1} M _inst_1) x) (Units.val.{u1} M _inst_1 x)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : Units.{u1} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_1) => M) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} M _inst_1) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)))) (Units.coeHom.{u1} M _inst_1) x) (Units.val.{u1} M _inst_1 x)
 Case conversion may be inaccurate. Consider using '#align units.coe_hom_apply Units.coeHom_applyₓ'. -/
 @[simp, to_additive]
 theorem coeHom_apply (x : Mˣ) : coeHom M x = ↑x :=
@@ -231,7 +231,7 @@ theorem divp_eq_div (a : α) (u : αˣ) : a /ₚ u = a / u := by rw [div_eq_mul_
 lean 3 declaration is
   forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : DivisionMonoid.{u2} α] {F : Type.{u3}} [_inst_5 : MonoidHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))] (f : F) (u : Units.{u1} M _inst_1), Eq.{succ u2} α (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> α) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => α) (MulHomClass.toFunLike.{u3, u1, u2} F M α (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4))) _inst_5))) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) u))) (Inv.inv.{u2} α (DivInvMonoid.toHasInv.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> α) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => α) (MulHomClass.toFunLike.{u3, u1, u2} F M α (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4))) _inst_5))) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) u)))
 but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u3}} [_inst_1 : Monoid.{u3} M] [_inst_4 : DivisionMonoid.{u1} α] {F : Type.{u2}} [_inst_5 : MonoidHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))] (f : F) (u : Units.{u3} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInv.{u3} M _inst_1) u))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInv.{u3} M _inst_1) u))) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) (InvOneClass.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) _inst_4))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 u)))
+  forall {α : Type.{u1}} {M : Type.{u3}} [_inst_1 : Monoid.{u3} M] [_inst_4 : DivisionMonoid.{u1} α] {F : Type.{u2}} [_inst_5 : MonoidHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))] (f : F) (u : Units.{u3} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInv.{u3} M _inst_1) u))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInv.{u3} M _inst_1) u))) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) (Units.val.{u3} M _inst_1 u)) (InvOneClass.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) (Units.val.{u3} M _inst_1 u)) _inst_4))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 u)))
 Case conversion may be inaccurate. Consider using '#align map_units_inv map_units_invₓ'. -/
 @[simp, to_additive]
 theorem map_units_inv {F : Type _} [MonoidHomClass F M α] (f : F) (u : Units M) :
@@ -246,7 +246,7 @@ end DivisionMonoid
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : M -> (Units.{u2} N _inst_2)), (forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : M -> (Units.{u2} N _inst_2)), (forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : M -> (Units.{u2} N _inst_2)), (forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.lift_right Units.liftRightₓ'. -/
 /-- If a map `g : M → Nˣ` agrees with a homomorphism `f : M →* N`, then
 this map is a monoid homomorphism too. -/
@@ -264,7 +264,7 @@ def liftRight (f : M →* N) (g : M → Nˣ) (h : ∀ x, ↑(g x) = f x) : M →
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} N (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} N (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)
 Case conversion may be inaccurate. Consider using '#align units.coe_lift_right Units.coe_liftRightₓ'. -/
 @[simp, to_additive]
 theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
@@ -277,7 +277,7 @@ theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x)
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) x) (Units.instInv.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u2} N _inst_2) x) (Units.instInv.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align units.mul_lift_right_inv Units.mul_liftRight_invₓ'. -/
 @[simp, to_additive]
 theorem mul_liftRight_inv {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
@@ -289,7 +289,7 @@ theorem mul_liftRight_inv {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) =
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) x) (Units.instInv.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u2} N _inst_2) x) (Units.instInv.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align units.lift_right_inv_mul Units.liftRight_inv_mulₓ'. -/
 @[simp, to_additive]
 theorem liftRight_inv_mul {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
@@ -323,7 +323,7 @@ def toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) : G →* Mˣ :
 lean 3 declaration is
   forall {G : Type.{u1}} {M : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Monoid.{u2} M] (f : MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) (g : G), Eq.{succ u2} M ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} M _inst_2) M (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} M _inst_2) M (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} M _inst_2) M (coeBase.{succ u2, succ u2} (Units.{u2} M _inst_2) M (Units.hasCoe.{u2} M _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2)) (fun (_x : MonoidHom.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2)) => G -> (Units.{u2} M _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2)) (MonoidHom.toHomUnits.{u1, u2} G M _inst_1 _inst_2 f) g)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) (fun (_x : MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) => G -> M) (MonoidHom.hasCoeToFun.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) f g)
 but is expected to have type
-  forall {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] (f : MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) (g : G), Eq.{succ u1} M (Units.val.{u1} M _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => Units.{u1} M _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)))) (MonoidHom.toHomUnits.{u2, u1} G M _inst_1 _inst_2 f) g)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)))) f g)
+  forall {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] (f : MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) (g : G), Eq.{succ u1} M (Units.val.{u1} M _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => Units.{u1} M _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)))) (MonoidHom.toHomUnits.{u2, u1} G M _inst_1 _inst_2 f) g)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => M) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)))) f g)
 Case conversion may be inaccurate. Consider using '#align monoid_hom.coe_to_hom_units MonoidHom.coe_toHomUnitsₓ'. -/
 @[simp, to_additive]
 theorem coe_toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) (g : G) :
@@ -346,7 +346,7 @@ variable [Monoid M] [Monoid N]
 lean 3 declaration is
   forall {F : Type.{u1}} {M : Type.{u2}} {N : Type.{u3}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u1, u2, u3} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (f : F) {x : M}, (IsUnit.{u2} M _inst_1 x) -> (IsUnit.{u3} N _inst_2 (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u2, u3} F M N (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) f x))
 but is expected to have type
-  forall {F : Type.{u3}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) {x : M}, (IsUnit.{u2} M _inst_1 x) -> (IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x))
+  forall {F : Type.{u3}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) {x : M}, (IsUnit.{u2} M _inst_1 x) -> (IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x))
 Case conversion may be inaccurate. Consider using '#align is_unit.map IsUnit.mapₓ'. -/
 @[to_additive]
 theorem map [MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x) : IsUnit (f x) := by
@@ -358,7 +358,7 @@ theorem map [MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x) : IsUnit (f x)
 lean 3 declaration is
   forall {F : Type.{u1}} {G : Type.{u2}} {M : Type.{u3}} {N : Type.{u4}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u4} N] [_inst_3 : MonoidHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2)] [_inst_4 : MonoidHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u4} M N (coeFn.{succ u2, max (succ u4) (succ u3)} G (fun (_x : G) => N -> M) (FunLike.hasCoeToFun.{succ u2, succ u4, succ u3} G N (fun (_x : N) => M) (MulHomClass.toFunLike.{u2, u4, u3} G N M (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4))) g) (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f)) -> (IsUnit.{u4} N _inst_2 (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f x)) -> (IsUnit.{u3} M _inst_1 x)
 but is expected to have type
-  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) -> (IsUnit.{u3} M _inst_1 x)
+  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) -> (IsUnit.{u3} M _inst_1 x)
 Case conversion may be inaccurate. Consider using '#align is_unit.of_left_inverse IsUnit.of_leftInverseₓ'. -/
 @[to_additive]
 theorem of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x : M} (g : G)
@@ -371,7 +371,7 @@ theorem of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x
 lean 3 declaration is
   forall {F : Type.{u1}} {G : Type.{u2}} {M : Type.{u3}} {N : Type.{u4}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u4} N] [_inst_3 : MonoidHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2)] [_inst_4 : MonoidHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u4} M N (coeFn.{succ u2, max (succ u4) (succ u3)} G (fun (_x : G) => N -> M) (FunLike.hasCoeToFun.{succ u2, succ u4, succ u3} G N (fun (_x : N) => M) (MulHomClass.toFunLike.{u2, u4, u3} G N M (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4))) g) (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f)) -> (Iff (IsUnit.{u4} N _inst_2 (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f x)) (IsUnit.{u3} M _inst_1 x))
 but is expected to have type
-  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (Iff (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) (IsUnit.{u3} M _inst_1 x))
+  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (Iff (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) (IsUnit.{u3} M _inst_1 x))
 Case conversion may be inaccurate. Consider using '#align is_unit_map_of_left_inverse isUnit_map_of_leftInverseₓ'. -/
 @[to_additive]
 theorem isUnit_map_of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x : M}
@@ -384,7 +384,7 @@ theorem isUnit_map_of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M]
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)), (forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)), (forall (x : M), IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)), (forall (x : M), IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
 Case conversion may be inaccurate. Consider using '#align is_unit.lift_right IsUnit.liftRightₓ'. -/
 /-- If a homomorphism `f : M →* N` sends each element to an `is_unit`, then it can be lifted
 to `f : M →* Nˣ`. See also `units.lift_right` for a computable version. -/
@@ -399,7 +399,7 @@ noncomputable def liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) : M →* N
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (hf : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f hf) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (hf : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} N (Units.val.{u1} N _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f hf) x)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (hf : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} N (Units.val.{u1} N _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f hf) x)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)
 Case conversion may be inaccurate. Consider using '#align is_unit.coe_lift_right IsUnit.coe_liftRightₓ'. -/
 @[to_additive]
 theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
@@ -412,7 +412,7 @@ theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (h : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) x) (Units.instInv.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u1} N _inst_2) x) (Units.instInv.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align is_unit.mul_lift_right_inv IsUnit.mul_liftRight_invₓ'. -/
 @[simp, to_additive]
 theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
@@ -425,7 +425,7 @@ theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (h : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f h) x))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) x) (Units.instInv.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2))) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u1} N _inst_2) x) (Units.instInv.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align is_unit.lift_right_inv_mul IsUnit.liftRight_inv_mulₓ'. -/
 @[simp, to_additive]
 theorem liftRight_inv_mul (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :

bump to nightly-2023-05-11-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/28b2a92f2996d28e580450863c130955de0ed398

1eda273d

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin, Chris Hughes, Kevin Buzzard
 
 ! This file was ported from Lean 3 source module algebra.hom.units
-! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
+! leanprover-community/mathlib commit a07d750983b94c530ab69a726862c2ab6802b38c
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -762,7 +762,8 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)) b) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))))) a))
 Case conversion may be inaccurate. Consider using '#align is_unit.div_mul_left IsUnit.div_mul_leftₓ'. -/
-@[to_additive]
+/-- The `group` version of this lemma is `div_mul_cancel'''` -/
+@[to_additive "The `add_group` version of this lemma is `sub_add_cancel''`"]
 protected theorem div_mul_left (h : IsUnit b) : b / (a * b) = 1 / a := by
   rw [div_eq_mul_inv, mul_inv_rev, h.mul_inv_cancel_left, one_div]
 #align is_unit.div_mul_left IsUnit.div_mul_left

bump to nightly-2023-04-25-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/2651125b48fc5c170ab1111afd0817c903b1fc6c

56c36841

Diff

@@ -118,7 +118,7 @@ theorem coe_map (f : M →* N) (x : Mˣ) : ↑(map f x) = f x :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => (Units.{u1} M _inst_1) -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) u)))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInvUnits.{u1} M _inst_1) u))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) u) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInvUnits.{u1} M _inst_1) u)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInv.{u1} M _inst_1) u))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) u) (Units.instInv.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInv.{u1} M _inst_1) u)))
 Case conversion may be inaccurate. Consider using '#align units.coe_map_inv Units.coe_map_invₓ'. -/
 @[simp, to_additive]
 theorem coe_map_inv (f : M →* N) (u : Mˣ) : ↑(map f u)⁻¹ = f ↑u⁻¹ :=
@@ -231,7 +231,7 @@ theorem divp_eq_div (a : α) (u : αˣ) : a /ₚ u = a / u := by rw [div_eq_mul_
 lean 3 declaration is
   forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : DivisionMonoid.{u2} α] {F : Type.{u3}} [_inst_5 : MonoidHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))] (f : F) (u : Units.{u1} M _inst_1), Eq.{succ u2} α (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> α) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => α) (MulHomClass.toFunLike.{u3, u1, u2} F M α (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4))) _inst_5))) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) u))) (Inv.inv.{u2} α (DivInvMonoid.toHasInv.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> α) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => α) (MulHomClass.toFunLike.{u3, u1, u2} F M α (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4))) _inst_5))) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) u)))
 but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u3}} [_inst_1 : Monoid.{u3} M] [_inst_4 : DivisionMonoid.{u1} α] {F : Type.{u2}} [_inst_5 : MonoidHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))] (f : F) (u : Units.{u3} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInvUnits.{u3} M _inst_1) u))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInvUnits.{u3} M _inst_1) u))) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) (InvOneClass.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) _inst_4))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 u)))
+  forall {α : Type.{u1}} {M : Type.{u3}} [_inst_1 : Monoid.{u3} M] [_inst_4 : DivisionMonoid.{u1} α] {F : Type.{u2}} [_inst_5 : MonoidHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))] (f : F) (u : Units.{u3} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInv.{u3} M _inst_1) u))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInv.{u3} M _inst_1) u))) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) (InvOneClass.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) _inst_4))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 u)))
 Case conversion may be inaccurate. Consider using '#align map_units_inv map_units_invₓ'. -/
 @[simp, to_additive]
 theorem map_units_inv {F : Type _} [MonoidHomClass F M α] (f : F) (u : Units M) :
@@ -277,7 +277,7 @@ theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x)
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) x) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) x) (Units.instInv.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align units.mul_lift_right_inv Units.mul_liftRight_invₓ'. -/
 @[simp, to_additive]
 theorem mul_liftRight_inv {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
@@ -289,7 +289,7 @@ theorem mul_liftRight_inv {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) =
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) x) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) x) (Units.instInv.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align units.lift_right_inv_mul Units.liftRight_inv_mulₓ'. -/
 @[simp, to_additive]
 theorem liftRight_inv_mul {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
@@ -412,7 +412,7 @@ theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (h : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) x) (Units.instInvUnits.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) x) (Units.instInv.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align is_unit.mul_lift_right_inv IsUnit.mul_liftRight_invₓ'. -/
 @[simp, to_additive]
 theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
@@ -425,7 +425,7 @@ theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (h : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f h) x))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) x) (Units.instInvUnits.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) x) (Units.instInv.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align is_unit.lift_right_inv_mul IsUnit.liftRight_inv_mulₓ'. -/
 @[simp, to_additive]
 theorem liftRight_inv_mul (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -51,7 +51,7 @@ section MonoidHomClass
 lean 3 declaration is
   forall {F : Type.{u1}} {G : Type.{u2}} {N : Type.{u3}} [_inst_1 : DivisionMonoid.{u2} G] [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2)] {x : G}, (IsUnit.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x) -> (forall (f : F) (g : F), (Eq.{succ u3} N (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) f x) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) g x)) -> (Eq.{succ u3} N (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) f (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x)) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) g (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x))))
 but is expected to have type
-  forall {F : Type.{u3}} {G : Type.{u2}} {N : Type.{u1}} [_inst_1 : DivisionMonoid.{u2} G] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2)] {x : G}, (IsUnit.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x) -> (forall (f : F) (g : F), (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x))))
+  forall {F : Type.{u3}} {G : Type.{u2}} {N : Type.{u1}} [_inst_1 : DivisionMonoid.{u2} G] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2)] {x : G}, (IsUnit.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x) -> (forall (f : F) (g : F), (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x))))
 Case conversion may be inaccurate. Consider using '#align is_unit.eq_on_inv IsUnit.eq_on_invₓ'. -/
 /-- If two homomorphisms from a division monoid to a monoid are equal at a unit `x`, then they are
 equal at `x⁻¹`. -/
@@ -68,7 +68,7 @@ theorem IsUnit.eq_on_inv {F G N} [DivisionMonoid G] [Monoid N] [MonoidHomClass F
 lean 3 declaration is
   forall {F : Type.{u1}} {G : Type.{u2}} {M : Type.{u3}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u3} M] [_inst_3 : MonoidHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2)] (f : F) (g : F) {x : G}, (Eq.{succ u3} M (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) f x) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) g x)) -> (Eq.{succ u3} M (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) f (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) x)) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) g (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) x)))
 but is expected to have type
-  forall {F : Type.{u3}} {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)] (f : F) (g : F) {x : G}, (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)))
+  forall {F : Type.{u3}} {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)] (f : F) (g : F) {x : G}, (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)))
 Case conversion may be inaccurate. Consider using '#align eq_on_inv eq_on_invₓ'. -/
 /-- If two homomorphism from a group to a monoid are equal at `x`, then they are equal at `x⁻¹`. -/
 @[to_additive
@@ -106,7 +106,7 @@ def map (f : M →* N) : Mˣ →* Nˣ :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (x : Units.{u1} M _inst_1), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => (Units.{u1} M _inst_1) -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) x))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (x : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) (Units.val.{u1} M _inst_1 x)) (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 x))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (x : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) (Units.val.{u1} M _inst_1 x)) (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 x))
 Case conversion may be inaccurate. Consider using '#align units.coe_map Units.coe_mapₓ'. -/
 @[simp, to_additive]
 theorem coe_map (f : M →* N) (x : Mˣ) : ↑(map f x) = f x :=
@@ -118,7 +118,7 @@ theorem coe_map (f : M →* N) (x : Mˣ) : ↑(map f x) = f x :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => (Units.{u1} M _inst_1) -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) u)))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInvUnits.{u1} M _inst_1) u))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) u) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInvUnits.{u1} M _inst_1) u)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInvUnits.{u1} M _inst_1) u))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) u) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInvUnits.{u1} M _inst_1) u)))
 Case conversion may be inaccurate. Consider using '#align units.coe_map_inv Units.coe_map_invₓ'. -/
 @[simp, to_additive]
 theorem coe_map_inv (f : M →* N) (u : Mˣ) : ↑(map f u)⁻¹ = f ↑u⁻¹ :=
@@ -170,7 +170,7 @@ variable {M}
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : Units.{u1} M _inst_1), Eq.{succ u1} M (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) => (Units.{u1} M _inst_1) -> M) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.coeHom.{u1} M _inst_1) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) x)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : Units.{u1} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_1) => M) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_1) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)))) (Units.coeHom.{u1} M _inst_1) x) (Units.val.{u1} M _inst_1 x)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : Units.{u1} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => M) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} M _inst_1) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)))) (Units.coeHom.{u1} M _inst_1) x) (Units.val.{u1} M _inst_1 x)
 Case conversion may be inaccurate. Consider using '#align units.coe_hom_apply Units.coeHom_applyₓ'. -/
 @[simp, to_additive]
 theorem coeHom_apply (x : Mˣ) : coeHom M x = ↑x :=
@@ -231,7 +231,7 @@ theorem divp_eq_div (a : α) (u : αˣ) : a /ₚ u = a / u := by rw [div_eq_mul_
 lean 3 declaration is
   forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : DivisionMonoid.{u2} α] {F : Type.{u3}} [_inst_5 : MonoidHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))] (f : F) (u : Units.{u1} M _inst_1), Eq.{succ u2} α (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> α) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => α) (MulHomClass.toFunLike.{u3, u1, u2} F M α (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4))) _inst_5))) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) u))) (Inv.inv.{u2} α (DivInvMonoid.toHasInv.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> α) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => α) (MulHomClass.toFunLike.{u3, u1, u2} F M α (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4))) _inst_5))) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) u)))
 but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u3}} [_inst_1 : Monoid.{u3} M] [_inst_4 : DivisionMonoid.{u1} α] {F : Type.{u2}} [_inst_5 : MonoidHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))] (f : F) (u : Units.{u3} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInvUnits.{u3} M _inst_1) u))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInvUnits.{u3} M _inst_1) u))) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) (Units.val.{u3} M _inst_1 u)) (InvOneClass.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) (Units.val.{u3} M _inst_1 u)) _inst_4))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 u)))
+  forall {α : Type.{u1}} {M : Type.{u3}} [_inst_1 : Monoid.{u3} M] [_inst_4 : DivisionMonoid.{u1} α] {F : Type.{u2}} [_inst_5 : MonoidHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))] (f : F) (u : Units.{u3} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInvUnits.{u3} M _inst_1) u))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInvUnits.{u3} M _inst_1) u))) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) (InvOneClass.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) (Units.val.{u3} M _inst_1 u)) _inst_4))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 u)))
 Case conversion may be inaccurate. Consider using '#align map_units_inv map_units_invₓ'. -/
 @[simp, to_additive]
 theorem map_units_inv {F : Type _} [MonoidHomClass F M α] (f : F) (u : Units M) :
@@ -246,7 +246,7 @@ end DivisionMonoid
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : M -> (Units.{u2} N _inst_2)), (forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : M -> (Units.{u2} N _inst_2)), (forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : M -> (Units.{u2} N _inst_2)), (forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.lift_right Units.liftRightₓ'. -/
 /-- If a map `g : M → Nˣ` agrees with a homomorphism `f : M →* N`, then
 this map is a monoid homomorphism too. -/
@@ -264,7 +264,7 @@ def liftRight (f : M →* N) (g : M → Nˣ) (h : ∀ x, ↑(g x) = f x) : M →
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} N (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} N (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)
 Case conversion may be inaccurate. Consider using '#align units.coe_lift_right Units.coe_liftRightₓ'. -/
 @[simp, to_additive]
 theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
@@ -277,7 +277,7 @@ theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x)
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u2} N _inst_2) x) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) x) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align units.mul_lift_right_inv Units.mul_liftRight_invₓ'. -/
 @[simp, to_additive]
 theorem mul_liftRight_inv {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
@@ -289,7 +289,7 @@ theorem mul_liftRight_inv {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) =
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u2} N _inst_2) x) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) x) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align units.lift_right_inv_mul Units.liftRight_inv_mulₓ'. -/
 @[simp, to_additive]
 theorem liftRight_inv_mul {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
@@ -323,7 +323,7 @@ def toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) : G →* Mˣ :
 lean 3 declaration is
   forall {G : Type.{u1}} {M : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Monoid.{u2} M] (f : MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) (g : G), Eq.{succ u2} M ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} M _inst_2) M (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} M _inst_2) M (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} M _inst_2) M (coeBase.{succ u2, succ u2} (Units.{u2} M _inst_2) M (Units.hasCoe.{u2} M _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2)) (fun (_x : MonoidHom.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2)) => G -> (Units.{u2} M _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2)) (MonoidHom.toHomUnits.{u1, u2} G M _inst_1 _inst_2 f) g)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) (fun (_x : MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) => G -> M) (MonoidHom.hasCoeToFun.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) f g)
 but is expected to have type
-  forall {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] (f : MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) (g : G), Eq.{succ u1} M (Units.val.{u1} M _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => Units.{u1} M _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)))) (MonoidHom.toHomUnits.{u2, u1} G M _inst_1 _inst_2 f) g)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)))) f g)
+  forall {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] (f : MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) (g : G), Eq.{succ u1} M (Units.val.{u1} M _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => Units.{u1} M _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)))) (MonoidHom.toHomUnits.{u2, u1} G M _inst_1 _inst_2 f) g)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => M) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)))) f g)
 Case conversion may be inaccurate. Consider using '#align monoid_hom.coe_to_hom_units MonoidHom.coe_toHomUnitsₓ'. -/
 @[simp, to_additive]
 theorem coe_toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) (g : G) :
@@ -346,7 +346,7 @@ variable [Monoid M] [Monoid N]
 lean 3 declaration is
   forall {F : Type.{u1}} {M : Type.{u2}} {N : Type.{u3}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u1, u2, u3} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (f : F) {x : M}, (IsUnit.{u2} M _inst_1 x) -> (IsUnit.{u3} N _inst_2 (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u2, u3} F M N (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) f x))
 but is expected to have type
-  forall {F : Type.{u3}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) {x : M}, (IsUnit.{u2} M _inst_1 x) -> (IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x))
+  forall {F : Type.{u3}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) {x : M}, (IsUnit.{u2} M _inst_1 x) -> (IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x))
 Case conversion may be inaccurate. Consider using '#align is_unit.map IsUnit.mapₓ'. -/
 @[to_additive]
 theorem map [MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x) : IsUnit (f x) := by
@@ -358,7 +358,7 @@ theorem map [MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x) : IsUnit (f x)
 lean 3 declaration is
   forall {F : Type.{u1}} {G : Type.{u2}} {M : Type.{u3}} {N : Type.{u4}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u4} N] [_inst_3 : MonoidHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2)] [_inst_4 : MonoidHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u4} M N (coeFn.{succ u2, max (succ u4) (succ u3)} G (fun (_x : G) => N -> M) (FunLike.hasCoeToFun.{succ u2, succ u4, succ u3} G N (fun (_x : N) => M) (MulHomClass.toFunLike.{u2, u4, u3} G N M (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4))) g) (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f)) -> (IsUnit.{u4} N _inst_2 (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f x)) -> (IsUnit.{u3} M _inst_1 x)
 but is expected to have type
-  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) -> (IsUnit.{u3} M _inst_1 x)
+  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) -> (IsUnit.{u3} M _inst_1 x)
 Case conversion may be inaccurate. Consider using '#align is_unit.of_left_inverse IsUnit.of_leftInverseₓ'. -/
 @[to_additive]
 theorem of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x : M} (g : G)
@@ -371,7 +371,7 @@ theorem of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x
 lean 3 declaration is
   forall {F : Type.{u1}} {G : Type.{u2}} {M : Type.{u3}} {N : Type.{u4}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u4} N] [_inst_3 : MonoidHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2)] [_inst_4 : MonoidHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u4} M N (coeFn.{succ u2, max (succ u4) (succ u3)} G (fun (_x : G) => N -> M) (FunLike.hasCoeToFun.{succ u2, succ u4, succ u3} G N (fun (_x : N) => M) (MulHomClass.toFunLike.{u2, u4, u3} G N M (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4))) g) (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f)) -> (Iff (IsUnit.{u4} N _inst_2 (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f x)) (IsUnit.{u3} M _inst_1 x))
 but is expected to have type
-  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (Iff (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) (IsUnit.{u3} M _inst_1 x))
+  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (Iff (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) (IsUnit.{u3} M _inst_1 x))
 Case conversion may be inaccurate. Consider using '#align is_unit_map_of_left_inverse isUnit_map_of_leftInverseₓ'. -/
 @[to_additive]
 theorem isUnit_map_of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x : M}
@@ -384,7 +384,7 @@ theorem isUnit_map_of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M]
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)), (forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)), (forall (x : M), IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)), (forall (x : M), IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
 Case conversion may be inaccurate. Consider using '#align is_unit.lift_right IsUnit.liftRightₓ'. -/
 /-- If a homomorphism `f : M →* N` sends each element to an `is_unit`, then it can be lifted
 to `f : M →* Nˣ`. See also `units.lift_right` for a computable version. -/
@@ -399,7 +399,7 @@ noncomputable def liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) : M →* N
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (hf : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f hf) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (hf : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} N (Units.val.{u1} N _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f hf) x)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (hf : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} N (Units.val.{u1} N _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f hf) x)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)
 Case conversion may be inaccurate. Consider using '#align is_unit.coe_lift_right IsUnit.coe_liftRightₓ'. -/
 @[to_additive]
 theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
@@ -412,7 +412,7 @@ theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (h : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u1} N _inst_2) x) (Units.instInvUnits.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2)))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) x) (Units.instInvUnits.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align is_unit.mul_lift_right_inv IsUnit.mul_liftRight_invₓ'. -/
 @[simp, to_additive]
 theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
@@ -425,7 +425,7 @@ theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (h : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f h) x))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2))) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u1} N _inst_2) x) (Units.instInvUnits.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2)))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2))) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) x) (Units.instInvUnits.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align is_unit.lift_right_inv_mul IsUnit.liftRight_inv_mulₓ'. -/
 @[simp, to_additive]
 theorem liftRight_inv_mul (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :

bump to nightly-2023-03-08-18

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

10f15343

Diff

@@ -51,7 +51,7 @@ section MonoidHomClass
 lean 3 declaration is
   forall {F : Type.{u1}} {G : Type.{u2}} {N : Type.{u3}} [_inst_1 : DivisionMonoid.{u2} G] [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2)] {x : G}, (IsUnit.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x) -> (forall (f : F) (g : F), (Eq.{succ u3} N (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) f x) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) g x)) -> (Eq.{succ u3} N (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) f (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x)) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => N) (MulHomClass.toFunLike.{u1, u2, u3} F G N (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) g (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x))))
 but is expected to have type
-  forall {F : Type.{u3}} {G : Type.{u2}} {N : Type.{u1}} [_inst_1 : DivisionMonoid.{u2} G] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2)] {x : G}, (IsUnit.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x) -> (forall (f : F) (g : F), (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => N) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => N) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x))))
+  forall {F : Type.{u3}} {G : Type.{u2}} {N : Type.{u1}} [_inst_1 : DivisionMonoid.{u2} G] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2)] {x : G}, (IsUnit.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)) x) -> (forall (f : F) (g : F), (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (DivisionMonoid.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G _inst_1))) x))))
 Case conversion may be inaccurate. Consider using '#align is_unit.eq_on_inv IsUnit.eq_on_invₓ'. -/
 /-- If two homomorphisms from a division monoid to a monoid are equal at a unit `x`, then they are
 equal at `x⁻¹`. -/
@@ -68,7 +68,7 @@ theorem IsUnit.eq_on_inv {F G N} [DivisionMonoid G] [Monoid N] [MonoidHomClass F
 lean 3 declaration is
   forall {F : Type.{u1}} {G : Type.{u2}} {M : Type.{u3}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u3} M] [_inst_3 : MonoidHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2)] (f : F) (g : F) {x : G}, (Eq.{succ u3} M (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) f x) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) g x)) -> (Eq.{succ u3} M (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) f (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) x)) (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => G -> M) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F G (fun (_x : G) => M) (MulHomClass.toFunLike.{u1, u2, u3} F G M (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u3} M _inst_2) _inst_3))) g (Inv.inv.{u2} G (DivInvMonoid.toHasInv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)) x)))
 but is expected to have type
-  forall {F : Type.{u3}} {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)] (f : F) (g : F) {x : G}, (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => M) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => M) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)))
+  forall {F : Type.{u3}} {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] [_inst_3 : MonoidHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)] (f : F) (g : F) {x : G}, (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f x) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g x)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) f (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)) (FunLike.coe.{succ u3, succ u2, succ u1} F G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) _x) (MulHomClass.toFunLike.{u3, u2, u1} F G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) _inst_3)) g (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) x)))
 Case conversion may be inaccurate. Consider using '#align eq_on_inv eq_on_invₓ'. -/
 /-- If two homomorphism from a group to a monoid are equal at `x`, then they are equal at `x⁻¹`. -/
 @[to_additive
@@ -106,7 +106,7 @@ def map (f : M →* N) : Mˣ →* Nˣ :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (x : Units.{u1} M _inst_1), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => (Units.{u1} M _inst_1) -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) x))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (x : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) (Units.val.{u1} M _inst_1 x)) (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 x))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (x : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) (Units.val.{u1} M _inst_1 x)) (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 x))
 Case conversion may be inaccurate. Consider using '#align units.coe_map Units.coe_mapₓ'. -/
 @[simp, to_additive]
 theorem coe_map (f : M →* N) (x : Mˣ) : ↑(map f x) = f x :=
@@ -118,7 +118,7 @@ theorem coe_map (f : M →* N) (x : Mˣ) : ↑(map f x) = f x :=
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => (Units.{u1} M _inst_1) -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.mulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) u)))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInvUnits.{u1} M _inst_1) u))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) u) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInvUnits.{u1} M _inst_1) u)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (u : Units.{u1} M _inst_1), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInvUnits.{u1} M _inst_1) u))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) u) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_1) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.map.{u1, u2} M N _inst_1 _inst_2 f) u))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f (Units.val.{u1} M _inst_1 (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.instInvUnits.{u1} M _inst_1) u)))
 Case conversion may be inaccurate. Consider using '#align units.coe_map_inv Units.coe_map_invₓ'. -/
 @[simp, to_additive]
 theorem coe_map_inv (f : M →* N) (u : Mˣ) : ↑(map f u)⁻¹ = f ↑u⁻¹ :=
@@ -170,7 +170,7 @@ variable {M}
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : Units.{u1} M _inst_1), Eq.{succ u1} M (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) => (Units.{u1} M _inst_1) -> M) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} M _inst_1) M (Units.mulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.coeHom.{u1} M _inst_1) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) x)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : Units.{u1} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Units.{u1} M _inst_1) => M) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Units.{u1} M _inst_1) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)))) (Units.coeHom.{u1} M _inst_1) x) (Units.val.{u1} M _inst_1 x)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : Units.{u1} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_1) => M) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) (fun (_x : Units.{u1} M _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} M _inst_1) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)) (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} M _inst_1) M (Units.instMulOneClassUnits.{u1} M _inst_1) (Monoid.toMulOneClass.{u1} M _inst_1)))) (Units.coeHom.{u1} M _inst_1) x) (Units.val.{u1} M _inst_1 x)
 Case conversion may be inaccurate. Consider using '#align units.coe_hom_apply Units.coeHom_applyₓ'. -/
 @[simp, to_additive]
 theorem coeHom_apply (x : Mˣ) : coeHom M x = ↑x :=
@@ -231,7 +231,7 @@ theorem divp_eq_div (a : α) (u : αˣ) : a /ₚ u = a / u := by rw [div_eq_mul_
 lean 3 declaration is
   forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : DivisionMonoid.{u2} α] {F : Type.{u3}} [_inst_5 : MonoidHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))] (f : F) (u : Units.{u1} M _inst_1), Eq.{succ u2} α (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> α) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => α) (MulHomClass.toFunLike.{u3, u1, u2} F M α (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4))) _inst_5))) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) (Inv.inv.{u1} (Units.{u1} M _inst_1) (Units.hasInv.{u1} M _inst_1) u))) (Inv.inv.{u2} α (DivInvMonoid.toHasInv.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> α) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => α) (MulHomClass.toFunLike.{u3, u1, u2} F M α (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M α (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (DivisionMonoid.toDivInvMonoid.{u2} α _inst_4))) _inst_5))) f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) u)))
 but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u3}} [_inst_1 : Monoid.{u3} M] [_inst_4 : DivisionMonoid.{u1} α] {F : Type.{u2}} [_inst_5 : MonoidHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))] (f : F) (u : Units.{u3} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => α) (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInvUnits.{u3} M _inst_1) u))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInvUnits.{u3} M _inst_1) u))) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => α) (Units.val.{u3} M _inst_1 u)) (InvOneClass.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => α) (Units.val.{u3} M _inst_1 u)) _inst_4))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 u)))
+  forall {α : Type.{u1}} {M : Type.{u3}} [_inst_1 : Monoid.{u3} M] [_inst_4 : DivisionMonoid.{u1} α] {F : Type.{u2}} [_inst_5 : MonoidHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))] (f : F) (u : Units.{u3} M _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInvUnits.{u3} M _inst_1) u))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 (Inv.inv.{u3} (Units.{u3} M _inst_1) (Units.instInvUnits.{u3} M _inst_1) u))) (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) (Units.val.{u3} M _inst_1 u)) (InvOneClass.toInv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) (Units.val.{u3} M _inst_1 u)) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) (Units.val.{u3} M _inst_1 u)) _inst_4))) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => α) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M α (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4)))) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M α (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_4))) _inst_5)) f (Units.val.{u3} M _inst_1 u)))
 Case conversion may be inaccurate. Consider using '#align map_units_inv map_units_invₓ'. -/
 @[simp, to_additive]
 theorem map_units_inv {F : Type _} [MonoidHomClass F M α] (f : F) (u : Units M) :
@@ -246,7 +246,7 @@ end DivisionMonoid
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : M -> (Units.{u2} N _inst_2)), (forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : M -> (Units.{u2} N _inst_2)), (forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (g : M -> (Units.{u2} N _inst_2)), (forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
 Case conversion may be inaccurate. Consider using '#align units.lift_right Units.liftRightₓ'. -/
 /-- If a map `g : M → Nˣ` agrees with a homomorphism `f : M →* N`, then
 this map is a monoid homomorphism too. -/
@@ -264,7 +264,7 @@ def liftRight (f : M →* N) (g : M → Nˣ) (h : ∀ x, ↑(g x) = f x) : M →
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} N (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} N (Units.val.{u2} N _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)
 Case conversion may be inaccurate. Consider using '#align units.coe_lift_right Units.coe_liftRightₓ'. -/
 @[simp, to_additive]
 theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
@@ -277,7 +277,7 @@ theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x)
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => Units.{u2} N _inst_2) x) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u2} N _inst_2) x) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x)))) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align units.mul_lift_right_inv Units.mul_liftRight_invₓ'. -/
 @[simp, to_additive]
 theorem mul_liftRight_inv {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
@@ -289,7 +289,7 @@ theorem mul_liftRight_inv {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) =
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (g x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => Units.{u2} N _inst_2) x) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)} {g : M -> (Units.{u2} N _inst_2)} (h : forall (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Units.val.{u2} N _inst_2 (g x)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (x : M), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (HMul.hMul.{u2, u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (instHMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (MulOneClass.toMul.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toMulOneClass.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2))) (Units.val.{u2} N _inst_2 (Inv.inv.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u2} N _inst_2) x) (Units.instInvUnits.{u2} N _inst_2) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u2} N _inst_2) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)) M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2)))) (Units.liftRight.{u1, u2} M N _inst_1 _inst_2 f g h) x))) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) (OfNat.ofNat.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) 1 (One.toOfNat1.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toOne.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align units.lift_right_inv_mul Units.liftRight_inv_mulₓ'. -/
 @[simp, to_additive]
 theorem liftRight_inv_mul {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
@@ -323,7 +323,7 @@ def toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) : G →* Mˣ :
 lean 3 declaration is
   forall {G : Type.{u1}} {M : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Monoid.{u2} M] (f : MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) (g : G), Eq.{succ u2} M ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} M _inst_2) M (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} M _inst_2) M (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} M _inst_2) M (coeBase.{succ u2, succ u2} (Units.{u2} M _inst_2) M (Units.hasCoe.{u2} M _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2)) (fun (_x : MonoidHom.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2)) => G -> (Units.{u2} M _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} G (Units.{u2} M _inst_2) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u2} M _inst_2)) (MonoidHom.toHomUnits.{u1, u2} G M _inst_1 _inst_2 f) g)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) (fun (_x : MonoidHom.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) => G -> M) (MonoidHom.hasCoeToFun.{u1, u2} G M (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} M _inst_2)) f g)
 but is expected to have type
-  forall {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] (f : MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) (g : G), Eq.{succ u1} M (Units.val.{u1} M _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => Units.{u1} M _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)))) (MonoidHom.toHomUnits.{u2, u1} G M _inst_1 _inst_2 f) g)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => M) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)))) f g)
+  forall {G : Type.{u2}} {M : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Monoid.{u1} M] (f : MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) (g : G), Eq.{succ u1} M (Units.val.{u1} M _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => Units.{u1} M _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_2) (Units.instMulOneClassUnits.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)) G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G (Units.{u1} M _inst_2) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Units.instMulOneClassUnits.{u1} M _inst_2)))) (MonoidHom.toHomUnits.{u2, u1} G M _inst_1 _inst_2 f) g)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => M) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)) G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2) (MonoidHom.monoidHomClass.{u2, u1} G M (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} M _inst_2)))) f g)
 Case conversion may be inaccurate. Consider using '#align monoid_hom.coe_to_hom_units MonoidHom.coe_toHomUnitsₓ'. -/
 @[simp, to_additive]
 theorem coe_toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) (g : G) :
@@ -346,7 +346,7 @@ variable [Monoid M] [Monoid N]
 lean 3 declaration is
   forall {F : Type.{u1}} {M : Type.{u2}} {N : Type.{u3}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u1, u2, u3} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (f : F) {x : M}, (IsUnit.{u2} M _inst_1 x) -> (IsUnit.{u3} N _inst_2 (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u2, u3} F M N (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3))) f x))
 but is expected to have type
-  forall {F : Type.{u3}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) {x : M}, (IsUnit.{u2} M _inst_1 x) -> (IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2 (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x))
+  forall {F : Type.{u3}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) {x : M}, (IsUnit.{u2} M _inst_1 x) -> (IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f x))
 Case conversion may be inaccurate. Consider using '#align is_unit.map IsUnit.mapₓ'. -/
 @[to_additive]
 theorem map [MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x) : IsUnit (f x) := by
@@ -358,7 +358,7 @@ theorem map [MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x) : IsUnit (f x)
 lean 3 declaration is
   forall {F : Type.{u1}} {G : Type.{u2}} {M : Type.{u3}} {N : Type.{u4}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u4} N] [_inst_3 : MonoidHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2)] [_inst_4 : MonoidHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u4} M N (coeFn.{succ u2, max (succ u4) (succ u3)} G (fun (_x : G) => N -> M) (FunLike.hasCoeToFun.{succ u2, succ u4, succ u3} G N (fun (_x : N) => M) (MulHomClass.toFunLike.{u2, u4, u3} G N M (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4))) g) (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f)) -> (IsUnit.{u4} N _inst_2 (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f x)) -> (IsUnit.{u3} M _inst_1 x)
 but is expected to have type
-  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) -> (IsUnit.{u3} M _inst_1 x)
+  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) -> (IsUnit.{u3} M _inst_1 x)
 Case conversion may be inaccurate. Consider using '#align is_unit.of_left_inverse IsUnit.of_leftInverseₓ'. -/
 @[to_additive]
 theorem of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x : M} (g : G)
@@ -371,7 +371,7 @@ theorem of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x
 lean 3 declaration is
   forall {F : Type.{u1}} {G : Type.{u2}} {M : Type.{u3}} {N : Type.{u4}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u4} N] [_inst_3 : MonoidHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2)] [_inst_4 : MonoidHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u4} M N (coeFn.{succ u2, max (succ u4) (succ u3)} G (fun (_x : G) => N -> M) (FunLike.hasCoeToFun.{succ u2, succ u4, succ u3} G N (fun (_x : N) => M) (MulHomClass.toFunLike.{u2, u4, u3} G N M (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u2, u4, u3} G N M (Monoid.toMulOneClass.{u4} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4))) g) (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f)) -> (Iff (IsUnit.{u4} N _inst_2 (coeFn.{succ u1, max (succ u3) (succ u4)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u1, succ u3, succ u4} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u1, u3, u4} F M N (MulOneClass.toHasMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toHasMul.{u4} N (Monoid.toMulOneClass.{u4} N _inst_2)) (MonoidHomClass.toMulHomClass.{u1, u3, u4} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u4} N _inst_2) _inst_3))) f x)) (IsUnit.{u3} M _inst_1 x))
 but is expected to have type
-  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (Iff (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) (IsUnit.{u3} M _inst_1 x))
+  forall {F : Type.{u4}} {G : Type.{u1}} {M : Type.{u3}} {N : Type.{u2}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] [_inst_4 : MonoidHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1)] {f : F} {x : M} (g : G), (Function.LeftInverse.{succ u3, succ u2} M N (FunLike.coe.{succ u1, succ u2, succ u3} G N (fun (_x : N) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : N) => M) _x) (MulHomClass.toFunLike.{u1, u2, u3} G N M (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u2, u3} G N M (Monoid.toMulOneClass.{u2} N _inst_2) (Monoid.toMulOneClass.{u3} M _inst_1) _inst_4)) g) (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f)) -> (Iff (IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{succ u4, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u4, u3, u2} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u3, u2} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3)) f x)) (IsUnit.{u3} M _inst_1 x))
 Case conversion may be inaccurate. Consider using '#align is_unit_map_of_left_inverse isUnit_map_of_leftInverseₓ'. -/
 @[to_additive]
 theorem isUnit_map_of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x : M}
@@ -384,7 +384,7 @@ theorem isUnit_map_of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M]
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)), (forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)), (forall (x : M), IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)), (forall (x : M), IsUnit.{u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) (MonoidHom.monoidHomClass.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)))) f x)) -> (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.instMulOneClassUnits.{u2} N _inst_2))
 Case conversion may be inaccurate. Consider using '#align is_unit.lift_right IsUnit.liftRightₓ'. -/
 /-- If a homomorphism `f : M →* N` sends each element to an `is_unit`, then it can be lifted
 to `f : M →* Nˣ`. See also `units.lift_right` for a computable version. -/
@@ -399,7 +399,7 @@ noncomputable def liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) : M →* N
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (hf : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f hf) x)) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (hf : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} N (Units.val.{u1} N _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f hf) x)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (hf : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} N (Units.val.{u1} N _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f hf) x)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)
 Case conversion may be inaccurate. Consider using '#align is_unit.coe_lift_right IsUnit.coe_liftRightₓ'. -/
 @[to_additive]
 theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
@@ -412,7 +412,7 @@ theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (h : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => Units.{u1} N _inst_2) x) (Units.instInvUnits.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2)))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u1} N _inst_2) x) (Units.instInvUnits.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x)))) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align is_unit.mul_lift_right_inv IsUnit.mul_liftRight_invₓ'. -/
 @[simp, to_additive]
 theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
@@ -425,7 +425,7 @@ theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (h : forall (x : M), IsUnit.{u2} N _inst_2 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (x : M), Eq.{succ u2} N (HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (Inv.inv.{u2} (Units.{u2} N _inst_2) (Units.hasInv.{u2} N _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) => M -> (Units.{u2} N _inst_2)) (MonoidHom.hasCoeToFun.{u1, u2} M (Units.{u2} N _inst_2) (Monoid.toMulOneClass.{u1} M _inst_1) (Units.mulOneClass.{u2} N _inst_2)) (IsUnit.liftRight.{u1, u2} M N _inst_1 _inst_2 f h) x))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f x)) (OfNat.ofNat.{u2} N 1 (OfNat.mk.{u2} N 1 (One.one.{u2} N (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)))))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2))) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => Units.{u1} N _inst_2) x) (Units.instInvUnits.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) _inst_2)))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (h : forall (x : M), IsUnit.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (x : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (MulOneClass.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2))) (Units.val.{u1} N _inst_2 (Inv.inv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u1} N _inst_2) x) (Units.instInvUnits.{u1} N _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => Units.{u1} N _inst_2) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)) M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M (Units.{u1} N _inst_2) (Monoid.toMulOneClass.{u2} M _inst_1) (Units.instMulOneClassUnits.{u1} N _inst_2)))) (IsUnit.liftRight.{u2, u1} M N _inst_1 _inst_2 f h) x))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f x)) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Monoid.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align is_unit.lift_right_inv_mul IsUnit.liftRight_inv_mulₓ'. -/
 @[simp, to_additive]
 theorem liftRight_inv_mul (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :

bump to nightly-2023-02-28-18

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

15328211

Diff

@@ -884,6 +884,12 @@ protected theorem div_div_cancel (h : IsUnit a) : a / (a / b) = b := by
 #align is_unit.div_div_cancel IsUnit.div_div_cancel
 #align is_add_unit.sub_sub_cancel IsAddUnit.sub_sub_cancel
 
+/- warning: is_unit.div_div_cancel_left -> IsUnit.div_div_cancel_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) a) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a b) a) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DivisionCommMonoid.{u1} α] {a : α} {b : α}, (IsUnit.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1))) a) -> (Eq.{succ u1} α (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) a b) a) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α _inst_1)))) b))
+Case conversion may be inaccurate. Consider using '#align is_unit.div_div_cancel_left IsUnit.div_div_cancel_leftₓ'. -/
 @[to_additive]
 protected theorem div_div_cancel_left (h : IsUnit a) : a / b / a = b⁻¹ := by
   rw [div_eq_mul_inv, div_eq_mul_inv, mul_right_comm, h.mul_inv_cancel, one_mul]

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

refactor(Data/FunLike): use unbundled inheritance from FunLike (#8386)

The FunLike hierarchy is very big and gets scanned through each time we need a coercion (via the CoeFun instance). It looks like unbundled inheritance suits Lean 4 better here. The only class that still extends FunLike is EquivLike, since that has a custom coe_injective' field that is easier to implement. All other classes should take FunLike or EquivLike as a parameter.

Zulip thread

Important changes

Previously, morphism classes would be Type-valued and extend FunLike:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  extends FunLike F A B :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

After this PR, they should be Prop-valued and take FunLike as a parameter:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  [FunLike F A B] : Prop :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

(Note that A B stay marked as outParam even though they are not purely required to be so due to the FunLike parameter already filling them in. This is required to see through type synonyms, which is important in the category theory library. Also, I think keeping them as outParam is slightly faster.)

Similarly, MyEquivClass should take EquivLike as a parameter.

As a result, every mention of [MyHomClass F A B] should become [FunLike F A B] [MyHomClass F A B].

Remaining issues

Slower (failing) search

While overall this gives some great speedups, there are some cases that are noticeably slower. In particular, a failing application of a lemma such as map_mul is more expensive. This is due to suboptimal processing of arguments. For example:

variable [FunLike F M N] [Mul M] [Mul N] (f : F) (x : M) (y : M)

theorem map_mul [MulHomClass F M N] : f (x * y) = f x * f y

example [AddHomClass F A B] : f (x * y) = f x * f y := map_mul f _ _

Before this PR, applying map_mul f gives the goals [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Since M and N are out_params, [MulHomClass F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found.

After this PR, the goals become [FunLike F ?M ?N] [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Now [FunLike F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found, before trying MulHomClass F M N which fails. Since the Mul hierarchy is very big, this can be slow to fail, especially when there is no such Mul instance.

A long-term but harder to achieve solution would be to specify the order in which instance goals get solved. For example, we'd like to change the arguments to map_mul to look like [FunLike F M N] [Mul M] [Mul N] [highPriority <| MulHomClass F M N] because MulHomClass fails or succeeds much faster than the others.

As a consequence, the simpNF linter is much slower since by design it tries and fails to apply many map_ lemmas. The same issue occurs a few times in existing calls to simp [map_mul], where map_mul is tried "too soon" and fails. Thanks to the speedup of leanprover/lean4#2478 the impact is very limited, only in files that already were close to the timeout.

`simp` not firing sometimes

This affects map_smulₛₗ and related definitions. For simp lemmas Lean apparently uses a slightly different mechanism to find instances, so that rw can find every argument to map_smulₛₗ successfully but simp can't: leanprover/lean4#3701.

Missing instances due to unification failing

Especially in the category theory library, we might sometimes have a type A which is also accessible as a synonym (Bundled A hA).1. Instance synthesis doesn't always work if we have f : A →* B but x * y : (Bundled A hA).1 or vice versa. This seems to be mostly fixed by keeping A B as outParams in MulHomClass F A B. (Presumably because Lean will do a definitional check A =?= (Bundled A hA).1 instead of using the syntax in the discrimination tree.)

Workaround for issues

The timeouts can be worked around for now by specifying which map_mul we mean, either as map_mul f for some explicit f, or as e.g. MonoidHomClass.map_mul.

map_smulₛₗ not firing as simp lemma can be worked around by going back to the pre-FunLike situation and making LinearMap.map_smulₛₗ a simp lemma instead of the generic map_smulₛₗ. Writing simp [map_smulₛₗ _] also works.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott@tqft.net> Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

c6a73d4f

Diff

@@ -33,8 +33,8 @@ equal at `x⁻¹`. -/
 @[to_additive
   "If two homomorphisms from a subtraction monoid to an additive monoid are equal at an
   additive unit `x`, then they are equal at `-x`."]
-theorem IsUnit.eq_on_inv {F G N} [DivisionMonoid G] [Monoid N] [MonoidHomClass F G N]
-    {x : G} (hx : IsUnit x) (f g : F) (h : f x = g x) : f x⁻¹ = g x⁻¹ :=
+theorem IsUnit.eq_on_inv {F G N} [DivisionMonoid G] [Monoid N] [FunLike F G N]
+    [MonoidHomClass F G N] {x : G} (hx : IsUnit x) (f g : F) (h : f x = g x) : f x⁻¹ = g x⁻¹ :=
   left_inv_eq_right_inv (map_mul_eq_one f hx.inv_mul_cancel)
     (h.symm ▸ map_mul_eq_one g (hx.mul_inv_cancel))
 #align is_unit.eq_on_inv IsUnit.eq_on_inv
@@ -44,7 +44,7 @@ theorem IsUnit.eq_on_inv {F G N} [DivisionMonoid G] [Monoid N] [MonoidHomClass F
 @[to_additive
     "If two homomorphism from an additive group to an additive monoid are equal at `x`,
     then they are equal at `-x`."]
-theorem eq_on_inv {F G M} [Group G] [Monoid M] [MonoidHomClass F G M]
+theorem eq_on_inv {F G M} [Group G] [Monoid M] [FunLike F G M] [MonoidHomClass F G M]
     (f g : F) {x : G} (h : f x = g x) : f x⁻¹ = g x⁻¹ :=
   (Group.isUnit x).eq_on_inv f g h
 #align eq_on_inv eq_on_inv
@@ -118,7 +118,8 @@ theorem val_zpow_eq_zpow_val : ∀ (u : αˣ) (n : ℤ), ((u ^ n : αˣ) : α) =
 #align add_units.coe_zsmul AddUnits.val_zsmul_eq_zsmul_val
 
 @[to_additive (attr := simp)]
-theorem _root_.map_units_inv {F : Type*} [MonoidHomClass F M α] (f : F) (u : Units M) :
+theorem _root_.map_units_inv {F : Type*} [FunLike F M α] [MonoidHomClass F M α]
+    (f : F) (u : Units M) :
     f ↑u⁻¹ = (f u)⁻¹ := ((f : M →* α).comp (Units.coeHom M)).map_inv u
 #align map_units_inv map_units_inv
 #align map_add_units_neg map_addUnits_neg
@@ -185,7 +186,7 @@ end MonoidHom
 
 namespace IsUnit
 
-variable {F G α M N : Type*}
+variable {F G α M N : Type*} [FunLike F M N] [FunLike G N M]
 
 section Monoid
 
@@ -198,7 +199,7 @@ theorem map [MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x) : IsUnit (f x)
 #align is_add_unit.map IsAddUnit.map
 
 @[to_additive]
-theorem of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x : M} (g : G)
+theorem of_leftInverse [MonoidHomClass G N M] {f : F} {x : M} (g : G)
     (hfg : Function.LeftInverse g f) (h : IsUnit (f x)) : IsUnit x := by
   simpa only [hfg x] using h.map g
 #align is_unit.of_left_inverse IsUnit.of_leftInverse

feat: a / b = c / d ↔ a * d = c * b when b, d commute (#9389)

This involves moving a bunch of lemmas from Algebra.Group.Units.Hom to Algebra.Group.Units (without modification).

From LeanAPAP

7ab8c781

Diff

@@ -19,11 +19,6 @@ also contains unrelated results about `Units` that depend on `MonoidHom`.
 * `Units.map`: Turn a homomorphism from `α` to `β` monoids into a homomorphism from `αˣ` to `βˣ`.
 * `MonoidHom.toHomUnits`: Turn a homomorphism from a group `α` to `β` into a homomorphism from
   `α` to `βˣ`.
-
-## TODO
-
-The results that don't mention homomorphisms should be proved (earlier?) in a different file and be
-used to golf the basic `Group` lemmas.
 -/
 
 
@@ -31,12 +26,6 @@ open Function
 
 universe u v w
 
-@[to_additive]
-theorem Group.isUnit {G} [Group G] (g : G) : IsUnit g :=
-  ⟨⟨g, g⁻¹, mul_inv_self g, inv_mul_self g⟩, rfl⟩
-#align group.is_unit Group.isUnit
-#align add_group.is_add_unit AddGroup.isAddUnit
-
 section MonoidHomClass
 
 /-- If two homomorphisms from a division monoid to a monoid are equal at a unit `x`, then they are
@@ -128,11 +117,6 @@ theorem val_zpow_eq_zpow_val : ∀ (u : αˣ) (n : ℤ), ((u ^ n : αˣ) : α) =
 #align units.coe_zpow Units.val_zpow_eq_zpow_val
 #align add_units.coe_zsmul AddUnits.val_zsmul_eq_zsmul_val
 
-@[field_simps]
-theorem _root_.divp_eq_div (a : α) (u : αˣ) : a /ₚ u = a / u :=
-  by rw [div_eq_mul_inv, divp, u.val_inv_eq_inv_val]
-#align divp_eq_div divp_eq_div
-
 @[to_additive (attr := simp)]
 theorem _root_.map_units_inv {F : Type*} [MonoidHomClass F M α] (f : F) (u : Units M) :
     f ↑u⁻¹ = (f u)⁻¹ := ((f : M →* α).comp (Units.coeHom M)).map_inv u
@@ -256,257 +240,4 @@ theorem liftRight_inv_mul (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
 #align is_add_unit.lift_right_neg_add IsAddUnit.liftRight_neg_add
 
 end Monoid
-
-section DivisionMonoid
-
-variable [DivisionMonoid α] {a b c : α}
-
-/-- The element of the group of units, corresponding to an element of a monoid which is a unit. As
-opposed to `IsUnit.unit`, the inverse is computable and comes from the inversion on `α`. This is
-useful to transfer properties of inversion in `Units α` to `α`. See also `toUnits`. -/
-@[to_additive (attr := simps val)
-  "The element of the additive group of additive units, corresponding to an element of
-  an additive monoid which is an additive unit. As opposed to `IsAddUnit.addUnit`, the negation is
-  computable and comes from the negation on `α`. This is useful to transfer properties of negation
-  in `AddUnits α` to `α`. See also `toAddUnits`."]
-def unit' (h : IsUnit a) : αˣ :=
-  ⟨a, a⁻¹, h.mul_inv_cancel, h.inv_mul_cancel⟩
-#align is_unit.unit' IsUnit.unit'
-#align is_add_unit.add_unit' IsAddUnit.addUnit'
-#align is_unit.coe_unit' IsUnit.val_unit'
-#align is_add_unit.coe_add_unit' IsAddUnit.val_addUnit'
-
--- Porting note: TODO: `simps val_inv` fails
-@[to_additive] theorem val_inv_unit' (h : IsUnit a) : ↑(h.unit'⁻¹) = a⁻¹ := rfl
-#align is_unit.coe_inv_unit' IsUnit.val_inv_unit'
-#align is_add_unit.coe_neg_add_unit' IsAddUnit.val_neg_addUnit'
-
-@[to_additive (attr := simp)]
-protected theorem mul_inv_cancel_left (h : IsUnit a) : ∀ b, a * (a⁻¹ * b) = b :=
-  h.unit'.mul_inv_cancel_left
-#align is_unit.mul_inv_cancel_left IsUnit.mul_inv_cancel_left
-#align is_add_unit.add_neg_cancel_left IsAddUnit.add_neg_cancel_left
-
-@[to_additive (attr := simp)]
-protected theorem inv_mul_cancel_left (h : IsUnit a) : ∀ b, a⁻¹ * (a * b) = b :=
-  h.unit'.inv_mul_cancel_left
-#align is_unit.inv_mul_cancel_left IsUnit.inv_mul_cancel_left
-#align is_add_unit.neg_add_cancel_left IsAddUnit.neg_add_cancel_left
-
-@[to_additive (attr := simp)]
-protected theorem mul_inv_cancel_right (h : IsUnit b) (a : α) : a * b * b⁻¹ = a :=
-  h.unit'.mul_inv_cancel_right _
-#align is_unit.mul_inv_cancel_right IsUnit.mul_inv_cancel_right
-#align is_add_unit.add_neg_cancel_right IsAddUnit.add_neg_cancel_right
-
-@[to_additive (attr := simp)]
-protected theorem inv_mul_cancel_right (h : IsUnit b) (a : α) : a * b⁻¹ * b = a :=
-  h.unit'.inv_mul_cancel_right _
-#align is_unit.inv_mul_cancel_right IsUnit.inv_mul_cancel_right
-#align is_add_unit.neg_add_cancel_right IsAddUnit.neg_add_cancel_right
-
-@[to_additive]
-protected theorem div_self (h : IsUnit a) : a / a = 1 := by rw [div_eq_mul_inv, h.mul_inv_cancel]
-#align is_unit.div_self IsUnit.div_self
-#align is_add_unit.sub_self IsAddUnit.sub_self
-
-@[to_additive]
-protected theorem eq_mul_inv_iff_mul_eq (h : IsUnit c) : a = b * c⁻¹ ↔ a * c = b :=
-  h.unit'.eq_mul_inv_iff_mul_eq
-#align is_unit.eq_mul_inv_iff_mul_eq IsUnit.eq_mul_inv_iff_mul_eq
-#align is_add_unit.eq_add_neg_iff_add_eq IsAddUnit.eq_add_neg_iff_add_eq
-
-@[to_additive]
-protected theorem eq_inv_mul_iff_mul_eq (h : IsUnit b) : a = b⁻¹ * c ↔ b * a = c :=
-  h.unit'.eq_inv_mul_iff_mul_eq
-#align is_unit.eq_inv_mul_iff_mul_eq IsUnit.eq_inv_mul_iff_mul_eq
-#align is_add_unit.eq_neg_add_iff_add_eq IsAddUnit.eq_neg_add_iff_add_eq
-
-@[to_additive]
-protected theorem inv_mul_eq_iff_eq_mul (h : IsUnit a) : a⁻¹ * b = c ↔ b = a * c :=
-  h.unit'.inv_mul_eq_iff_eq_mul
-#align is_unit.inv_mul_eq_iff_eq_mul IsUnit.inv_mul_eq_iff_eq_mul
-#align is_add_unit.neg_add_eq_iff_eq_add IsAddUnit.neg_add_eq_iff_eq_add
-
-@[to_additive]
-protected theorem mul_inv_eq_iff_eq_mul (h : IsUnit b) : a * b⁻¹ = c ↔ a = c * b :=
-  h.unit'.mul_inv_eq_iff_eq_mul
-#align is_unit.mul_inv_eq_iff_eq_mul IsUnit.mul_inv_eq_iff_eq_mul
-#align is_add_unit.add_neg_eq_iff_eq_add IsAddUnit.add_neg_eq_iff_eq_add
-
-@[to_additive]
-protected theorem mul_inv_eq_one (h : IsUnit b) : a * b⁻¹ = 1 ↔ a = b :=
-  @Units.mul_inv_eq_one _ _ h.unit' _
-#align is_unit.mul_inv_eq_one IsUnit.mul_inv_eq_one
-#align is_add_unit.add_neg_eq_zero IsAddUnit.add_neg_eq_zero
-
-@[to_additive]
-protected theorem inv_mul_eq_one (h : IsUnit a) : a⁻¹ * b = 1 ↔ a = b :=
-  @Units.inv_mul_eq_one _ _ h.unit' _
-#align is_unit.inv_mul_eq_one IsUnit.inv_mul_eq_one
-#align is_add_unit.neg_add_eq_zero IsAddUnit.neg_add_eq_zero
-
-@[to_additive]
-protected theorem mul_eq_one_iff_eq_inv (h : IsUnit b) : a * b = 1 ↔ a = b⁻¹ :=
-  @Units.mul_eq_one_iff_eq_inv _ _ h.unit' _
-#align is_unit.mul_eq_one_iff_eq_inv IsUnit.mul_eq_one_iff_eq_inv
-#align is_add_unit.add_eq_zero_iff_eq_neg IsAddUnit.add_eq_zero_iff_eq_neg
-
-@[to_additive]
-protected theorem mul_eq_one_iff_inv_eq (h : IsUnit a) : a * b = 1 ↔ a⁻¹ = b :=
-  @Units.mul_eq_one_iff_inv_eq _ _ h.unit' _
-#align is_unit.mul_eq_one_iff_inv_eq IsUnit.mul_eq_one_iff_inv_eq
-#align is_add_unit.add_eq_zero_iff_neg_eq IsAddUnit.add_eq_zero_iff_neg_eq
-
-@[to_additive (attr := simp)]
-protected theorem div_mul_cancel (h : IsUnit b) (a : α) : a / b * b = a := by
-  rw [div_eq_mul_inv, h.inv_mul_cancel_right]
-#align is_unit.div_mul_cancel IsUnit.div_mul_cancel
-#align is_add_unit.sub_add_cancel IsAddUnit.sub_add_cancel
-
-@[to_additive (attr := simp)]
-protected theorem mul_div_cancel (h : IsUnit b) (a : α) : a * b / b = a := by
-  rw [div_eq_mul_inv, h.mul_inv_cancel_right]
-#align is_unit.mul_div_cancel IsUnit.mul_div_cancel
-#align is_add_unit.add_sub_cancel IsAddUnit.add_sub_cancel
-
-@[to_additive]
-protected theorem mul_one_div_cancel (h : IsUnit a) : a * (1 / a) = 1 := by simp [h]
-#align is_unit.mul_one_div_cancel IsUnit.mul_one_div_cancel
-#align is_add_unit.add_zero_sub_cancel IsAddUnit.add_zero_sub_cancel
-
-@[to_additive]
-protected theorem one_div_mul_cancel (h : IsUnit a) : 1 / a * a = 1 := by simp [h]
-#align is_unit.one_div_mul_cancel IsUnit.one_div_mul_cancel
-#align is_add_unit.zero_sub_add_cancel IsAddUnit.zero_sub_add_cancel
-
-@[to_additive]
-theorem inv (h : IsUnit a) : IsUnit a⁻¹ := by
-  rcases h with ⟨u, hu⟩
-  rw [← hu, ← Units.val_inv_eq_inv_val]
-  exact Units.isUnit _
-#align is_unit.inv IsUnit.inv
-#align is_add_unit.neg IsAddUnit.neg
-
-@[to_additive]
-theorem div (ha : IsUnit a) (hb : IsUnit b) : IsUnit (a / b) := by
-  rw [div_eq_mul_inv]
-  exact ha.mul hb.inv
-#align is_unit.div IsUnit.div
-#align is_add_unit.sub IsAddUnit.sub
-
-@[to_additive]
-protected theorem div_left_inj (h : IsUnit c) : a / c = b / c ↔ a = b := by
-  simp only [div_eq_mul_inv]
-  exact Units.mul_left_inj h.inv.unit'
-#align is_unit.div_left_inj IsUnit.div_left_inj
-#align is_add_unit.sub_left_inj IsAddUnit.sub_left_inj
-
-@[to_additive]
-protected theorem div_eq_iff (h : IsUnit b) : a / b = c ↔ a = c * b := by
-  rw [div_eq_mul_inv, h.mul_inv_eq_iff_eq_mul]
-#align is_unit.div_eq_iff IsUnit.div_eq_iff
-#align is_add_unit.sub_eq_iff IsAddUnit.sub_eq_iff
-
-@[to_additive]
-protected theorem eq_div_iff (h : IsUnit c) : a = b / c ↔ a * c = b := by
-  rw [div_eq_mul_inv, h.eq_mul_inv_iff_mul_eq]
-#align is_unit.eq_div_iff IsUnit.eq_div_iff
-#align is_add_unit.eq_sub_iff IsAddUnit.eq_sub_iff
-
-@[to_additive]
-protected theorem div_eq_of_eq_mul (h : IsUnit b) : a = c * b → a / b = c :=
-  h.div_eq_iff.2
-#align is_unit.div_eq_of_eq_mul IsUnit.div_eq_of_eq_mul
-#align is_add_unit.sub_eq_of_eq_add IsAddUnit.sub_eq_of_eq_add
-
-@[to_additive]
-protected theorem eq_div_of_mul_eq (h : IsUnit c) : a * c = b → a = b / c :=
-  h.eq_div_iff.2
-#align is_unit.eq_div_of_mul_eq IsUnit.eq_div_of_mul_eq
-#align is_add_unit.eq_sub_of_add_eq IsAddUnit.eq_sub_of_add_eq
-
-@[to_additive]
-protected theorem div_eq_one_iff_eq (h : IsUnit b) : a / b = 1 ↔ a = b :=
-  ⟨eq_of_div_eq_one, fun hab => hab.symm ▸ h.div_self⟩
-#align is_unit.div_eq_one_iff_eq IsUnit.div_eq_one_iff_eq
-#align is_add_unit.sub_eq_zero_iff_eq IsAddUnit.sub_eq_zero_iff_eq
-
-/-- The `Group` version of this lemma is `div_mul_cancel'''` -/
-@[to_additive "The `AddGroup` version of this lemma is `sub_add_cancel''`"]
-protected theorem div_mul_left (h : IsUnit b) : b / (a * b) = 1 / a := by
-  rw [div_eq_mul_inv, mul_inv_rev, h.mul_inv_cancel_left, one_div]
-#align is_unit.div_mul_left IsUnit.div_mul_left
-#align is_add_unit.sub_add_left IsAddUnit.sub_add_left
-
-@[to_additive]
-protected theorem mul_div_mul_right (h : IsUnit c) (a b : α) : a * c / (b * c) = a / b := by
-  simp only [div_eq_mul_inv, mul_inv_rev, mul_assoc, h.mul_inv_cancel_left]
-#align is_unit.mul_div_mul_right IsUnit.mul_div_mul_right
-#align is_add_unit.add_sub_add_right IsAddUnit.add_sub_add_right
-
-@[to_additive]
-protected theorem mul_mul_div (a : α) (h : IsUnit b) : a * b * (1 / b) = a := by simp [h]
-#align is_unit.mul_mul_div IsUnit.mul_mul_div
-#align is_add_unit.add_add_sub IsAddUnit.add_add_sub
-
-end DivisionMonoid
-
-section DivisionCommMonoid
-
-variable [DivisionCommMonoid α] {a b c d : α}
-
-@[to_additive]
-protected theorem div_mul_right (h : IsUnit a) (b : α) : a / (a * b) = 1 / b := by
-  rw [mul_comm, h.div_mul_left]
-#align is_unit.div_mul_right IsUnit.div_mul_right
-#align is_add_unit.sub_add_right IsAddUnit.sub_add_right
-
-@[to_additive]
-protected theorem mul_div_cancel_left (h : IsUnit a) (b : α) : a * b / a = b := by
-  rw [mul_comm, h.mul_div_cancel]
-#align is_unit.mul_div_cancel_left IsUnit.mul_div_cancel_left
-#align is_add_unit.add_sub_cancel_left IsAddUnit.add_sub_cancel_left
-
-@[to_additive]
-protected theorem mul_div_cancel' (h : IsUnit a) (b : α) : a * (b / a) = b := by
-  rw [mul_comm, h.div_mul_cancel]
-#align is_unit.mul_div_cancel' IsUnit.mul_div_cancel'
-#align is_add_unit.add_sub_cancel' IsAddUnit.add_sub_cancel'
-
-@[to_additive]
-protected theorem mul_div_mul_left (h : IsUnit c) (a b : α) : c * a / (c * b) = a / b := by
-  rw [mul_comm c, mul_comm c, h.mul_div_mul_right]
-#align is_unit.mul_div_mul_left IsUnit.mul_div_mul_left
-#align is_add_unit.add_sub_add_left IsAddUnit.add_sub_add_left
-
-@[to_additive]
-protected theorem mul_eq_mul_of_div_eq_div (hb : IsUnit b) (hd : IsUnit d)
-    (a c : α) (h : a / b = c / d) : a * d = c * b := by
-  rw [← mul_one a, ← hb.div_self, ← mul_comm_div, h, div_mul_eq_mul_div, hd.div_mul_cancel]
-#align is_unit.mul_eq_mul_of_div_eq_div IsUnit.mul_eq_mul_of_div_eq_div
-#align is_add_unit.add_eq_add_of_sub_eq_sub IsAddUnit.add_eq_add_of_sub_eq_sub
-
-@[to_additive]
-protected theorem div_eq_div_iff (hb : IsUnit b) (hd : IsUnit d) :
-    a / b = c / d ↔ a * d = c * b := by
-  rw [← (hb.mul hd).mul_left_inj, ← mul_assoc, hb.div_mul_cancel, ← mul_assoc, mul_right_comm,
-    hd.div_mul_cancel]
-#align is_unit.div_eq_div_iff IsUnit.div_eq_div_iff
-#align is_add_unit.sub_eq_sub_iff IsAddUnit.sub_eq_sub_iff
-
-@[to_additive]
-protected theorem div_div_cancel (h : IsUnit a) : a / (a / b) = b := by
-  rw [div_div_eq_mul_div, h.mul_div_cancel_left]
-#align is_unit.div_div_cancel IsUnit.div_div_cancel
-#align is_add_unit.sub_sub_cancel IsAddUnit.sub_sub_cancel
-
-@[to_additive]
-protected theorem div_div_cancel_left (h : IsUnit a) : a / b / a = b⁻¹ := by
-  rw [div_eq_mul_inv, div_eq_mul_inv, mul_right_comm, h.mul_inv_cancel, one_mul]
-#align is_unit.div_div_cancel_left IsUnit.div_div_cancel_left
-#align is_add_unit.sub_sub_cancel_left IsAddUnit.sub_sub_cancel_left
-
-end DivisionCommMonoid
-
 end IsUnit

Chore: Move Units lemmas earlier (#9461)

Part of #9411

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

7522333a

Diff

@@ -118,22 +118,10 @@ theorem coeHom_apply (x : Mˣ) : coeHom M x = ↑x := rfl
 #align units.coe_hom_apply Units.coeHom_apply
 #align add_units.coe_hom_apply AddUnits.coeHom_apply
 
-@[to_additive (attr := simp, norm_cast)]
-theorem val_pow_eq_pow_val (u : Mˣ) (n : ℕ) : ((u ^ n : Mˣ) : M) = (u : M) ^ n :=
-  (Units.coeHom M).map_pow u n
-#align units.coe_pow Units.val_pow_eq_pow_val
-#align add_units.coe_nsmul AddUnits.val_nsmul_eq_nsmul_val
-
 section DivisionMonoid
 
 variable [DivisionMonoid α]
 
-@[to_additive (attr := simp, norm_cast)]
-theorem val_div_eq_div_val : ∀ u₁ u₂ : αˣ, ↑(u₁ / u₂) = (u₁ / u₂ : α) :=
-  (Units.coeHom α).map_div
-#align units.coe_div Units.val_div_eq_div_val
-#align add_units.coe_sub AddUnits.val_neg_eq_neg_val
-
 @[to_additive (attr := simp, norm_cast)]
 theorem val_zpow_eq_zpow_val : ∀ (u : αˣ) (n : ℤ), ((u ^ n : αˣ) : α) = (u : α) ^ n :=
   (Units.coeHom α).map_zpow

feat: Kummer extensions are cyclic. (#9119)

Co-authored-by: Andrew Yang <36414270+erdOne@users.noreply.github.com>

ba4be74a

Diff

@@ -93,6 +93,10 @@ theorem map_comp (f : M →* N) (g : N →* P) : map (g.comp f) = (map g).comp (
 #align units.map_comp Units.map_comp
 #align add_units.map_comp AddUnits.map_comp
 
+@[to_additive]
+lemma map_injective {f : M →* N} (hf : Function.Injective f) :
+    Function.Injective (map f) := fun _ _ e => ext (hf (congr_arg val e))
+
 variable (M)
 
 @[to_additive (attr := simp)]

chore: remove now-unneeded dsimp and its associated porting note (#9304)

The dsimp only is no longer needed after #3222 adjusted the definition of Units.ext.

3d732b10

Diff

@@ -156,7 +156,7 @@ this map is a monoid homomorphism too. -/
   is an AddMonoid homomorphism too."]
 def liftRight (f : M →* N) (g : M → Nˣ) (h : ∀ x, ↑(g x) = f x) : M →* Nˣ where
   toFun := g
-  map_one' := by ext; dsimp only; rw [h 1]; exact f.map_one -- Porting note: why is `dsimp` needed?
+  map_one' := by ext; rw [h 1]; exact f.map_one
   map_mul' x y := Units.ext <| by simp only [h, val_mul, f.map_mul]
 #align units.lift_right Units.liftRight
 #align add_units.lift_right AddUnits.liftRight

chore: space after ← (#8178)

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

5fb9beab

Diff

@@ -391,7 +391,7 @@ protected theorem one_div_mul_cancel (h : IsUnit a) : 1 / a * a = 1 := by simp [
 @[to_additive]
 theorem inv (h : IsUnit a) : IsUnit a⁻¹ := by
   rcases h with ⟨u, hu⟩
-  rw [←hu, ← Units.val_inv_eq_inv_val]
+  rw [← hu, ← Units.val_inv_eq_inv_val]
   exact Units.isUnit _
 #align is_unit.inv IsUnit.inv
 #align is_add_unit.neg IsAddUnit.neg

refactor(Algebra/Hom): transpose Hom and file name (#8095)

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

92fe122e

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2018 Johan Commelin All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin, Chris Hughes, Kevin Buzzard
 -/
-import Mathlib.Algebra.Hom.Group.Defs
+import Mathlib.Algebra.Group.Hom.Defs
 import Mathlib.Algebra.Group.Units
 
 #align_import algebra.hom.units from "leanprover-community/mathlib"@"a07d750983b94c530ab69a726862c2ab6802b38c"

chore: exactly 4 spaces in theorems (#7328)

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

d3263b23

Diff

@@ -45,9 +45,9 @@ equal at `x⁻¹`. -/
   "If two homomorphisms from a subtraction monoid to an additive monoid are equal at an
   additive unit `x`, then they are equal at `-x`."]
 theorem IsUnit.eq_on_inv {F G N} [DivisionMonoid G] [Monoid N] [MonoidHomClass F G N]
-  {x : G} (hx : IsUnit x) (f g : F) (h : f x = g x) : f x⁻¹ = g x⁻¹ :=
-left_inv_eq_right_inv (map_mul_eq_one f hx.inv_mul_cancel)
-  (h.symm ▸ map_mul_eq_one g (hx.mul_inv_cancel))
+    {x : G} (hx : IsUnit x) (f g : F) (h : f x = g x) : f x⁻¹ = g x⁻¹ :=
+  left_inv_eq_right_inv (map_mul_eq_one f hx.inv_mul_cancel)
+    (h.symm ▸ map_mul_eq_one g (hx.mul_inv_cancel))
 #align is_unit.eq_on_inv IsUnit.eq_on_inv
 #align is_add_unit.eq_on_neg IsAddUnit.eq_on_neg
 
@@ -56,7 +56,7 @@ left_inv_eq_right_inv (map_mul_eq_one f hx.inv_mul_cancel)
     "If two homomorphism from an additive group to an additive monoid are equal at `x`,
     then they are equal at `-x`."]
 theorem eq_on_inv {F G M} [Group G] [Monoid M] [MonoidHomClass F G M]
-  (f g : F) {x : G} (h : f x = g x) : f x⁻¹ = g x⁻¹ :=
+    (f g : F) {x : G} (h : f x = g x) : f x⁻¹ = g x⁻¹ :=
   (Group.isUnit x).eq_on_inv f g h
 #align eq_on_inv eq_on_inv
 #align eq_on_neg eq_on_neg
@@ -223,15 +223,15 @@ theorem map [MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x) : IsUnit (f x)
 
 @[to_additive]
 theorem of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M] {f : F} {x : M} (g : G)
-  (hfg : Function.LeftInverse g f) (h : IsUnit (f x)) : IsUnit x :=
-  by simpa only [hfg x] using h.map g
+    (hfg : Function.LeftInverse g f) (h : IsUnit (f x)) : IsUnit x := by
+  simpa only [hfg x] using h.map g
 #align is_unit.of_left_inverse IsUnit.of_leftInverse
 #align is_add_unit.of_left_inverse IsAddUnit.of_leftInverse
 
 @[to_additive]
 theorem _root_.isUnit_map_of_leftInverse [MonoidHomClass F M N] [MonoidHomClass G N M]
-  {f : F} {x : M} (g : G) (hfg : Function.LeftInverse g f) :
-  IsUnit (f x) ↔ IsUnit x := ⟨of_leftInverse g hfg, map _⟩
+    {f : F} {x : M} (g : G) (hfg : Function.LeftInverse g f) :
+    IsUnit (f x) ↔ IsUnit x := ⟨of_leftInverse g hfg, map _⟩
 #align is_unit_map_of_left_inverse isUnit_map_of_leftInverse
 #align is_add_unit_map_of_left_inverse isAddUnit_map_of_leftInverse
 
@@ -490,7 +490,7 @@ protected theorem mul_div_mul_left (h : IsUnit c) (a b : α) : c * a / (c * b) =
 
 @[to_additive]
 protected theorem mul_eq_mul_of_div_eq_div (hb : IsUnit b) (hd : IsUnit d)
-  (a c : α) (h : a / b = c / d) : a * d = c * b := by
+    (a c : α) (h : a / b = c / d) : a * d = c * b := by
   rw [← mul_one a, ← hb.div_self, ← mul_comm_div, h, div_mul_eq_mul_div, hd.div_mul_cancel]
 #align is_unit.mul_eq_mul_of_div_eq_div IsUnit.mul_eq_mul_of_div_eq_div
 #align is_add_unit.add_eq_add_of_sub_eq_sub IsAddUnit.add_eq_add_of_sub_eq_sub

chore: exactly 4 spaces in subsequent lines (#7296)

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

43ed95ab

Diff

@@ -497,7 +497,7 @@ protected theorem mul_eq_mul_of_div_eq_div (hb : IsUnit b) (hd : IsUnit d)
 
 @[to_additive]
 protected theorem div_eq_div_iff (hb : IsUnit b) (hd : IsUnit d) :
-  a / b = c / d ↔ a * d = c * b := by
+    a / b = c / d ↔ a * d = c * b := by
   rw [← (hb.mul hd).mul_left_inj, ← mul_assoc, hb.div_mul_cancel, ← mul_assoc, mul_right_comm,
     hd.div_mul_cancel]
 #align is_unit.div_eq_div_iff IsUnit.div_eq_div_iff

chore: only four spaces for subsequent lines (#7286)

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

0c7d6fa5

Diff

@@ -143,7 +143,7 @@ theorem _root_.divp_eq_div (a : α) (u : αˣ) : a /ₚ u = a / u :=
 
 @[to_additive (attr := simp)]
 theorem _root_.map_units_inv {F : Type*} [MonoidHomClass F M α] (f : F) (u : Units M) :
-  f ↑u⁻¹ = (f u)⁻¹ := ((f : M →* α).comp (Units.coeHom M)).map_inv u
+    f ↑u⁻¹ = (f u)⁻¹ := ((f : M →* α).comp (Units.coeHom M)).map_inv u
 #align map_units_inv map_units_inv
 #align map_add_units_neg map_addUnits_neg
 
@@ -163,20 +163,20 @@ def liftRight (f : M →* N) (g : M → Nˣ) (h : ∀ x, ↑(g x) = f x) : M →
 
 @[to_additive (attr := simp)]
 theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
-  (liftRight f g h x : N) = f x := h x
+    (liftRight f g h x : N) = f x := h x
 #align units.coe_lift_right Units.coe_liftRight
 #align add_units.coe_lift_right AddUnits.coe_liftRight
 
 @[to_additive (attr := simp)]
 theorem mul_liftRight_inv {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
-  f x * ↑(liftRight f g h x)⁻¹ = 1 :=
+    f x * ↑(liftRight f g h x)⁻¹ = 1 :=
   by rw [Units.mul_inv_eq_iff_eq_mul, one_mul, coe_liftRight]
 #align units.mul_lift_right_inv Units.mul_liftRight_inv
 #align add_units.add_lift_right_neg AddUnits.add_liftRight_neg
 
 @[to_additive (attr := simp)]
 theorem liftRight_inv_mul {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
-  ↑(liftRight f g h x)⁻¹ * f x = 1 :=
+    ↑(liftRight f g h x)⁻¹ * f x = 1 :=
   by rw [Units.inv_mul_eq_iff_eq_mul, mul_one, coe_liftRight]
 #align units.lift_right_inv_mul Units.liftRight_inv_mul
 #align add_units.lift_right_neg_add AddUnits.liftRight_neg_add
@@ -201,7 +201,7 @@ def toHomUnits {G M : Type*} [Group G] [Monoid M] (f : G →* M) : G →* Mˣ :=
 
 @[to_additive (attr := simp)]
 theorem coe_toHomUnits {G M : Type*} [Group G] [Monoid M] (f : G →* M) (g : G) :
-  (f.toHomUnits g : M) = f g := rfl
+    (f.toHomUnits g : M) = f g := rfl
 #align monoid_hom.coe_to_hom_units MonoidHom.coe_toHomUnits
 #align add_monoid_hom.coe_to_hom_add_units AddMonoidHom.coe_toHomAddUnits
 
@@ -247,19 +247,19 @@ noncomputable def liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) : M →* N
 
 @[to_additive]
 theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
-  (IsUnit.liftRight f hf x : N) = f x := rfl
+    (IsUnit.liftRight f hf x : N) = f x := rfl
 #align is_unit.coe_lift_right IsUnit.coe_liftRight
 #align is_add_unit.coe_lift_right IsAddUnit.coe_liftRight
 
 @[to_additive (attr := simp)]
 theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
-  f x * ↑(IsUnit.liftRight f h x)⁻¹ = 1 := Units.mul_liftRight_inv (by intro; rfl) x
+    f x * ↑(IsUnit.liftRight f h x)⁻¹ = 1 := Units.mul_liftRight_inv (by intro; rfl) x
 #align is_unit.mul_lift_right_inv IsUnit.mul_liftRight_inv
 #align is_add_unit.add_lift_right_neg IsAddUnit.add_liftRight_neg
 
 @[to_additive (attr := simp)]
 theorem liftRight_inv_mul (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
-  ↑(IsUnit.liftRight f h x)⁻¹ * f x = 1 := Units.liftRight_inv_mul (by intro; rfl) x
+    ↑(IsUnit.liftRight f h x)⁻¹ * f x = 1 := Units.liftRight_inv_mul (by intro; rfl) x
 #align is_unit.lift_right_inv_mul IsUnit.liftRight_inv_mul
 #align is_add_unit.lift_right_neg_add IsAddUnit.liftRight_neg_add

chore: replace anonymous morphism constructors with named fields (#7015)

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.

2bffb702

Diff

@@ -102,8 +102,8 @@ theorem map_id : map (MonoidHom.id M) = MonoidHom.id Mˣ := by ext; rfl
 
 /-- Coercion `Mˣ → M` as a monoid homomorphism. -/
 @[to_additive "Coercion `AddUnits M → M` as an AddMonoid homomorphism."]
-def coeHom : Mˣ →* M :=
-  ⟨⟨Units.val, val_one⟩, val_mul⟩
+def coeHom : Mˣ →* M where
+  toFun := Units.val; map_one' := val_one; map_mul' := val_mul
 #align units.coe_hom Units.coeHom
 #align add_units.coe_hom AddUnits.coeHom

refactor: split Algebra.Hom.Group and Algebra.Hom.Ring (#7094)

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

260cb506

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2018 Johan Commelin All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin, Chris Hughes, Kevin Buzzard
 -/
-import Mathlib.Algebra.Hom.Group
+import Mathlib.Algebra.Hom.Group.Defs
 import Mathlib.Algebra.Group.Units
 
 #align_import algebra.hom.units from "leanprover-community/mathlib"@"a07d750983b94c530ab69a726862c2ab6802b38c"

fix: simps config for Units (#6514)

552f9b55

Diff

@@ -272,7 +272,7 @@ variable [DivisionMonoid α] {a b c : α}
 /-- The element of the group of units, corresponding to an element of a monoid which is a unit. As
 opposed to `IsUnit.unit`, the inverse is computable and comes from the inversion on `α`. This is
 useful to transfer properties of inversion in `Units α` to `α`. See also `toUnits`. -/
-@[to_additive (attr := simps)
+@[to_additive (attr := simps val)
   "The element of the additive group of additive units, corresponding to an element of
   an additive monoid which is an additive unit. As opposed to `IsAddUnit.addUnit`, the negation is
   computable and comes from the negation on `α`. This is useful to transfer properties of negation
@@ -281,6 +281,13 @@ def unit' (h : IsUnit a) : αˣ :=
   ⟨a, a⁻¹, h.mul_inv_cancel, h.inv_mul_cancel⟩
 #align is_unit.unit' IsUnit.unit'
 #align is_add_unit.add_unit' IsAddUnit.addUnit'
+#align is_unit.coe_unit' IsUnit.val_unit'
+#align is_add_unit.coe_add_unit' IsAddUnit.val_addUnit'
+
+-- Porting note: TODO: `simps val_inv` fails
+@[to_additive] theorem val_inv_unit' (h : IsUnit a) : ↑(h.unit'⁻¹) = a⁻¹ := rfl
+#align is_unit.coe_inv_unit' IsUnit.val_inv_unit'
+#align is_add_unit.coe_neg_add_unit' IsAddUnit.val_neg_addUnit'
 
 @[to_additive (attr := simp)]
 protected theorem mul_inv_cancel_left (h : IsUnit a) : ∀ b, a * (a⁻¹ * b) = b :=

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

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

This has nice performance benefits.

32de3f67

Diff

@@ -65,7 +65,7 @@ end MonoidHomClass
 
 namespace Units
 
-variable {α : Type _} {M : Type u} {N : Type v} {P : Type w} [Monoid M] [Monoid N] [Monoid P]
+variable {α : Type*} {M : Type u} {N : Type v} {P : Type w} [Monoid M] [Monoid N] [Monoid P]
 
 /-- The group homomorphism on units induced by a `MonoidHom`. -/
 @[to_additive "The additive homomorphism on `AddUnit`s induced by an `AddMonoidHom`."]
@@ -142,7 +142,7 @@ theorem _root_.divp_eq_div (a : α) (u : αˣ) : a /ₚ u = a / u :=
 #align divp_eq_div divp_eq_div
 
 @[to_additive (attr := simp)]
-theorem _root_.map_units_inv {F : Type _} [MonoidHomClass F M α] (f : F) (u : Units M) :
+theorem _root_.map_units_inv {F : Type*} [MonoidHomClass F M α] (f : F) (u : Units M) :
   f ↑u⁻¹ = (f u)⁻¹ := ((f : M →* α).comp (Units.coeHom M)).map_inv u
 #align map_units_inv map_units_inv
 #align map_add_units_neg map_addUnits_neg
@@ -192,7 +192,7 @@ and `f.toHomUnits` is the corresponding monoid homomorphism from `G` to `Mˣ`. -
   "If `f` is a homomorphism from an additive group `G` to an additive monoid `M`,
   then its image lies in the `AddUnits` of `M`,
   and `f.toHomUnits` is the corresponding homomorphism from `G` to `AddUnits M`."]
-def toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) : G →* Mˣ :=
+def toHomUnits {G M : Type*} [Group G] [Monoid M] (f : G →* M) : G →* Mˣ :=
   Units.liftRight f (fun g => ⟨f g, f g⁻¹, map_mul_eq_one f (mul_inv_self _),
     map_mul_eq_one f (inv_mul_self _)⟩)
     fun _ => rfl
@@ -200,7 +200,7 @@ def toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) : G →* Mˣ :
 #align add_monoid_hom.to_hom_add_units AddMonoidHom.toHomAddUnits
 
 @[to_additive (attr := simp)]
-theorem coe_toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) (g : G) :
+theorem coe_toHomUnits {G M : Type*} [Group G] [Monoid M] (f : G →* M) (g : G) :
   (f.toHomUnits g : M) = f g := rfl
 #align monoid_hom.coe_to_hom_units MonoidHom.coe_toHomUnits
 #align add_monoid_hom.coe_to_hom_add_units AddMonoidHom.coe_toHomAddUnits
@@ -209,7 +209,7 @@ end MonoidHom
 
 namespace IsUnit
 
-variable {F G α M N : Type _}
+variable {F G α M N : Type*}
 
 section Monoid

chore: remove 'Ported by' headers (#6018)

Briefly during the port we were adding "Ported by" headers, but only ~60 / 3000 files ended up with such a header.

I propose deleting them.

We could consider adding these uniformly via a script, as part of the great history rewrite...?

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

e8318a88

Diff

@@ -2,7 +2,6 @@
 Copyright (c) 2018 Johan Commelin All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin, Chris Hughes, Kevin Buzzard
-Ported by: Winston Yin
 -/
 import Mathlib.Algebra.Hom.Group
 import Mathlib.Algebra.Group.Units

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

depends on: #5966

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

89aa3a3b

Diff

@@ -3,15 +3,12 @@ Copyright (c) 2018 Johan Commelin All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin, Chris Hughes, Kevin Buzzard
 Ported by: Winston Yin
-
-! This file was ported from Lean 3 source module algebra.hom.units
-! leanprover-community/mathlib commit a07d750983b94c530ab69a726862c2ab6802b38c
-! 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.Group.Units
 
+#align_import algebra.hom.units from "leanprover-community/mathlib"@"a07d750983b94c530ab69a726862c2ab6802b38c"
+
 /-!
 # Monoid homomorphisms and units

chore: fix grammar 1/3 (#5001)

All of these are doc fixes

d8caa37d

Diff

@@ -20,8 +20,8 @@ also contains unrelated results about `Units` that depend on `MonoidHom`.
 
 ## Main declarations
 
-* `Units.map`: Turn an homomorphism from `α` to `β` monoids into an homomorphism from `αˣ` to `βˣ`.
-* `MonoidHom.toHomUnits`: Turn an homomorphism from a group `α` to `β` into an homomorphism from
+* `Units.map`: Turn a homomorphism from `α` to `β` monoids into a homomorphism from `αˣ` to `βˣ`.
+* `MonoidHom.toHomUnits`: Turn a homomorphism from a group `α` to `β` into a homomorphism from
   `α` to `βˣ`.
 
 ## TODO

Match https://github.com/leanprover-community/mathlib/pull/18958

chore: forward-port leanprover-community/mathlib#18958 (#3920)

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

e122338e

Diff

@@ -5,7 +5,7 @@ Authors: Johan Commelin, Chris Hughes, Kevin Buzzard
 Ported by: Winston Yin
 
 ! This file was ported from Lean 3 source module algebra.hom.units
-! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
+! leanprover-community/mathlib commit a07d750983b94c530ab69a726862c2ab6802b38c
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -437,7 +437,8 @@ protected theorem div_eq_one_iff_eq (h : IsUnit b) : a / b = 1 ↔ a = b :=
 #align is_unit.div_eq_one_iff_eq IsUnit.div_eq_one_iff_eq
 #align is_add_unit.sub_eq_zero_iff_eq IsAddUnit.sub_eq_zero_iff_eq
 
-@[to_additive]
+/-- The `Group` version of this lemma is `div_mul_cancel'''` -/
+@[to_additive "The `AddGroup` version of this lemma is `sub_add_cancel''`"]
 protected theorem div_mul_left (h : IsUnit b) : b / (a * b) = 1 / a := by
   rw [div_eq_mul_inv, mul_inv_rev, h.mul_inv_cancel_left, one_div]
 #align is_unit.div_mul_left IsUnit.div_mul_left

chore: forward-port leanprover-community/mathlib#18421 (#2191)

0422d4a6

Diff

@@ -5,7 +5,7 @@ Authors: Johan Commelin, Chris Hughes, Kevin Buzzard
 Ported by: Winston Yin
 
 ! This file was ported from Lean 3 source module algebra.hom.units
-! leanprover-community/mathlib commit 76171581280d5b5d1e2d1f4f37e5420357bdc636
+! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -505,6 +505,12 @@ protected theorem div_div_cancel (h : IsUnit a) : a / (a / b) = b := by
 #align is_unit.div_div_cancel IsUnit.div_div_cancel
 #align is_add_unit.sub_sub_cancel IsAddUnit.sub_sub_cancel
 
+@[to_additive]
+protected theorem div_div_cancel_left (h : IsUnit a) : a / b / a = b⁻¹ := by
+  rw [div_eq_mul_inv, div_eq_mul_inv, mul_right_comm, h.mul_inv_cancel, one_mul]
+#align is_unit.div_div_cancel_left IsUnit.div_div_cancel_left
+#align is_add_unit.sub_sub_cancel_left IsAddUnit.sub_sub_cancel_left
+
 end DivisionCommMonoid
 
 end IsUnit

feat: to_additive raises linter errors; nested to_additive (#1819)

Turn info messages of to_additive into linter errors
Allow @[to_additive (attr := to_additive)] to additivize the generated lemma. This is useful for Pow -> SMul -> VAdd lemmas. We can write e.g. @[to_additive (attr := to_additive, simp)] to add the simp attribute to all 3 generated lemmas, and we can provide other options to each to_additive call separately (specifying a name / reorder).
The previous point was needed to cleanly get rid of some linter warnings. It also required some additional changes (addToAdditiveAttr now returns a value, turn a few (meta) definitions into mutual partial def, reorder some definitions, generalize additivizeLemmas to lists of more than 2 elements) that should have no visible effects for the user.

37ae5972

Diff

@@ -118,7 +118,7 @@ theorem coeHom_apply (x : Mˣ) : coeHom M x = ↑x := rfl
 #align units.coe_hom_apply Units.coeHom_apply
 #align add_units.coe_hom_apply AddUnits.coeHom_apply
 
-@[to_additive (attr := simp, norm_cast) AddUnits.val_nsmul_eq_nsmul_val]
+@[to_additive (attr := simp, norm_cast)]
 theorem val_pow_eq_pow_val (u : Mˣ) (n : ℕ) : ((u ^ n : Mˣ) : M) = (u : M) ^ n :=
   (Units.coeHom M).map_pow u n
 #align units.coe_pow Units.val_pow_eq_pow_val

fix: use to_additive (attr := _) here and there (#2073)

adaaf293

Diff

@@ -276,12 +276,11 @@ variable [DivisionMonoid α] {a b c : α}
 /-- The element of the group of units, corresponding to an element of a monoid which is a unit. As
 opposed to `IsUnit.unit`, the inverse is computable and comes from the inversion on `α`. This is
 useful to transfer properties of inversion in `Units α` to `α`. See also `toUnits`. -/
-@[to_additive
+@[to_additive (attr := simps)
   "The element of the additive group of additive units, corresponding to an element of
   an additive monoid which is an additive unit. As opposed to `IsAddUnit.addUnit`, the negation is
   computable and comes from the negation on `α`. This is useful to transfer properties of negation
-  in `AddUnits α` to `α`. See also `toAddUnits`.",
-  simps]
+  in `AddUnits α` to `α`. See also `toAddUnits`."]
 def unit' (h : IsUnit a) : αˣ :=
   ⟨a, a⁻¹, h.mul_inv_cancel, h.inv_mul_cancel⟩
 #align is_unit.unit' IsUnit.unit'

chore: fix most phantom #aligns (#1794)

3d3fb046

Diff

@@ -39,7 +39,7 @@ universe u v w
 theorem Group.isUnit {G} [Group G] (g : G) : IsUnit g :=
   ⟨⟨g, g⁻¹, mul_inv_self g, inv_mul_self g⟩, rfl⟩
 #align group.is_unit Group.isUnit
-#align add_group.is_unit AddGroup.isAddUnit
+#align add_group.is_add_unit AddGroup.isAddUnit
 
 section MonoidHomClass
 
@@ -132,7 +132,7 @@ variable [DivisionMonoid α]
 theorem val_div_eq_div_val : ∀ u₁ u₂ : αˣ, ↑(u₁ / u₂) = (u₁ / u₂ : α) :=
   (Units.coeHom α).map_div
 #align units.coe_div Units.val_div_eq_div_val
-#align add_units.coe_neg AddUnits.val_neg_eq_neg_val
+#align add_units.coe_sub AddUnits.val_neg_eq_neg_val
 
 @[to_additive (attr := simp, norm_cast)]
 theorem val_zpow_eq_zpow_val : ∀ (u : αˣ) (n : ℤ), ((u ^ n : αˣ) : α) = (u : α) ^ n :=

feat: improve the way to_additive deals with attributes (#1314)

The new syntax for any attributes that need to be copied by to_additive is @[to_additive (attrs := simp, ext, simps)]
Adds the auxiliary declarations generated by the simp and simps attributes to the to_additive-dictionary.
Future issue: Does not yet translate auxiliary declarations for other attributes (including custom simp-attributes). In particular it's possible that norm_cast might generate some auxiliary declarations.
Fixes #950
Fixes #953
Fixes #1149
This moves the interaction between to_additive and simps from the Simps file to the toAdditive file for uniformity.
Make the same changes to @[reassoc]

Co-authored-by: Johan Commelin <johan@commelin.net> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

56bf4cd6

Diff

@@ -82,24 +82,24 @@ def map (f : M →* N) : Mˣ →* Nˣ :=
 #align units.map Units.map
 #align add_units.map AddUnits.map
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem coe_map (f : M →* N) (x : Mˣ) : ↑(map f x) = f x := rfl
 #align units.coe_map Units.coe_map
 #align add_units.coe_map AddUnits.coe_map
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem coe_map_inv (f : M →* N) (u : Mˣ) : ↑(map f u)⁻¹ = f ↑u⁻¹ := rfl
 #align units.coe_map_inv Units.coe_map_inv
 #align add_units.coe_map_neg AddUnits.coe_map_neg
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem map_comp (f : M →* N) (g : N →* P) : map (g.comp f) = (map g).comp (map f) := rfl
 #align units.map_comp Units.map_comp
 #align add_units.map_comp AddUnits.map_comp
 
 variable (M)
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem map_id : map (MonoidHom.id M) = MonoidHom.id Mˣ := by ext; rfl
 #align units.map_id Units.map_id
 #align add_units.map_id AddUnits.map_id
@@ -113,12 +113,12 @@ def coeHom : Mˣ →* M :=
 
 variable {M}
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem coeHom_apply (x : Mˣ) : coeHom M x = ↑x := rfl
 #align units.coe_hom_apply Units.coeHom_apply
 #align add_units.coe_hom_apply AddUnits.coeHom_apply
 
-@[simp, norm_cast, to_additive AddUnits.val_nsmul_eq_nsmul_val]
+@[to_additive (attr := simp, norm_cast) AddUnits.val_nsmul_eq_nsmul_val]
 theorem val_pow_eq_pow_val (u : Mˣ) (n : ℕ) : ((u ^ n : Mˣ) : M) = (u : M) ^ n :=
   (Units.coeHom M).map_pow u n
 #align units.coe_pow Units.val_pow_eq_pow_val
@@ -128,13 +128,13 @@ section DivisionMonoid
 
 variable [DivisionMonoid α]
 
-@[simp, norm_cast, to_additive]
+@[to_additive (attr := simp, norm_cast)]
 theorem val_div_eq_div_val : ∀ u₁ u₂ : αˣ, ↑(u₁ / u₂) = (u₁ / u₂ : α) :=
   (Units.coeHom α).map_div
 #align units.coe_div Units.val_div_eq_div_val
 #align add_units.coe_neg AddUnits.val_neg_eq_neg_val
 
-@[simp, norm_cast, to_additive]
+@[to_additive (attr := simp, norm_cast)]
 theorem val_zpow_eq_zpow_val : ∀ (u : αˣ) (n : ℤ), ((u ^ n : αˣ) : α) = (u : α) ^ n :=
   (Units.coeHom α).map_zpow
 #align units.coe_zpow Units.val_zpow_eq_zpow_val
@@ -145,7 +145,7 @@ theorem _root_.divp_eq_div (a : α) (u : αˣ) : a /ₚ u = a / u :=
   by rw [div_eq_mul_inv, divp, u.val_inv_eq_inv_val]
 #align divp_eq_div divp_eq_div
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem _root_.map_units_inv {F : Type _} [MonoidHomClass F M α] (f : F) (u : Units M) :
   f ↑u⁻¹ = (f u)⁻¹ := ((f : M →* α).comp (Units.coeHom M)).map_inv u
 #align map_units_inv map_units_inv
@@ -165,20 +165,20 @@ def liftRight (f : M →* N) (g : M → Nˣ) (h : ∀ x, ↑(g x) = f x) : M →
 #align units.lift_right Units.liftRight
 #align add_units.lift_right AddUnits.liftRight
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
   (liftRight f g h x : N) = f x := h x
 #align units.coe_lift_right Units.coe_liftRight
 #align add_units.coe_lift_right AddUnits.coe_liftRight
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mul_liftRight_inv {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
   f x * ↑(liftRight f g h x)⁻¹ = 1 :=
   by rw [Units.mul_inv_eq_iff_eq_mul, one_mul, coe_liftRight]
 #align units.mul_lift_right_inv Units.mul_liftRight_inv
 #align add_units.add_lift_right_neg AddUnits.add_liftRight_neg
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem liftRight_inv_mul {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
   ↑(liftRight f g h x)⁻¹ * f x = 1 :=
   by rw [Units.inv_mul_eq_iff_eq_mul, mul_one, coe_liftRight]
@@ -203,7 +203,7 @@ def toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) : G →* Mˣ :
 #align monoid_hom.to_hom_units MonoidHom.toHomUnits
 #align add_monoid_hom.to_hom_add_units AddMonoidHom.toHomAddUnits
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem coe_toHomUnits {G M : Type _} [Group G] [Monoid M] (f : G →* M) (g : G) :
   (f.toHomUnits g : M) = f g := rfl
 #align monoid_hom.coe_to_hom_units MonoidHom.coe_toHomUnits
@@ -255,13 +255,13 @@ theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
 #align is_unit.coe_lift_right IsUnit.coe_liftRight
 #align is_add_unit.coe_lift_right IsAddUnit.coe_liftRight
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
   f x * ↑(IsUnit.liftRight f h x)⁻¹ = 1 := Units.mul_liftRight_inv (by intro; rfl) x
 #align is_unit.mul_lift_right_inv IsUnit.mul_liftRight_inv
 #align is_add_unit.add_lift_right_neg IsAddUnit.add_liftRight_neg
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem liftRight_inv_mul (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
   ↑(IsUnit.liftRight f h x)⁻¹ * f x = 1 := Units.liftRight_inv_mul (by intro; rfl) x
 #align is_unit.lift_right_inv_mul IsUnit.liftRight_inv_mul
@@ -287,25 +287,25 @@ def unit' (h : IsUnit a) : αˣ :=
 #align is_unit.unit' IsUnit.unit'
 #align is_add_unit.add_unit' IsAddUnit.addUnit'
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 protected theorem mul_inv_cancel_left (h : IsUnit a) : ∀ b, a * (a⁻¹ * b) = b :=
   h.unit'.mul_inv_cancel_left
 #align is_unit.mul_inv_cancel_left IsUnit.mul_inv_cancel_left
 #align is_add_unit.add_neg_cancel_left IsAddUnit.add_neg_cancel_left
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 protected theorem inv_mul_cancel_left (h : IsUnit a) : ∀ b, a⁻¹ * (a * b) = b :=
   h.unit'.inv_mul_cancel_left
 #align is_unit.inv_mul_cancel_left IsUnit.inv_mul_cancel_left
 #align is_add_unit.neg_add_cancel_left IsAddUnit.neg_add_cancel_left
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 protected theorem mul_inv_cancel_right (h : IsUnit b) (a : α) : a * b * b⁻¹ = a :=
   h.unit'.mul_inv_cancel_right _
 #align is_unit.mul_inv_cancel_right IsUnit.mul_inv_cancel_right
 #align is_add_unit.add_neg_cancel_right IsAddUnit.add_neg_cancel_right
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 protected theorem inv_mul_cancel_right (h : IsUnit b) (a : α) : a * b⁻¹ * b = a :=
   h.unit'.inv_mul_cancel_right _
 #align is_unit.inv_mul_cancel_right IsUnit.inv_mul_cancel_right
@@ -364,13 +364,13 @@ protected theorem mul_eq_one_iff_inv_eq (h : IsUnit a) : a * b = 1 ↔ a⁻¹ =
 #align is_unit.mul_eq_one_iff_inv_eq IsUnit.mul_eq_one_iff_inv_eq
 #align is_add_unit.add_eq_zero_iff_neg_eq IsAddUnit.add_eq_zero_iff_neg_eq
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 protected theorem div_mul_cancel (h : IsUnit b) (a : α) : a / b * b = a := by
   rw [div_eq_mul_inv, h.inv_mul_cancel_right]
 #align is_unit.div_mul_cancel IsUnit.div_mul_cancel
 #align is_add_unit.sub_add_cancel IsAddUnit.sub_add_cancel
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 protected theorem mul_div_cancel (h : IsUnit b) (a : α) : a * b / b = a := by
   rw [div_eq_mul_inv, h.mul_inv_cancel_right]
 #align is_unit.mul_div_cancel IsUnit.mul_div_cancel

chore: fix casing per naming scheme (#1183)

Fix a lot of wrong casing mostly in the docstrings but also sometimes in def/theorem names. E.g. fin 2 --> Fin 2, add_monoid_hom --> AddMonoidHom

Remove \n from to_additive docstrings that were inserted by mathport.

Move files and directories with Gcd and Smul to GCD and SMul

71723d8b

Diff

@@ -239,11 +239,11 @@ theorem _root_.isUnit_map_of_leftInverse [MonoidHomClass F M N] [MonoidHomClass
 #align is_unit_map_of_left_inverse isUnit_map_of_leftInverse
 #align is_add_unit_map_of_left_inverse isAddUnit_map_of_leftInverse
 
-/-- If a homomorphism `f : M →* N` sends each element to an `is_unit`, then it can be lifted
-to `f : M →* Nˣ`. See also `units.lift_right` for a computable version. -/
+/-- If a homomorphism `f : M →* N` sends each element to an `IsUnit`, then it can be lifted
+to `f : M →* Nˣ`. See also `Units.liftRight` for a computable version. -/
 @[to_additive
-  "If a homomorphism `f : M →+ N` sends each element to an `is_add_unit`, then it can be
-  lifted to `f : M →+ add_units N`. See also `add_units.lift_right` for a computable version."]
+  "If a homomorphism `f : M →+ N` sends each element to an `IsAddUnit`, then it can be
+  lifted to `f : M →+ AddUnits N`. See also `AddUnits.liftRight` for a computable version."]
 noncomputable def liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) : M →* Nˣ :=
   (Units.liftRight f fun x => (hf x).unit) fun _ => rfl
 #align is_unit.lift_right IsUnit.liftRight
@@ -274,8 +274,8 @@ section DivisionMonoid
 variable [DivisionMonoid α] {a b c : α}
 
 /-- The element of the group of units, corresponding to an element of a monoid which is a unit. As
-opposed to `is_unit.unit`, the inverse is computable and comes from the inversion on `α`. This is
-useful to transfer properties of inversion in `units α` to `α`. See also `to_units`. -/
+opposed to `IsUnit.unit`, the inverse is computable and comes from the inversion on `α`. This is
+useful to transfer properties of inversion in `Units α` to `α`. See also `toUnits`. -/
 @[to_additive
   "The element of the additive group of additive units, corresponding to an element of
   an additive monoid which is an additive unit. As opposed to `IsAddUnit.addUnit`, the negation is

chore: bump to 2022-12-22 (#1157)

4b0358a2

Diff

@@ -257,13 +257,13 @@ theorem coe_liftRight (f : M →* N) (hf : ∀ x, IsUnit (f x)) (x) :
 
 @[simp, to_additive]
 theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
-  f x * ↑(IsUnit.liftRight f h x)⁻¹ = 1 := Units.mul_liftRight_inv (fun _ => rfl) x
+  f x * ↑(IsUnit.liftRight f h x)⁻¹ = 1 := Units.mul_liftRight_inv (by intro; rfl) x
 #align is_unit.mul_lift_right_inv IsUnit.mul_liftRight_inv
 #align is_add_unit.add_lift_right_neg IsAddUnit.add_liftRight_neg
 
 @[simp, to_additive]
 theorem liftRight_inv_mul (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
-  ↑(IsUnit.liftRight f h x)⁻¹ * f x = 1 := Units.liftRight_inv_mul (fun _ => rfl) x
+  ↑(IsUnit.liftRight f h x)⁻¹ * f x = 1 := Units.liftRight_inv_mul (by intro; rfl) x
 #align is_unit.lift_right_inv_mul IsUnit.liftRight_inv_mul
 #align is_add_unit.lift_right_neg_add IsAddUnit.liftRight_neg_add