algebra.group_with_zero.units.lemmas | Mathlib porting status

Changes since the initial port

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

Changes in mathlib3

dc6c365e

(last sync)

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

@@ -113,6 +113,8 @@ hb.is_unit.div_eq_div_iff hd.is_unit
 
 lemma div_div_cancel' (ha : a ≠ 0) : a / (a / b) = b := ha.is_unit.div_div_cancel
 
+lemma div_div_cancel_left' (ha : a ≠ 0) : a / b / a = b⁻¹ := ha.is_unit.div_div_cancel_left
+
 lemma div_helper (b : G₀) (h : a ≠ 0) : 1 / (a * b) * a = 1 / b :=
 by rw [div_mul_eq_mul_div, one_mul, div_mul_right _ h]

4dc134b9

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

dc6c365e

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
 import Algebra.GroupWithZero.Commute
-import Algebra.Hom.Units
+import Algebra.Group.Units.Hom
 import GroupTheory.GroupAction.Units
 
 #align_import algebra.group_with_zero.units.lemmas from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
@@ -81,18 +81,18 @@ theorem mul_eq_one_iff_inv_eq₀ (ha : a ≠ 0) : a * b = 1 ↔ a⁻¹ = b :=
 #align mul_eq_one_iff_inv_eq₀ mul_eq_one_iff_inv_eq₀
 -/
 
-#print div_mul_cancel /-
+#print div_mul_cancel₀ /-
 @[simp]
-theorem div_mul_cancel (a : G₀) (h : b ≠ 0) : a / b * b = a :=
+theorem div_mul_cancel₀ (a : G₀) (h : b ≠ 0) : a / b * b = a :=
   h.IsUnit.div_mul_cancelₓ _
-#align div_mul_cancel div_mul_cancel
+#align div_mul_cancel div_mul_cancel₀
 -/
 
-#print mul_div_cancel /-
+#print mul_div_cancel_right₀ /-
 @[simp]
-theorem mul_div_cancel (a : G₀) (h : b ≠ 0) : a * b / b = a :=
+theorem mul_div_cancel_right₀ (a : G₀) (h : b ≠ 0) : a * b / b = a :=
   h.IsUnit.mul_div_cancel _
-#align mul_div_cancel mul_div_cancel
+#align mul_div_cancel mul_div_cancel_right₀
 -/
 
 #print mul_one_div_cancel /-
@@ -177,25 +177,25 @@ theorem mul_mul_div (a : G₀) (hb : b ≠ 0) : a = a * b * (1 / b) :=
 
 #print div_div_div_cancel_right /-
 theorem div_div_div_cancel_right (a : G₀) (hc : c ≠ 0) : a / c / (b / c) = a / b := by
-  rw [div_div_eq_mul_div, div_mul_cancel _ hc]
+  rw [div_div_eq_mul_div, div_mul_cancel₀ _ hc]
 #align div_div_div_cancel_right div_div_div_cancel_right
 -/
 
 #print div_mul_div_cancel /-
 theorem div_mul_div_cancel (a : G₀) (hc : c ≠ 0) : a / c * (c / b) = a / b := by
-  rw [← mul_div_assoc, div_mul_cancel _ hc]
+  rw [← mul_div_assoc, div_mul_cancel₀ _ hc]
 #align div_mul_div_cancel div_mul_div_cancel
 -/
 
 #print div_mul_cancel_of_imp /-
 theorem div_mul_cancel_of_imp {a b : G₀} (h : b = 0 → a = 0) : a / b * b = a :=
-  by_cases (fun hb : b = 0 => by simp [*]) (div_mul_cancel a)
+  by_cases (fun hb : b = 0 => by simp [*]) (div_mul_cancel₀ a)
 #align div_mul_cancel_of_imp div_mul_cancel_of_imp
 -/
 
 #print mul_div_cancel_of_imp /-
 theorem mul_div_cancel_of_imp {a b : G₀} (h : b = 0 → a = 0) : a * b / b = a :=
-  by_cases (fun hb : b = 0 => by simp [*]) (mul_div_cancel a)
+  by_cases (fun hb : b = 0 => by simp [*]) (mul_div_cancel_right₀ a)
 #align mul_div_cancel_of_imp mul_div_cancel_of_imp
 -/
 
@@ -225,10 +225,10 @@ theorem mul_div_cancel_left_of_imp {a b : G₀} (h : a = 0 → b = 0) : a * b /
 #align mul_div_cancel_left_of_imp mul_div_cancel_left_of_imp
 -/
 
-#print mul_div_cancel_left /-
-theorem mul_div_cancel_left (b : G₀) (ha : a ≠ 0) : a * b / a = b :=
+#print mul_div_cancel_left₀ /-
+theorem mul_div_cancel_left₀ (b : G₀) (ha : a ≠ 0) : a * b / a = b :=
   ha.IsUnit.mul_div_cancel_left _
-#align mul_div_cancel_left mul_div_cancel_left
+#align mul_div_cancel_left mul_div_cancel_left₀
 -/
 
 #print mul_div_cancel_of_imp' /-
@@ -237,10 +237,10 @@ theorem mul_div_cancel_of_imp' {a b : G₀} (h : b = 0 → a = 0) : b * (a / b)
 #align mul_div_cancel_of_imp' mul_div_cancel_of_imp'
 -/
 
-#print mul_div_cancel' /-
-theorem mul_div_cancel' (a : G₀) (hb : b ≠ 0) : b * (a / b) = a :=
+#print mul_div_cancel₀ /-
+theorem mul_div_cancel₀ (a : G₀) (hb : b ≠ 0) : b * (a / b) = a :=
   hb.IsUnit.mul_div_cancel'ₓ _
-#align mul_div_cancel' mul_div_cancel'
+#align mul_div_cancel' mul_div_cancel₀
 -/
 
 #print mul_div_mul_left /-
@@ -252,7 +252,7 @@ theorem mul_div_mul_left (a b : G₀) (hc : c ≠ 0) : c * a / (c * b) = a / b :
 #print mul_eq_mul_of_div_eq_div /-
 theorem mul_eq_mul_of_div_eq_div (a : G₀) {b : G₀} (c : G₀) {d : G₀} (hb : b ≠ 0) (hd : d ≠ 0)
     (h : a / b = c / d) : a * d = c * b := by
-  rw [← mul_one a, ← div_self hb, ← mul_comm_div, h, div_mul_eq_mul_div, div_mul_cancel _ hd]
+  rw [← mul_one a, ← div_self hb, ← mul_comm_div, h, div_mul_eq_mul_div, div_mul_cancel₀ _ hd]
 #align mul_eq_mul_of_div_eq_div mul_eq_mul_of_div_eq_div
 -/

dc6c365e

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathbin.Algebra.GroupWithZero.Commute
-import Mathbin.Algebra.Hom.Units
-import Mathbin.GroupTheory.GroupAction.Units
+import Algebra.GroupWithZero.Commute
+import Algebra.Hom.Units
+import GroupTheory.GroupAction.Units
 
 #align_import algebra.group_with_zero.units.lemmas from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"

dc6c365e

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module algebra.group_with_zero.units.lemmas
-! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.GroupWithZero.Commute
 import Mathbin.Algebra.Hom.Units
 import Mathbin.GroupTheory.GroupAction.Units
 
+#align_import algebra.group_with_zero.units.lemmas from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
+
 /-!
 # Further lemmas about units in a `monoid_with_zero` or a `group_with_zero`.

dc6c365e

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -29,127 +29,185 @@ section GroupWithZero
 
 variable [GroupWithZero G₀] {a b c : G₀}
 
+#print div_self /-
 @[simp]
 theorem div_self (h : a ≠ 0) : a / a = 1 :=
   h.IsUnit.div_self
 #align div_self div_self
+-/
 
+#print eq_mul_inv_iff_mul_eq₀ /-
 theorem eq_mul_inv_iff_mul_eq₀ (hc : c ≠ 0) : a = b * c⁻¹ ↔ a * c = b :=
   hc.IsUnit.eq_mul_inv_iff_mul_eq
 #align eq_mul_inv_iff_mul_eq₀ eq_mul_inv_iff_mul_eq₀
+-/
 
+#print eq_inv_mul_iff_mul_eq₀ /-
 theorem eq_inv_mul_iff_mul_eq₀ (hb : b ≠ 0) : a = b⁻¹ * c ↔ b * a = c :=
   hb.IsUnit.eq_inv_mul_iff_mul_eq
 #align eq_inv_mul_iff_mul_eq₀ eq_inv_mul_iff_mul_eq₀
+-/
 
+#print inv_mul_eq_iff_eq_mul₀ /-
 theorem inv_mul_eq_iff_eq_mul₀ (ha : a ≠ 0) : a⁻¹ * b = c ↔ b = a * c :=
   ha.IsUnit.inv_mul_eq_iff_eq_mul
 #align inv_mul_eq_iff_eq_mul₀ inv_mul_eq_iff_eq_mul₀
+-/
 
+#print mul_inv_eq_iff_eq_mul₀ /-
 theorem mul_inv_eq_iff_eq_mul₀ (hb : b ≠ 0) : a * b⁻¹ = c ↔ a = c * b :=
   hb.IsUnit.mul_inv_eq_iff_eq_mul
 #align mul_inv_eq_iff_eq_mul₀ mul_inv_eq_iff_eq_mul₀
+-/
 
+#print mul_inv_eq_one₀ /-
 theorem mul_inv_eq_one₀ (hb : b ≠ 0) : a * b⁻¹ = 1 ↔ a = b :=
   hb.IsUnit.mul_inv_eq_one
 #align mul_inv_eq_one₀ mul_inv_eq_one₀
+-/
 
+#print inv_mul_eq_one₀ /-
 theorem inv_mul_eq_one₀ (ha : a ≠ 0) : a⁻¹ * b = 1 ↔ a = b :=
   ha.IsUnit.inv_mul_eq_one
 #align inv_mul_eq_one₀ inv_mul_eq_one₀
+-/
 
+#print mul_eq_one_iff_eq_inv₀ /-
 theorem mul_eq_one_iff_eq_inv₀ (hb : b ≠ 0) : a * b = 1 ↔ a = b⁻¹ :=
   hb.IsUnit.mul_eq_one_iff_eq_inv
 #align mul_eq_one_iff_eq_inv₀ mul_eq_one_iff_eq_inv₀
+-/
 
+#print mul_eq_one_iff_inv_eq₀ /-
 theorem mul_eq_one_iff_inv_eq₀ (ha : a ≠ 0) : a * b = 1 ↔ a⁻¹ = b :=
   ha.IsUnit.mul_eq_one_iff_inv_eq
 #align mul_eq_one_iff_inv_eq₀ mul_eq_one_iff_inv_eq₀
+-/
 
+#print div_mul_cancel /-
 @[simp]
 theorem div_mul_cancel (a : G₀) (h : b ≠ 0) : a / b * b = a :=
   h.IsUnit.div_mul_cancelₓ _
 #align div_mul_cancel div_mul_cancel
+-/
 
+#print mul_div_cancel /-
 @[simp]
 theorem mul_div_cancel (a : G₀) (h : b ≠ 0) : a * b / b = a :=
   h.IsUnit.mul_div_cancel _
 #align mul_div_cancel mul_div_cancel
+-/
 
+#print mul_one_div_cancel /-
 theorem mul_one_div_cancel (h : a ≠ 0) : a * (1 / a) = 1 :=
   h.IsUnit.mul_one_div_cancel
 #align mul_one_div_cancel mul_one_div_cancel
+-/
 
+#print one_div_mul_cancel /-
 theorem one_div_mul_cancel (h : a ≠ 0) : 1 / a * a = 1 :=
   h.IsUnit.one_div_mul_cancel
 #align one_div_mul_cancel one_div_mul_cancel
+-/
 
+#print div_left_inj' /-
 theorem div_left_inj' (hc : c ≠ 0) : a / c = b / c ↔ a = b :=
   hc.IsUnit.div_left_inj
 #align div_left_inj' div_left_inj'
+-/
 
+#print div_eq_iff /-
 @[field_simps]
 theorem div_eq_iff (hb : b ≠ 0) : a / b = c ↔ a = c * b :=
   hb.IsUnit.div_eq_iff
 #align div_eq_iff div_eq_iff
+-/
 
+#print eq_div_iff /-
 @[field_simps]
 theorem eq_div_iff (hb : b ≠ 0) : c = a / b ↔ c * b = a :=
   hb.IsUnit.eq_div_iff
 #align eq_div_iff eq_div_iff
+-/
 
+#print div_eq_iff_mul_eq /-
 theorem div_eq_iff_mul_eq (hb : b ≠ 0) : a / b = c ↔ c * b = a :=
   hb.IsUnit.div_eq_iff.trans eq_comm
 #align div_eq_iff_mul_eq div_eq_iff_mul_eq
+-/
 
+#print eq_div_iff_mul_eq /-
 theorem eq_div_iff_mul_eq (hc : c ≠ 0) : a = b / c ↔ a * c = b :=
   hc.IsUnit.eq_div_iff
 #align eq_div_iff_mul_eq eq_div_iff_mul_eq
+-/
 
+#print div_eq_of_eq_mul /-
 theorem div_eq_of_eq_mul (hb : b ≠ 0) : a = c * b → a / b = c :=
   hb.IsUnit.div_eq_of_eq_mul
 #align div_eq_of_eq_mul div_eq_of_eq_mul
+-/
 
+#print eq_div_of_mul_eq /-
 theorem eq_div_of_mul_eq (hc : c ≠ 0) : a * c = b → a = b / c :=
   hc.IsUnit.eq_div_of_mul_eq
 #align eq_div_of_mul_eq eq_div_of_mul_eq
+-/
 
+#print div_eq_one_iff_eq /-
 theorem div_eq_one_iff_eq (hb : b ≠ 0) : a / b = 1 ↔ a = b :=
   hb.IsUnit.div_eq_one_iff_eq
 #align div_eq_one_iff_eq div_eq_one_iff_eq
+-/
 
+#print div_mul_left /-
 theorem div_mul_left (hb : b ≠ 0) : b / (a * b) = 1 / a :=
   hb.IsUnit.div_mul_left
 #align div_mul_left div_mul_left
+-/
 
+#print mul_div_mul_right /-
 theorem mul_div_mul_right (a b : G₀) (hc : c ≠ 0) : a * c / (b * c) = a / b :=
   hc.IsUnit.mul_div_mul_right _ _
 #align mul_div_mul_right mul_div_mul_right
+-/
 
+#print mul_mul_div /-
 theorem mul_mul_div (a : G₀) (hb : b ≠ 0) : a = a * b * (1 / b) :=
   (hb.IsUnit.mul_mul_div _).symm
 #align mul_mul_div mul_mul_div
+-/
 
+#print div_div_div_cancel_right /-
 theorem div_div_div_cancel_right (a : G₀) (hc : c ≠ 0) : a / c / (b / c) = a / b := by
   rw [div_div_eq_mul_div, div_mul_cancel _ hc]
 #align div_div_div_cancel_right div_div_div_cancel_right
+-/
 
+#print div_mul_div_cancel /-
 theorem div_mul_div_cancel (a : G₀) (hc : c ≠ 0) : a / c * (c / b) = a / b := by
   rw [← mul_div_assoc, div_mul_cancel _ hc]
 #align div_mul_div_cancel div_mul_div_cancel
+-/
 
+#print div_mul_cancel_of_imp /-
 theorem div_mul_cancel_of_imp {a b : G₀} (h : b = 0 → a = 0) : a / b * b = a :=
   by_cases (fun hb : b = 0 => by simp [*]) (div_mul_cancel a)
 #align div_mul_cancel_of_imp div_mul_cancel_of_imp
+-/
 
+#print mul_div_cancel_of_imp /-
 theorem mul_div_cancel_of_imp {a b : G₀} (h : b = 0 → a = 0) : a * b / b = a :=
   by_cases (fun hb : b = 0 => by simp [*]) (mul_div_cancel a)
 #align mul_div_cancel_of_imp mul_div_cancel_of_imp
+-/
 
+#print divp_mk0 /-
 @[simp]
 theorem divp_mk0 (a : G₀) {b : G₀} (hb : b ≠ 0) : a /ₚ Units.mk0 b hb = a / b :=
   divp_eq_div _ _
 #align divp_mk0 divp_mk0
+-/
 
 end GroupWithZero
 
@@ -158,51 +216,73 @@ section CommGroupWithZero
 -- comm
 variable [CommGroupWithZero G₀] {a b c d : G₀}
 
+#print div_mul_right /-
 theorem div_mul_right (b : G₀) (ha : a ≠ 0) : a / (a * b) = 1 / b :=
   ha.IsUnit.div_mul_right _
 #align div_mul_right div_mul_right
+-/
 
+#print mul_div_cancel_left_of_imp /-
 theorem mul_div_cancel_left_of_imp {a b : G₀} (h : a = 0 → b = 0) : a * b / a = b := by
   rw [mul_comm, mul_div_cancel_of_imp h]
 #align mul_div_cancel_left_of_imp mul_div_cancel_left_of_imp
+-/
 
+#print mul_div_cancel_left /-
 theorem mul_div_cancel_left (b : G₀) (ha : a ≠ 0) : a * b / a = b :=
   ha.IsUnit.mul_div_cancel_left _
 #align mul_div_cancel_left mul_div_cancel_left
+-/
 
+#print mul_div_cancel_of_imp' /-
 theorem mul_div_cancel_of_imp' {a b : G₀} (h : b = 0 → a = 0) : b * (a / b) = a := by
   rw [mul_comm, div_mul_cancel_of_imp h]
 #align mul_div_cancel_of_imp' mul_div_cancel_of_imp'
+-/
 
+#print mul_div_cancel' /-
 theorem mul_div_cancel' (a : G₀) (hb : b ≠ 0) : b * (a / b) = a :=
   hb.IsUnit.mul_div_cancel'ₓ _
 #align mul_div_cancel' mul_div_cancel'
+-/
 
+#print mul_div_mul_left /-
 theorem mul_div_mul_left (a b : G₀) (hc : c ≠ 0) : c * a / (c * b) = a / b :=
   hc.IsUnit.mul_div_mul_left _ _
 #align mul_div_mul_left mul_div_mul_left
+-/
 
+#print mul_eq_mul_of_div_eq_div /-
 theorem mul_eq_mul_of_div_eq_div (a : G₀) {b : G₀} (c : G₀) {d : G₀} (hb : b ≠ 0) (hd : d ≠ 0)
     (h : a / b = c / d) : a * d = c * b := by
   rw [← mul_one a, ← div_self hb, ← mul_comm_div, h, div_mul_eq_mul_div, div_mul_cancel _ hd]
 #align mul_eq_mul_of_div_eq_div mul_eq_mul_of_div_eq_div
+-/
 
+#print div_eq_div_iff /-
 @[field_simps]
 theorem div_eq_div_iff (hb : b ≠ 0) (hd : d ≠ 0) : a / b = c / d ↔ a * d = c * b :=
   hb.IsUnit.div_eq_div_iff hd.IsUnit
 #align div_eq_div_iff div_eq_div_iff
+-/
 
+#print div_div_cancel' /-
 theorem div_div_cancel' (ha : a ≠ 0) : a / (a / b) = b :=
   ha.IsUnit.div_div_cancel
 #align div_div_cancel' div_div_cancel'
+-/
 
+#print div_div_cancel_left' /-
 theorem div_div_cancel_left' (ha : a ≠ 0) : a / b / a = b⁻¹ :=
   ha.IsUnit.div_div_cancel_left
 #align div_div_cancel_left' div_div_cancel_left'
+-/
 
+#print div_helper /-
 theorem div_helper (b : G₀) (h : a ≠ 0) : 1 / (a * b) * a = 1 / b := by
   rw [div_mul_eq_mul_div, one_mul, div_mul_right _ h]
 #align div_helper div_helper
+-/
 
 end CommGroupWithZero
 
@@ -211,27 +291,27 @@ section MonoidWithZero
 variable [GroupWithZero G₀] [Nontrivial M₀] [MonoidWithZero M₀'] [MonoidWithZeroHomClass F G₀ M₀]
   [MonoidWithZeroHomClass F' G₀ M₀'] (f : F) {a : G₀}
 
-include M₀
-
+#print map_ne_zero /-
 theorem map_ne_zero : f a ≠ 0 ↔ a ≠ 0 :=
   ⟨fun hfa ha => hfa <| ha.symm ▸ map_zero f, fun ha => ((IsUnit.mk0 a ha).map f).NeZero⟩
 #align map_ne_zero map_ne_zero
+-/
 
+#print map_eq_zero /-
 @[simp]
 theorem map_eq_zero : f a = 0 ↔ a = 0 :=
   not_iff_not.1 (map_ne_zero f)
 #align map_eq_zero map_eq_zero
+-/
 
-omit M₀
-
-include M₀'
-
+#print eq_on_inv₀ /-
 theorem eq_on_inv₀ (f g : F') (h : f a = g a) : f a⁻¹ = g a⁻¹ :=
   by
   rcases eq_or_ne a 0 with (rfl | ha)
   · rw [inv_zero, map_zero, map_zero]
   · exact (IsUnit.mk0 a ha).eq_on_inv f g h
 #align eq_on_inv₀ eq_on_inv₀
+-/
 
 end MonoidWithZero
 
@@ -239,8 +319,7 @@ section GroupWithZero
 
 variable [GroupWithZero G₀] [GroupWithZero G₀'] [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (a b : G₀)
 
-include G₀'
-
+#print map_inv₀ /-
 /-- A monoid homomorphism between groups with zeros sending `0` to `0` sends `a⁻¹` to `(f a)⁻¹`. -/
 @[simp]
 theorem map_inv₀ : f a⁻¹ = (f a)⁻¹ := by
@@ -248,11 +327,14 @@ theorem map_inv₀ : f a⁻¹ = (f a)⁻¹ := by
   apply eq_inv_of_mul_eq_one_left
   rw [← map_mul, inv_mul_cancel h, map_one]
 #align map_inv₀ map_inv₀
+-/
 
+#print map_div₀ /-
 @[simp]
 theorem map_div₀ : f (a / b) = f a / f b :=
   map_div' f (map_inv₀ f) a b
 #align map_div₀ map_div₀
+-/
 
 end GroupWithZero
 
@@ -268,17 +350,21 @@ noncomputable def MonoidWithZero.inverse {M : Type _} [CommMonoidWithZero M] : M
 #align monoid_with_zero.inverse MonoidWithZero.inverse
 -/
 
+#print MonoidWithZero.coe_inverse /-
 @[simp]
 theorem MonoidWithZero.coe_inverse {M : Type _} [CommMonoidWithZero M] :
     (MonoidWithZero.inverse : M → M) = Ring.inverse :=
   rfl
 #align monoid_with_zero.coe_inverse MonoidWithZero.coe_inverse
+-/
 
+#print MonoidWithZero.inverse_apply /-
 @[simp]
 theorem MonoidWithZero.inverse_apply {M : Type _} [CommMonoidWithZero M] (a : M) :
     MonoidWithZero.inverse a = Ring.inverse a :=
   rfl
 #align monoid_with_zero.inverse_apply MonoidWithZero.inverse_apply
+-/
 
 #print invMonoidWithZeroHom /-
 /-- Inversion on a commutative group with zero, considered as a monoid with zero homomorphism. -/
@@ -293,10 +379,12 @@ variable [GroupWithZero G₀]
 
 variable {a b : G₀}
 
+#print Units.smul_mk0 /-
 @[simp]
 theorem smul_mk0 {α : Type _} [SMul G₀ α] {g : G₀} (hg : g ≠ 0) (a : α) : mk0 g hg • a = g • a :=
   rfl
 #align units.smul_mk0 Units.smul_mk0
+-/
 
 end Units

dc6c365e

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -29,297 +29,123 @@ section GroupWithZero
 
 variable [GroupWithZero G₀] {a b c : G₀}
 
-/- warning: div_self -> div_self is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a a) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))))))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a a) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (GroupWithZero.toDivisionMonoid.{u1} G₀ _inst_2)))))))
-Case conversion may be inaccurate. Consider using '#align div_self div_selfₓ'. -/
 @[simp]
 theorem div_self (h : a ≠ 0) : a / a = 1 :=
   h.IsUnit.div_self
 #align div_self div_self
 
-/- warning: eq_mul_inv_iff_mul_eq₀ -> eq_mul_inv_iff_mul_eq₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) b (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) c))) (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a c) b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) b (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) c))) (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a c) b))
-Case conversion may be inaccurate. Consider using '#align eq_mul_inv_iff_mul_eq₀ eq_mul_inv_iff_mul_eq₀ₓ'. -/
 theorem eq_mul_inv_iff_mul_eq₀ (hc : c ≠ 0) : a = b * c⁻¹ ↔ a * c = b :=
   hc.IsUnit.eq_mul_inv_iff_mul_eq
 #align eq_mul_inv_iff_mul_eq₀ eq_mul_inv_iff_mul_eq₀
 
-/- warning: eq_inv_mul_iff_mul_eq₀ -> eq_inv_mul_iff_mul_eq₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) b) c)) (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) b a) c))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) b) c)) (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) b a) c))
-Case conversion may be inaccurate. Consider using '#align eq_inv_mul_iff_mul_eq₀ eq_inv_mul_iff_mul_eq₀ₓ'. -/
 theorem eq_inv_mul_iff_mul_eq₀ (hb : b ≠ 0) : a = b⁻¹ * c ↔ b * a = c :=
   hb.IsUnit.eq_inv_mul_iff_mul_eq
 #align eq_inv_mul_iff_mul_eq₀ eq_inv_mul_iff_mul_eq₀
 
-/- warning: inv_mul_eq_iff_eq_mul₀ -> inv_mul_eq_iff_eq_mul₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a) b) c) (Eq.{succ u1} G₀ b (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a c)))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a) b) c) (Eq.{succ u1} G₀ b (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a c)))
-Case conversion may be inaccurate. Consider using '#align inv_mul_eq_iff_eq_mul₀ inv_mul_eq_iff_eq_mul₀ₓ'. -/
 theorem inv_mul_eq_iff_eq_mul₀ (ha : a ≠ 0) : a⁻¹ * b = c ↔ b = a * c :=
   ha.IsUnit.inv_mul_eq_iff_eq_mul
 #align inv_mul_eq_iff_eq_mul₀ inv_mul_eq_iff_eq_mul₀
 
-/- warning: mul_inv_eq_iff_eq_mul₀ -> mul_inv_eq_iff_eq_mul₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) b)) c) (Eq.{succ u1} G₀ a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) c b)))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) b)) c) (Eq.{succ u1} G₀ a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) c b)))
-Case conversion may be inaccurate. Consider using '#align mul_inv_eq_iff_eq_mul₀ mul_inv_eq_iff_eq_mul₀ₓ'. -/
 theorem mul_inv_eq_iff_eq_mul₀ (hb : b ≠ 0) : a * b⁻¹ = c ↔ a = c * b :=
   hb.IsUnit.mul_inv_eq_iff_eq_mul
 #align mul_inv_eq_iff_eq_mul₀ mul_inv_eq_iff_eq_mul₀
 
-/- warning: mul_inv_eq_one₀ -> mul_inv_eq_one₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) b)) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) (Eq.{succ u1} G₀ a b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) b)) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (GroupWithZero.toDivisionMonoid.{u1} G₀ _inst_2))))))) (Eq.{succ u1} G₀ a b))
-Case conversion may be inaccurate. Consider using '#align mul_inv_eq_one₀ mul_inv_eq_one₀ₓ'. -/
 theorem mul_inv_eq_one₀ (hb : b ≠ 0) : a * b⁻¹ = 1 ↔ a = b :=
   hb.IsUnit.mul_inv_eq_one
 #align mul_inv_eq_one₀ mul_inv_eq_one₀
 
-/- warning: inv_mul_eq_one₀ -> inv_mul_eq_one₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a) b) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) (Eq.{succ u1} G₀ a b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a) b) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (GroupWithZero.toDivisionMonoid.{u1} G₀ _inst_2))))))) (Eq.{succ u1} G₀ a b))
-Case conversion may be inaccurate. Consider using '#align inv_mul_eq_one₀ inv_mul_eq_one₀ₓ'. -/
 theorem inv_mul_eq_one₀ (ha : a ≠ 0) : a⁻¹ * b = 1 ↔ a = b :=
   ha.IsUnit.inv_mul_eq_one
 #align inv_mul_eq_one₀ inv_mul_eq_one₀
 
-/- warning: mul_eq_one_iff_eq_inv₀ -> mul_eq_one_iff_eq_inv₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a b) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) (Eq.{succ u1} G₀ a (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) b)))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a b) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (GroupWithZero.toDivisionMonoid.{u1} G₀ _inst_2))))))) (Eq.{succ u1} G₀ a (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) b)))
-Case conversion may be inaccurate. Consider using '#align mul_eq_one_iff_eq_inv₀ mul_eq_one_iff_eq_inv₀ₓ'. -/
 theorem mul_eq_one_iff_eq_inv₀ (hb : b ≠ 0) : a * b = 1 ↔ a = b⁻¹ :=
   hb.IsUnit.mul_eq_one_iff_eq_inv
 #align mul_eq_one_iff_eq_inv₀ mul_eq_one_iff_eq_inv₀
 
-/- warning: mul_eq_one_iff_inv_eq₀ -> mul_eq_one_iff_inv_eq₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a b) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) (Eq.{succ u1} G₀ (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a) b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a b) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (GroupWithZero.toDivisionMonoid.{u1} G₀ _inst_2))))))) (Eq.{succ u1} G₀ (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a) b))
-Case conversion may be inaccurate. Consider using '#align mul_eq_one_iff_inv_eq₀ mul_eq_one_iff_inv_eq₀ₓ'. -/
 theorem mul_eq_one_iff_inv_eq₀ (ha : a ≠ 0) : a * b = 1 ↔ a⁻¹ = b :=
   ha.IsUnit.mul_eq_one_iff_inv_eq
 #align mul_eq_one_iff_inv_eq₀ mul_eq_one_iff_inv_eq₀
 
-/- warning: div_mul_cancel -> div_mul_cancel is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {b : G₀} (a : G₀), (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b) b) a)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {b : G₀} (a : G₀), (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a b) b) a)
-Case conversion may be inaccurate. Consider using '#align div_mul_cancel div_mul_cancelₓ'. -/
 @[simp]
 theorem div_mul_cancel (a : G₀) (h : b ≠ 0) : a / b * b = a :=
   h.IsUnit.div_mul_cancelₓ _
 #align div_mul_cancel div_mul_cancel
 
-/- warning: mul_div_cancel -> mul_div_cancel is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {b : G₀} (a : G₀), (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a b) b) a)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {b : G₀} (a : G₀), (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a b) b) a)
-Case conversion may be inaccurate. Consider using '#align mul_div_cancel mul_div_cancelₓ'. -/
 @[simp]
 theorem mul_div_cancel (a : G₀) (h : b ≠ 0) : a * b / b = a :=
   h.IsUnit.mul_div_cancel _
 #align mul_div_cancel mul_div_cancel
 
-/- warning: mul_one_div_cancel -> mul_one_div_cancel is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))))) a)) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))))))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (GroupWithZero.toDivisionMonoid.{u1} G₀ _inst_2)))))) a)) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (GroupWithZero.toDivisionMonoid.{u1} G₀ _inst_2)))))))
-Case conversion may be inaccurate. Consider using '#align mul_one_div_cancel mul_one_div_cancelₓ'. -/
 theorem mul_one_div_cancel (h : a ≠ 0) : a * (1 / a) = 1 :=
   h.IsUnit.mul_one_div_cancel
 #align mul_one_div_cancel mul_one_div_cancel
 
-/- warning: one_div_mul_cancel -> one_div_mul_cancel is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))))) a) a) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))))))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (GroupWithZero.toDivisionMonoid.{u1} G₀ _inst_2)))))) a) a) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (GroupWithZero.toDivisionMonoid.{u1} G₀ _inst_2)))))))
-Case conversion may be inaccurate. Consider using '#align one_div_mul_cancel one_div_mul_cancelₓ'. -/
 theorem one_div_mul_cancel (h : a ≠ 0) : 1 / a * a = 1 :=
   h.IsUnit.one_div_mul_cancel
 #align one_div_mul_cancel one_div_mul_cancel
 
-/- warning: div_left_inj' -> div_left_inj' is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a c) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) b c)) (Eq.{succ u1} G₀ a b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a c) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) b c)) (Eq.{succ u1} G₀ a b))
-Case conversion may be inaccurate. Consider using '#align div_left_inj' div_left_inj'ₓ'. -/
 theorem div_left_inj' (hc : c ≠ 0) : a / c = b / c ↔ a = b :=
   hc.IsUnit.div_left_inj
 #align div_left_inj' div_left_inj'
 
-/- warning: div_eq_iff -> div_eq_iff is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b) c) (Eq.{succ u1} G₀ a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) c b)))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a b) c) (Eq.{succ u1} G₀ a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) c b)))
-Case conversion may be inaccurate. Consider using '#align div_eq_iff div_eq_iffₓ'. -/
 @[field_simps]
 theorem div_eq_iff (hb : b ≠ 0) : a / b = c ↔ a = c * b :=
   hb.IsUnit.div_eq_iff
 #align div_eq_iff div_eq_iff
 
-/- warning: eq_div_iff -> eq_div_iff is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ c (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b)) (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) c b) a))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ c (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a b)) (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) c b) a))
-Case conversion may be inaccurate. Consider using '#align eq_div_iff eq_div_iffₓ'. -/
 @[field_simps]
 theorem eq_div_iff (hb : b ≠ 0) : c = a / b ↔ c * b = a :=
   hb.IsUnit.eq_div_iff
 #align eq_div_iff eq_div_iff
 
-/- warning: div_eq_iff_mul_eq -> div_eq_iff_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b) c) (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) c b) a))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a b) c) (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) c b) a))
-Case conversion may be inaccurate. Consider using '#align div_eq_iff_mul_eq div_eq_iff_mul_eqₓ'. -/
 theorem div_eq_iff_mul_eq (hb : b ≠ 0) : a / b = c ↔ c * b = a :=
   hb.IsUnit.div_eq_iff.trans eq_comm
 #align div_eq_iff_mul_eq div_eq_iff_mul_eq
 
-/- warning: eq_div_iff_mul_eq -> eq_div_iff_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ a (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) b c)) (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a c) b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ a (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) b c)) (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a c) b))
-Case conversion may be inaccurate. Consider using '#align eq_div_iff_mul_eq eq_div_iff_mul_eqₓ'. -/
 theorem eq_div_iff_mul_eq (hc : c ≠ 0) : a = b / c ↔ a * c = b :=
   hc.IsUnit.eq_div_iff
 #align eq_div_iff_mul_eq eq_div_iff_mul_eq
 
-/- warning: div_eq_of_eq_mul -> div_eq_of_eq_mul is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) c b)) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b) c)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) c b)) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a b) c)
-Case conversion may be inaccurate. Consider using '#align div_eq_of_eq_mul div_eq_of_eq_mulₓ'. -/
 theorem div_eq_of_eq_mul (hb : b ≠ 0) : a = c * b → a / b = c :=
   hb.IsUnit.div_eq_of_eq_mul
 #align div_eq_of_eq_mul div_eq_of_eq_mul
 
-/- warning: eq_div_of_mul_eq -> eq_div_of_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a c) b) -> (Eq.{succ u1} G₀ a (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) b c))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀}, (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a c) b) -> (Eq.{succ u1} G₀ a (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) b c))
-Case conversion may be inaccurate. Consider using '#align eq_div_of_mul_eq eq_div_of_mul_eqₓ'. -/
 theorem eq_div_of_mul_eq (hc : c ≠ 0) : a * c = b → a = b / c :=
   hc.IsUnit.eq_div_of_mul_eq
 #align eq_div_of_mul_eq eq_div_of_mul_eq
 
-/- warning: div_eq_one_iff_eq -> div_eq_one_iff_eq is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Iff (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) (Eq.{succ u1} G₀ a b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a b) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (GroupWithZero.toDivisionMonoid.{u1} G₀ _inst_2))))))) (Eq.{succ u1} G₀ a b))
-Case conversion may be inaccurate. Consider using '#align div_eq_one_iff_eq div_eq_one_iff_eqₓ'. -/
 theorem div_eq_one_iff_eq (hb : b ≠ 0) : a / b = 1 ↔ a = b :=
   hb.IsUnit.div_eq_one_iff_eq
 #align div_eq_one_iff_eq div_eq_one_iff_eq
 
-/- warning: div_mul_left -> div_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) b (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a b)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))))) a))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) b (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a b)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (GroupWithZero.toDivisionMonoid.{u1} G₀ _inst_2)))))) a))
-Case conversion may be inaccurate. Consider using '#align div_mul_left div_mul_leftₓ'. -/
 theorem div_mul_left (hb : b ≠ 0) : b / (a * b) = 1 / a :=
   hb.IsUnit.div_mul_left
 #align div_mul_left div_mul_left
 
-/- warning: mul_div_mul_right -> mul_div_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {c : G₀} (a : G₀) (b : G₀), (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a c) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) b c)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {c : G₀} (a : G₀) (b : G₀), (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a c) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) b c)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a b))
-Case conversion may be inaccurate. Consider using '#align mul_div_mul_right mul_div_mul_rightₓ'. -/
 theorem mul_div_mul_right (a b : G₀) (hc : c ≠ 0) : a * c / (b * c) = a / b :=
   hc.IsUnit.mul_div_mul_right _ _
 #align mul_div_mul_right mul_div_mul_right
 
-/- warning: mul_mul_div -> mul_mul_div is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {b : G₀} (a : G₀), (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a b) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))))) b)))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {b : G₀} (a : G₀), (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a b) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (GroupWithZero.toDivisionMonoid.{u1} G₀ _inst_2)))))) b)))
-Case conversion may be inaccurate. Consider using '#align mul_mul_div mul_mul_divₓ'. -/
 theorem mul_mul_div (a : G₀) (hb : b ≠ 0) : a = a * b * (1 / b) :=
   (hb.IsUnit.mul_mul_div _).symm
 #align mul_mul_div mul_mul_div
 
-/- warning: div_div_div_cancel_right -> div_div_div_cancel_right is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {b : G₀} {c : G₀} (a : G₀), (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a c) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) b c)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {b : G₀} {c : G₀} (a : G₀), (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a c) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) b c)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a b))
-Case conversion may be inaccurate. Consider using '#align div_div_div_cancel_right div_div_div_cancel_rightₓ'. -/
 theorem div_div_div_cancel_right (a : G₀) (hc : c ≠ 0) : a / c / (b / c) = a / b := by
   rw [div_div_eq_mul_div, div_mul_cancel _ hc]
 #align div_div_div_cancel_right div_div_div_cancel_right
 
-/- warning: div_mul_div_cancel -> div_mul_div_cancel is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {b : G₀} {c : G₀} (a : G₀), (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a c) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) c b)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {b : G₀} {c : G₀} (a : G₀), (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a c) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) c b)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a b))
-Case conversion may be inaccurate. Consider using '#align div_mul_div_cancel div_mul_div_cancelₓ'. -/
 theorem div_mul_div_cancel (a : G₀) (hc : c ≠ 0) : a / c * (c / b) = a / b := by
   rw [← mul_div_assoc, div_mul_cancel _ hc]
 #align div_mul_div_cancel div_mul_div_cancel
 
-/- warning: div_mul_cancel_of_imp -> div_mul_cancel_of_imp is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, ((Eq.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b) b) a)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, ((Eq.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a b) b) a)
-Case conversion may be inaccurate. Consider using '#align div_mul_cancel_of_imp div_mul_cancel_of_impₓ'. -/
 theorem div_mul_cancel_of_imp {a b : G₀} (h : b = 0 → a = 0) : a / b * b = a :=
   by_cases (fun hb : b = 0 => by simp [*]) (div_mul_cancel a)
 #align div_mul_cancel_of_imp div_mul_cancel_of_imp
 
-/- warning: mul_div_cancel_of_imp -> mul_div_cancel_of_imp is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, ((Eq.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) -> (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a b) b) a)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, ((Eq.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) a b) b) a)
-Case conversion may be inaccurate. Consider using '#align mul_div_cancel_of_imp mul_div_cancel_of_impₓ'. -/
 theorem mul_div_cancel_of_imp {a b : G₀} (h : b = 0 → a = 0) : a * b / b = a :=
   by_cases (fun hb : b = 0 => by simp [*]) (mul_div_cancel a)
 #align mul_div_cancel_of_imp mul_div_cancel_of_imp
 
-/- warning: divp_mk0 -> divp_mk0 is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] (a : G₀) {b : G₀} (hb : Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))), Eq.{succ u1} G₀ (divp.{u1} G₀ (MonoidWithZero.toMonoid.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) a (Units.mk0.{u1} G₀ _inst_2 b hb)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] (a : G₀) {b : G₀} (hb : Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))), Eq.{succ u1} G₀ (divp.{u1} G₀ (MonoidWithZero.toMonoid.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) a (Units.mk0.{u1} G₀ _inst_2 b hb)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_2)) a b)
-Case conversion may be inaccurate. Consider using '#align divp_mk0 divp_mk0ₓ'. -/
 @[simp]
 theorem divp_mk0 (a : G₀) {b : G₀} (hb : b ≠ 0) : a /ₚ Units.mk0 b hb = a / b :=
   divp_eq_div _ _
@@ -332,114 +158,48 @@ section CommGroupWithZero
 -- comm
 variable [CommGroupWithZero G₀] {a b c d : G₀}
 
-/- warning: div_mul_right -> div_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} (b : G₀), (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) a b)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))))) b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} (b : G₀), (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) a (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) a b)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (DivisionCommMonoid.toDivisionMonoid.{u1} G₀ (CommGroupWithZero.toDivisionCommMonoid.{u1} G₀ _inst_2))))))) b))
-Case conversion may be inaccurate. Consider using '#align div_mul_right div_mul_rightₓ'. -/
 theorem div_mul_right (b : G₀) (ha : a ≠ 0) : a / (a * b) = 1 / b :=
   ha.IsUnit.div_mul_right _
 #align div_mul_right div_mul_right
 
-/- warning: mul_div_cancel_left_of_imp -> mul_div_cancel_left_of_imp is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, ((Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) a b) a) b)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, ((Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2)))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) a b) a) b)
-Case conversion may be inaccurate. Consider using '#align mul_div_cancel_left_of_imp mul_div_cancel_left_of_impₓ'. -/
 theorem mul_div_cancel_left_of_imp {a b : G₀} (h : a = 0 → b = 0) : a * b / a = b := by
   rw [mul_comm, mul_div_cancel_of_imp h]
 #align mul_div_cancel_left_of_imp mul_div_cancel_left_of_imp
 
-/- warning: mul_div_cancel_left -> mul_div_cancel_left is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} (b : G₀), (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) a b) a) b)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} (b : G₀), (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) a b) a) b)
-Case conversion may be inaccurate. Consider using '#align mul_div_cancel_left mul_div_cancel_leftₓ'. -/
 theorem mul_div_cancel_left (b : G₀) (ha : a ≠ 0) : a * b / a = b :=
   ha.IsUnit.mul_div_cancel_left _
 #align mul_div_cancel_left mul_div_cancel_left
 
-/- warning: mul_div_cancel_of_imp' -> mul_div_cancel_of_imp' is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, ((Eq.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) b (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) a b)) a)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, ((Eq.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2)))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) b (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) a b)) a)
-Case conversion may be inaccurate. Consider using '#align mul_div_cancel_of_imp' mul_div_cancel_of_imp'ₓ'. -/
 theorem mul_div_cancel_of_imp' {a b : G₀} (h : b = 0 → a = 0) : b * (a / b) = a := by
   rw [mul_comm, div_mul_cancel_of_imp h]
 #align mul_div_cancel_of_imp' mul_div_cancel_of_imp'
 
-/- warning: mul_div_cancel' -> mul_div_cancel' is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {b : G₀} (a : G₀), (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) b (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) a b)) a)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {b : G₀} (a : G₀), (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) b (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) a b)) a)
-Case conversion may be inaccurate. Consider using '#align mul_div_cancel' mul_div_cancel'ₓ'. -/
 theorem mul_div_cancel' (a : G₀) (hb : b ≠ 0) : b * (a / b) = a :=
   hb.IsUnit.mul_div_cancel'ₓ _
 #align mul_div_cancel' mul_div_cancel'
 
-/- warning: mul_div_mul_left -> mul_div_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {c : G₀} (a : G₀) (b : G₀), (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) c a) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) c b)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) a b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {c : G₀} (a : G₀) (b : G₀), (Ne.{succ u1} G₀ c (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) c a) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) c b)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) a b))
-Case conversion may be inaccurate. Consider using '#align mul_div_mul_left mul_div_mul_leftₓ'. -/
 theorem mul_div_mul_left (a b : G₀) (hc : c ≠ 0) : c * a / (c * b) = a / b :=
   hc.IsUnit.mul_div_mul_left _ _
 #align mul_div_mul_left mul_div_mul_left
 
-/- warning: mul_eq_mul_of_div_eq_div -> mul_eq_mul_of_div_eq_div is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] (a : G₀) {b : G₀} (c : G₀) {d : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Ne.{succ u1} G₀ d (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) a b) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) c d)) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) a d) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) c b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] (a : G₀) {b : G₀} (c : G₀) {d : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Ne.{succ u1} G₀ d (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) a b) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) c d)) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) a d) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) c b))
-Case conversion may be inaccurate. Consider using '#align mul_eq_mul_of_div_eq_div mul_eq_mul_of_div_eq_divₓ'. -/
 theorem mul_eq_mul_of_div_eq_div (a : G₀) {b : G₀} (c : G₀) {d : G₀} (hb : b ≠ 0) (hd : d ≠ 0)
     (h : a / b = c / d) : a * d = c * b := by
   rw [← mul_one a, ← div_self hb, ← mul_comm_div, h, div_mul_eq_mul_div, div_mul_cancel _ hd]
 #align mul_eq_mul_of_div_eq_div mul_eq_mul_of_div_eq_div
 
-/- warning: div_eq_div_iff -> div_eq_div_iff is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀} {d : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Ne.{succ u1} G₀ d (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Iff (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) a b) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) c d)) (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) a d) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) c b)))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} {b : G₀} {c : G₀} {d : G₀}, (Ne.{succ u1} G₀ b (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Ne.{succ u1} G₀ d (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Iff (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) a b) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) c d)) (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) a d) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) c b)))
-Case conversion may be inaccurate. Consider using '#align div_eq_div_iff div_eq_div_iffₓ'. -/
 @[field_simps]
 theorem div_eq_div_iff (hb : b ≠ 0) (hd : d ≠ 0) : a / b = c / d ↔ a * d = c * b :=
   hb.IsUnit.div_eq_div_iff hd.IsUnit
 #align div_eq_div_iff div_eq_div_iff
 
-/- warning: div_div_cancel' -> div_div_cancel' is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) a (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) a b)) b)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) a (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) a b)) b)
-Case conversion may be inaccurate. Consider using '#align div_div_cancel' div_div_cancel'ₓ'. -/
 theorem div_div_cancel' (ha : a ≠ 0) : a / (a / b) = b :=
   ha.IsUnit.div_div_cancel
 #align div_div_cancel' div_div_cancel'
 
-/- warning: div_div_cancel_left' -> div_div_cancel_left' is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) a b) a) (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))) b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) a b) a) (Inv.inv.{u1} G₀ (CommGroupWithZero.toInv.{u1} G₀ _inst_2) b))
-Case conversion may be inaccurate. Consider using '#align div_div_cancel_left' div_div_cancel_left'ₓ'. -/
 theorem div_div_cancel_left' (ha : a ≠ 0) : a / b / a = b⁻¹ :=
   ha.IsUnit.div_div_cancel_left
 #align div_div_cancel_left' div_div_cancel_left'
 
-/- warning: div_helper -> div_helper is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} (b : G₀), (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))))) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) a b)) a) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) (OfNat.ofNat.{u1} G₀ 1 (OfNat.mk.{u1} G₀ 1 (One.one.{u1} G₀ (MulOneClass.toHasOne.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))))) b))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} (b : G₀), (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (DivisionCommMonoid.toDivisionMonoid.{u1} G₀ (CommGroupWithZero.toDivisionCommMonoid.{u1} G₀ _inst_2))))))) (HMul.hMul.{u1, u1, u1} G₀ G₀ G₀ (instHMul.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))))) a b)) a) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) (OfNat.ofNat.{u1} G₀ 1 (One.toOfNat1.{u1} G₀ (InvOneClass.toOne.{u1} G₀ (DivInvOneMonoid.toInvOneClass.{u1} G₀ (DivisionMonoid.toDivInvOneMonoid.{u1} G₀ (DivisionCommMonoid.toDivisionMonoid.{u1} G₀ (CommGroupWithZero.toDivisionCommMonoid.{u1} G₀ _inst_2))))))) b))
-Case conversion may be inaccurate. Consider using '#align div_helper div_helperₓ'. -/
 theorem div_helper (b : G₀) (h : a ≠ 0) : 1 / (a * b) * a = 1 / b := by
   rw [div_mul_eq_mul_div, one_mul, div_mul_right _ h]
 #align div_helper div_helper
@@ -453,22 +213,10 @@ variable [GroupWithZero G₀] [Nontrivial M₀] [MonoidWithZero M₀'] [MonoidWi
 
 include M₀
 
-/- warning: map_ne_zero -> map_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {M₀ : Type.{u1}} {G₀ : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M₀] [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : Nontrivial.{u1} M₀] [_inst_5 : MonoidWithZeroHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Ne.{succ u1} M₀ (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => G₀ -> M₀) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F G₀ (fun (_x : G₀) => M₀) (MulHomClass.toFunLike.{u3, u2, u1} F G₀ M₀ (MulOneClass.toHasMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1) _inst_5)))) f a) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))))))) (Ne.{succ u2} G₀ a (OfNat.ofNat.{u2} G₀ 0 (OfNat.mk.{u2} G₀ 0 (Zero.zero.{u2} G₀ (MulZeroClass.toHasZero.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))))))))
-but is expected to have type
-  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Ne.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) _inst_1)))) (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
-Case conversion may be inaccurate. Consider using '#align map_ne_zero map_ne_zeroₓ'. -/
 theorem map_ne_zero : f a ≠ 0 ↔ a ≠ 0 :=
   ⟨fun hfa ha => hfa <| ha.symm ▸ map_zero f, fun ha => ((IsUnit.mk0 a ha).map f).NeZero⟩
 #align map_ne_zero map_ne_zero
 
-/- warning: map_eq_zero -> map_eq_zero is a dubious translation:
-lean 3 declaration is
-  forall {M₀ : Type.{u1}} {G₀ : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M₀] [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : Nontrivial.{u1} M₀] [_inst_5 : MonoidWithZeroHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Eq.{succ u1} M₀ (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => G₀ -> M₀) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F G₀ (fun (_x : G₀) => M₀) (MulHomClass.toFunLike.{u3, u2, u1} F G₀ M₀ (MulOneClass.toHasMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1) _inst_5)))) f a) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))))))) (Eq.{succ u2} G₀ a (OfNat.ofNat.{u2} G₀ 0 (OfNat.mk.{u2} G₀ 0 (Zero.zero.{u2} G₀ (MulZeroClass.toHasZero.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))))))))
-but is expected to have type
-  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) _inst_1)))) (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
-Case conversion may be inaccurate. Consider using '#align map_eq_zero map_eq_zeroₓ'. -/
 @[simp]
 theorem map_eq_zero : f a = 0 ↔ a = 0 :=
   not_iff_not.1 (map_ne_zero f)
@@ -478,12 +226,6 @@ omit M₀
 
 include M₀'
 
-/- warning: eq_on_inv₀ -> eq_on_inv₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} {M₀' : Type.{u2}} {F' : Type.{u3}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_4 : MonoidWithZero.{u2} M₀'] [_inst_6 : MonoidWithZeroHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)] {a : G₀} (f : F') (g : F'), (Eq.{succ u2} M₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) f a) (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) g a)) -> (Eq.{succ u2} M₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) f (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a)) (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) g (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a)))
-but is expected to have type
-  forall {G₀ : Type.{u1}} {M₀' : Type.{u3}} {F' : Type.{u2}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_4 : MonoidWithZero.{u3} M₀'] [_inst_6 : MonoidWithZeroHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)] {a : G₀} (f : F') (g : F'), (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀') a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g a)) -> (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀') (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)))
-Case conversion may be inaccurate. Consider using '#align eq_on_inv₀ eq_on_inv₀ₓ'. -/
 theorem eq_on_inv₀ (f g : F') (h : f a = g a) : f a⁻¹ = g a⁻¹ :=
   by
   rcases eq_or_ne a 0 with (rfl | ha)
@@ -499,12 +241,6 @@ variable [GroupWithZero G₀] [GroupWithZero G₀'] [MonoidWithZeroHomClass F G
 
 include G₀'
 
-/- warning: map_inv₀ -> map_inv₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} {G₀' : Type.{u2}} {F : Type.{u3}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : GroupWithZero.{u2} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))] (f : F) (a : G₀), Eq.{succ u2} G₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a)) (Inv.inv.{u2} G₀' (DivInvMonoid.toHasInv.{u2} G₀' (GroupWithZero.toDivInvMonoid.{u2} G₀' _inst_3)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f a))
-but is expected to have type
-  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (Inv.inv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') a) (GroupWithZero.toInv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') a) _inst_3) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a))
-Case conversion may be inaccurate. Consider using '#align map_inv₀ map_inv₀ₓ'. -/
 /-- A monoid homomorphism between groups with zeros sending `0` to `0` sends `a⁻¹` to `(f a)⁻¹`. -/
 @[simp]
 theorem map_inv₀ : f a⁻¹ = (f a)⁻¹ := by
@@ -513,12 +249,6 @@ theorem map_inv₀ : f a⁻¹ = (f a)⁻¹ := by
   rw [← map_mul, inv_mul_cancel h, map_one]
 #align map_inv₀ map_inv₀
 
-/- warning: map_div₀ -> map_div₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} {G₀' : Type.{u2}} {F : Type.{u3}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : GroupWithZero.{u2} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))] (f : F) (a : G₀) (b : G₀), Eq.{succ u2} G₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b)) (HDiv.hDiv.{u2, u2, u2} G₀' G₀' G₀' (instHDiv.{u2} G₀' (DivInvMonoid.toHasDiv.{u2} G₀' (GroupWithZero.toDivInvMonoid.{u2} G₀' _inst_3))) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f a) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f b))
-but is expected to have type
-  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀) (b : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (HDiv.hDiv.{u3, u3, u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') a) (instHDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') a) (GroupWithZero.toDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') a) _inst_3)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f b))
-Case conversion may be inaccurate. Consider using '#align map_div₀ map_div₀ₓ'. -/
 @[simp]
 theorem map_div₀ : f (a / b) = f a / f b :=
   map_div' f (map_inv₀ f) a b
@@ -538,24 +268,12 @@ noncomputable def MonoidWithZero.inverse {M : Type _} [CommMonoidWithZero M] : M
 #align monoid_with_zero.inverse MonoidWithZero.inverse
 -/
 
-/- warning: monoid_with_zero.coe_inverse -> MonoidWithZero.coe_inverse is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M], Eq.{succ u1} ((fun (_x : MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) => M -> M) (MonoidWithZero.inverse.{u1} M _inst_2)) (coeFn.{succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (fun (_x : MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) => M -> M) (MonoidWithZeroHom.hasCoeToFun.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZero.inverse.{u1} M _inst_2)) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M], Eq.{succ u1} (forall (a : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2)) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))
-Case conversion may be inaccurate. Consider using '#align monoid_with_zero.coe_inverse MonoidWithZero.coe_inverseₓ'. -/
 @[simp]
 theorem MonoidWithZero.coe_inverse {M : Type _} [CommMonoidWithZero M] :
     (MonoidWithZero.inverse : M → M) = Ring.inverse :=
   rfl
 #align monoid_with_zero.coe_inverse MonoidWithZero.coe_inverse
 
-/- warning: monoid_with_zero.inverse_apply -> MonoidWithZero.inverse_apply is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M] (a : M), Eq.{succ u1} M (coeFn.{succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (fun (_x : MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) => M -> M) (MonoidWithZeroHom.hasCoeToFun.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZero.inverse.{u1} M _inst_2) a) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2) a)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M] (a : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2) a) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2) a)
-Case conversion may be inaccurate. Consider using '#align monoid_with_zero.inverse_apply MonoidWithZero.inverse_applyₓ'. -/
 @[simp]
 theorem MonoidWithZero.inverse_apply {M : Type _} [CommMonoidWithZero M] (a : M) :
     MonoidWithZero.inverse a = Ring.inverse a :=
@@ -575,12 +293,6 @@ variable [GroupWithZero G₀]
 
 variable {a b : G₀}
 
-/- warning: units.smul_mk0 -> Units.smul_mk0 is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {α : Type.{u2}} [_inst_3 : SMul.{u1, u2} G₀ α] {g : G₀} (hg : Ne.{succ u1} G₀ g (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))))) (a : α), Eq.{succ u2} α (SMul.smul.{u1, u2} (Units.{u1} G₀ (MonoidWithZero.toMonoid.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) α (Units.hasSmul.{u1, u2} G₀ α (MonoidWithZero.toMonoid.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) _inst_3) (Units.mk0.{u1} G₀ _inst_2 g hg) a) (SMul.smul.{u1, u2} G₀ α _inst_3 g a)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_2 : GroupWithZero.{u1} G₀] {α : Type.{u2}} [_inst_3 : SMul.{u1, u2} G₀ α] {g : G₀} (hg : Ne.{succ u1} G₀ g (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))))) (a : α), Eq.{succ u2} α (HSMul.hSMul.{u1, u2, u2} (Units.{u1} G₀ (MonoidWithZero.toMonoid.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) α α (instHSMul.{u1, u2} (Units.{u1} G₀ (MonoidWithZero.toMonoid.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) α (Units.instSMulUnits.{u1, u2} G₀ α (MonoidWithZero.toMonoid.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) _inst_3)) (Units.mk0.{u1} G₀ _inst_2 g hg) a) (HSMul.hSMul.{u1, u2, u2} G₀ α α (instHSMul.{u1, u2} G₀ α _inst_3) g a)
-Case conversion may be inaccurate. Consider using '#align units.smul_mk0 Units.smul_mk0ₓ'. -/
 @[simp]
 theorem smul_mk0 {α : Type _} [SMul G₀ α] {g : G₀} (hg : g ≠ 0) (a : α) : mk0 g hg • a = g • a :=
   rfl

dc6c365e

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -457,7 +457,7 @@ include M₀
 lean 3 declaration is
   forall {M₀ : Type.{u1}} {G₀ : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M₀] [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : Nontrivial.{u1} M₀] [_inst_5 : MonoidWithZeroHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Ne.{succ u1} M₀ (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => G₀ -> M₀) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F G₀ (fun (_x : G₀) => M₀) (MulHomClass.toFunLike.{u3, u2, u1} F G₀ M₀ (MulOneClass.toHasMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1) _inst_5)))) f a) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))))))) (Ne.{succ u2} G₀ a (OfNat.ofNat.{u2} G₀ 0 (OfNat.mk.{u2} G₀ 0 (Zero.zero.{u2} G₀ (MulZeroClass.toHasZero.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))))))))
 but is expected to have type
-  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Ne.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) _inst_1)))) (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
+  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Ne.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) _inst_1)))) (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
 Case conversion may be inaccurate. Consider using '#align map_ne_zero map_ne_zeroₓ'. -/
 theorem map_ne_zero : f a ≠ 0 ↔ a ≠ 0 :=
   ⟨fun hfa ha => hfa <| ha.symm ▸ map_zero f, fun ha => ((IsUnit.mk0 a ha).map f).NeZero⟩
@@ -467,7 +467,7 @@ theorem map_ne_zero : f a ≠ 0 ↔ a ≠ 0 :=
 lean 3 declaration is
   forall {M₀ : Type.{u1}} {G₀ : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M₀] [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : Nontrivial.{u1} M₀] [_inst_5 : MonoidWithZeroHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Eq.{succ u1} M₀ (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => G₀ -> M₀) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F G₀ (fun (_x : G₀) => M₀) (MulHomClass.toFunLike.{u3, u2, u1} F G₀ M₀ (MulOneClass.toHasMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1) _inst_5)))) f a) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))))))) (Eq.{succ u2} G₀ a (OfNat.ofNat.{u2} G₀ 0 (OfNat.mk.{u2} G₀ 0 (Zero.zero.{u2} G₀ (MulZeroClass.toHasZero.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))))))))
 but is expected to have type
-  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) _inst_1)))) (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
+  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀) a) _inst_1)))) (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
 Case conversion may be inaccurate. Consider using '#align map_eq_zero map_eq_zeroₓ'. -/
 @[simp]
 theorem map_eq_zero : f a = 0 ↔ a = 0 :=
@@ -482,7 +482,7 @@ include M₀'
 lean 3 declaration is
   forall {G₀ : Type.{u1}} {M₀' : Type.{u2}} {F' : Type.{u3}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_4 : MonoidWithZero.{u2} M₀'] [_inst_6 : MonoidWithZeroHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)] {a : G₀} (f : F') (g : F'), (Eq.{succ u2} M₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) f a) (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) g a)) -> (Eq.{succ u2} M₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) f (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a)) (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) g (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a)))
 but is expected to have type
-  forall {G₀ : Type.{u1}} {M₀' : Type.{u3}} {F' : Type.{u2}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_4 : MonoidWithZero.{u3} M₀'] [_inst_6 : MonoidWithZeroHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)] {a : G₀} (f : F') (g : F'), (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀') a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g a)) -> (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀') (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)))
+  forall {G₀ : Type.{u1}} {M₀' : Type.{u3}} {F' : Type.{u2}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_4 : MonoidWithZero.{u3} M₀'] [_inst_6 : MonoidWithZeroHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)] {a : G₀} (f : F') (g : F'), (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀') a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g a)) -> (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀') (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)))
 Case conversion may be inaccurate. Consider using '#align eq_on_inv₀ eq_on_inv₀ₓ'. -/
 theorem eq_on_inv₀ (f g : F') (h : f a = g a) : f a⁻¹ = g a⁻¹ :=
   by
@@ -503,7 +503,7 @@ include G₀'
 lean 3 declaration is
   forall {G₀ : Type.{u1}} {G₀' : Type.{u2}} {F : Type.{u3}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : GroupWithZero.{u2} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))] (f : F) (a : G₀), Eq.{succ u2} G₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a)) (Inv.inv.{u2} G₀' (DivInvMonoid.toHasInv.{u2} G₀' (GroupWithZero.toDivInvMonoid.{u2} G₀' _inst_3)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f a))
 but is expected to have type
-  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (Inv.inv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') a) (GroupWithZero.toInv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') a) _inst_3) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a))
+  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (Inv.inv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') a) (GroupWithZero.toInv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') a) _inst_3) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a))
 Case conversion may be inaccurate. Consider using '#align map_inv₀ map_inv₀ₓ'. -/
 /-- A monoid homomorphism between groups with zeros sending `0` to `0` sends `a⁻¹` to `(f a)⁻¹`. -/
 @[simp]
@@ -517,7 +517,7 @@ theorem map_inv₀ : f a⁻¹ = (f a)⁻¹ := by
 lean 3 declaration is
   forall {G₀ : Type.{u1}} {G₀' : Type.{u2}} {F : Type.{u3}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : GroupWithZero.{u2} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))] (f : F) (a : G₀) (b : G₀), Eq.{succ u2} G₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b)) (HDiv.hDiv.{u2, u2, u2} G₀' G₀' G₀' (instHDiv.{u2} G₀' (DivInvMonoid.toHasDiv.{u2} G₀' (GroupWithZero.toDivInvMonoid.{u2} G₀' _inst_3))) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f a) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f b))
 but is expected to have type
-  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀) (b : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (HDiv.hDiv.{u3, u3, u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') a) (instHDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') a) (GroupWithZero.toDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') a) _inst_3)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f b))
+  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀) (b : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (HDiv.hDiv.{u3, u3, u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') a) (instHDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') a) (GroupWithZero.toDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') a) _inst_3)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f b))
 Case conversion may be inaccurate. Consider using '#align map_div₀ map_div₀ₓ'. -/
 @[simp]
 theorem map_div₀ : f (a / b) = f a / f b :=
@@ -542,7 +542,7 @@ noncomputable def MonoidWithZero.inverse {M : Type _} [CommMonoidWithZero M] : M
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M], Eq.{succ u1} ((fun (_x : MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) => M -> M) (MonoidWithZero.inverse.{u1} M _inst_2)) (coeFn.{succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (fun (_x : MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) => M -> M) (MonoidWithZeroHom.hasCoeToFun.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZero.inverse.{u1} M _inst_2)) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M], Eq.{succ u1} (forall (a : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2)) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M], Eq.{succ u1} (forall (a : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2)) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align monoid_with_zero.coe_inverse MonoidWithZero.coe_inverseₓ'. -/
 @[simp]
 theorem MonoidWithZero.coe_inverse {M : Type _} [CommMonoidWithZero M] :
@@ -554,7 +554,7 @@ theorem MonoidWithZero.coe_inverse {M : Type _} [CommMonoidWithZero M] :
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M] (a : M), Eq.{succ u1} M (coeFn.{succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (fun (_x : MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) => M -> M) (MonoidWithZeroHom.hasCoeToFun.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZero.inverse.{u1} M _inst_2) a) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2) a)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M] (a : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2) a) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2) a)
+  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M] (a : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2) a) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2) a)
 Case conversion may be inaccurate. Consider using '#align monoid_with_zero.inverse_apply MonoidWithZero.inverse_applyₓ'. -/
 @[simp]
 theorem MonoidWithZero.inverse_apply {M : Type _} [CommMonoidWithZero M] (a : M) :

dc6c365e

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -457,7 +457,7 @@ include M₀
 lean 3 declaration is
   forall {M₀ : Type.{u1}} {G₀ : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M₀] [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : Nontrivial.{u1} M₀] [_inst_5 : MonoidWithZeroHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Ne.{succ u1} M₀ (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => G₀ -> M₀) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F G₀ (fun (_x : G₀) => M₀) (MulHomClass.toFunLike.{u3, u2, u1} F G₀ M₀ (MulOneClass.toHasMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1) _inst_5)))) f a) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))))))) (Ne.{succ u2} G₀ a (OfNat.ofNat.{u2} G₀ 0 (OfNat.mk.{u2} G₀ 0 (Zero.zero.{u2} G₀ (MulZeroClass.toHasZero.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))))))))
 but is expected to have type
-  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Ne.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) _inst_1)))) (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
+  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Ne.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) _inst_1)))) (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
 Case conversion may be inaccurate. Consider using '#align map_ne_zero map_ne_zeroₓ'. -/
 theorem map_ne_zero : f a ≠ 0 ↔ a ≠ 0 :=
   ⟨fun hfa ha => hfa <| ha.symm ▸ map_zero f, fun ha => ((IsUnit.mk0 a ha).map f).NeZero⟩
@@ -467,7 +467,7 @@ theorem map_ne_zero : f a ≠ 0 ↔ a ≠ 0 :=
 lean 3 declaration is
   forall {M₀ : Type.{u1}} {G₀ : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M₀] [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : Nontrivial.{u1} M₀] [_inst_5 : MonoidWithZeroHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Eq.{succ u1} M₀ (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => G₀ -> M₀) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F G₀ (fun (_x : G₀) => M₀) (MulHomClass.toFunLike.{u3, u2, u1} F G₀ M₀ (MulOneClass.toHasMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1) _inst_5)))) f a) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))))))) (Eq.{succ u2} G₀ a (OfNat.ofNat.{u2} G₀ 0 (OfNat.mk.{u2} G₀ 0 (Zero.zero.{u2} G₀ (MulZeroClass.toHasZero.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))))))))
 but is expected to have type
-  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) _inst_1)))) (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
+  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀) a) _inst_1)))) (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
 Case conversion may be inaccurate. Consider using '#align map_eq_zero map_eq_zeroₓ'. -/
 @[simp]
 theorem map_eq_zero : f a = 0 ↔ a = 0 :=
@@ -482,7 +482,7 @@ include M₀'
 lean 3 declaration is
   forall {G₀ : Type.{u1}} {M₀' : Type.{u2}} {F' : Type.{u3}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_4 : MonoidWithZero.{u2} M₀'] [_inst_6 : MonoidWithZeroHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)] {a : G₀} (f : F') (g : F'), (Eq.{succ u2} M₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) f a) (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) g a)) -> (Eq.{succ u2} M₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) f (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a)) (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) g (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a)))
 but is expected to have type
-  forall {G₀ : Type.{u1}} {M₀' : Type.{u3}} {F' : Type.{u2}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_4 : MonoidWithZero.{u3} M₀'] [_inst_6 : MonoidWithZeroHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)] {a : G₀} (f : F') (g : F'), (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀') a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g a)) -> (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀') (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)))
+  forall {G₀ : Type.{u1}} {M₀' : Type.{u3}} {F' : Type.{u2}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_4 : MonoidWithZero.{u3} M₀'] [_inst_6 : MonoidWithZeroHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)] {a : G₀} (f : F') (g : F'), (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀') a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g a)) -> (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀') (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)))
 Case conversion may be inaccurate. Consider using '#align eq_on_inv₀ eq_on_inv₀ₓ'. -/
 theorem eq_on_inv₀ (f g : F') (h : f a = g a) : f a⁻¹ = g a⁻¹ :=
   by
@@ -503,7 +503,7 @@ include G₀'
 lean 3 declaration is
   forall {G₀ : Type.{u1}} {G₀' : Type.{u2}} {F : Type.{u3}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : GroupWithZero.{u2} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))] (f : F) (a : G₀), Eq.{succ u2} G₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a)) (Inv.inv.{u2} G₀' (DivInvMonoid.toHasInv.{u2} G₀' (GroupWithZero.toDivInvMonoid.{u2} G₀' _inst_3)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f a))
 but is expected to have type
-  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (Inv.inv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') a) (GroupWithZero.toInv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') a) _inst_3) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a))
+  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (Inv.inv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') a) (GroupWithZero.toInv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') a) _inst_3) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a))
 Case conversion may be inaccurate. Consider using '#align map_inv₀ map_inv₀ₓ'. -/
 /-- A monoid homomorphism between groups with zeros sending `0` to `0` sends `a⁻¹` to `(f a)⁻¹`. -/
 @[simp]
@@ -517,7 +517,7 @@ theorem map_inv₀ : f a⁻¹ = (f a)⁻¹ := by
 lean 3 declaration is
   forall {G₀ : Type.{u1}} {G₀' : Type.{u2}} {F : Type.{u3}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : GroupWithZero.{u2} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))] (f : F) (a : G₀) (b : G₀), Eq.{succ u2} G₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b)) (HDiv.hDiv.{u2, u2, u2} G₀' G₀' G₀' (instHDiv.{u2} G₀' (DivInvMonoid.toHasDiv.{u2} G₀' (GroupWithZero.toDivInvMonoid.{u2} G₀' _inst_3))) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f a) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f b))
 but is expected to have type
-  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀) (b : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (HDiv.hDiv.{u3, u3, u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') a) (instHDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') a) (GroupWithZero.toDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') a) _inst_3)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f b))
+  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀) (b : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (HDiv.hDiv.{u3, u3, u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') a) (instHDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') a) (GroupWithZero.toDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') a) _inst_3)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f b))
 Case conversion may be inaccurate. Consider using '#align map_div₀ map_div₀ₓ'. -/
 @[simp]
 theorem map_div₀ : f (a / b) = f a / f b :=
@@ -542,7 +542,7 @@ noncomputable def MonoidWithZero.inverse {M : Type _} [CommMonoidWithZero M] : M
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M], Eq.{succ u1} ((fun (_x : MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) => M -> M) (MonoidWithZero.inverse.{u1} M _inst_2)) (coeFn.{succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (fun (_x : MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) => M -> M) (MonoidWithZeroHom.hasCoeToFun.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZero.inverse.{u1} M _inst_2)) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M], Eq.{succ u1} (forall (a : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2)) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M], Eq.{succ u1} (forall (a : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2)) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align monoid_with_zero.coe_inverse MonoidWithZero.coe_inverseₓ'. -/
 @[simp]
 theorem MonoidWithZero.coe_inverse {M : Type _} [CommMonoidWithZero M] :
@@ -554,7 +554,7 @@ theorem MonoidWithZero.coe_inverse {M : Type _} [CommMonoidWithZero M] :
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M] (a : M), Eq.{succ u1} M (coeFn.{succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (fun (_x : MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) => M -> M) (MonoidWithZeroHom.hasCoeToFun.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZero.inverse.{u1} M _inst_2) a) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2) a)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M] (a : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2) a) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2) a)
+  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M] (a : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2) a) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2) a)
 Case conversion may be inaccurate. Consider using '#align monoid_with_zero.inverse_apply MonoidWithZero.inverse_applyₓ'. -/
 @[simp]
 theorem MonoidWithZero.inverse_apply {M : Type _} [CommMonoidWithZero M] (a : M) :

dc6c365e

bump to nightly-2023-03-08-18

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

10f15343

Diff

@@ -457,7 +457,7 @@ include M₀
 lean 3 declaration is
   forall {M₀ : Type.{u1}} {G₀ : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M₀] [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : Nontrivial.{u1} M₀] [_inst_5 : MonoidWithZeroHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Ne.{succ u1} M₀ (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => G₀ -> M₀) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F G₀ (fun (_x : G₀) => M₀) (MulHomClass.toFunLike.{u3, u2, u1} F G₀ M₀ (MulOneClass.toHasMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1) _inst_5)))) f a) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))))))) (Ne.{succ u2} G₀ a (OfNat.ofNat.{u2} G₀ 0 (OfNat.mk.{u2} G₀ 0 (Zero.zero.{u2} G₀ (MulZeroClass.toHasZero.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))))))))
 but is expected to have type
-  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Ne.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀) a) _inst_1)))) (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
+  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Ne.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) _inst_1)))) (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
 Case conversion may be inaccurate. Consider using '#align map_ne_zero map_ne_zeroₓ'. -/
 theorem map_ne_zero : f a ≠ 0 ↔ a ≠ 0 :=
   ⟨fun hfa ha => hfa <| ha.symm ▸ map_zero f, fun ha => ((IsUnit.mk0 a ha).map f).NeZero⟩
@@ -467,7 +467,7 @@ theorem map_ne_zero : f a ≠ 0 ↔ a ≠ 0 :=
 lean 3 declaration is
   forall {M₀ : Type.{u1}} {G₀ : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M₀] [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : Nontrivial.{u1} M₀] [_inst_5 : MonoidWithZeroHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Eq.{succ u1} M₀ (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => G₀ -> M₀) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F G₀ (fun (_x : G₀) => M₀) (MulHomClass.toFunLike.{u3, u2, u1} F G₀ M₀ (MulOneClass.toHasMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u2, u1} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1) _inst_5)))) f a) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))))))) (Eq.{succ u2} G₀ a (OfNat.ofNat.{u2} G₀ 0 (OfNat.mk.{u2} G₀ 0 (Zero.zero.{u2} G₀ (MulZeroClass.toHasZero.{u2} G₀ (MulZeroOneClass.toMulZeroClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))))))))
 but is expected to have type
-  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀) a) _inst_1)))) (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
+  forall {M₀ : Type.{u3}} {G₀ : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M₀] [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : Nontrivial.{u3} M₀] [_inst_5 : MonoidWithZeroHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)] (f : F) {a : G₀}, Iff (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) (FunLike.coe.{succ u2, succ u1, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) _x) (MulHomClass.toFunLike.{u2, u1, u3} F G₀ M₀ (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀ (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F G₀ M₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀ (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F G₀ M₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀ _inst_1) _inst_5))) f a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀) a) _inst_1)))) (Eq.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MonoidWithZero.toZero.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))))
 Case conversion may be inaccurate. Consider using '#align map_eq_zero map_eq_zeroₓ'. -/
 @[simp]
 theorem map_eq_zero : f a = 0 ↔ a = 0 :=
@@ -482,7 +482,7 @@ include M₀'
 lean 3 declaration is
   forall {G₀ : Type.{u1}} {M₀' : Type.{u2}} {F' : Type.{u3}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_4 : MonoidWithZero.{u2} M₀'] [_inst_6 : MonoidWithZeroHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)] {a : G₀} (f : F') (g : F'), (Eq.{succ u2} M₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) f a) (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) g a)) -> (Eq.{succ u2} M₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) f (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a)) (coeFn.{succ u3, max (succ u1) (succ u2)} F' (fun (_x : F') => G₀ -> M₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F' G₀ (fun (_x : G₀) => M₀') (MulHomClass.toFunLike.{u3, u1, u2} F' G₀ M₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} M₀' (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} M₀' (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} M₀' _inst_4) _inst_6)))) g (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a)))
 but is expected to have type
-  forall {G₀ : Type.{u1}} {M₀' : Type.{u3}} {F' : Type.{u2}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_4 : MonoidWithZero.{u3} M₀'] [_inst_6 : MonoidWithZeroHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)] {a : G₀} (f : F') (g : F'), (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀') a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g a)) -> (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀') (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)))
+  forall {G₀ : Type.{u1}} {M₀' : Type.{u3}} {F' : Type.{u2}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_4 : MonoidWithZero.{u3} M₀'] [_inst_6 : MonoidWithZeroHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)] {a : G₀} (f : F') (g : F'), (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀') a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f a) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g a)) -> (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀') (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) f (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)) (FunLike.coe.{succ u2, succ u1, succ u3} F' G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => M₀') _x) (MulHomClass.toFunLike.{u2, u1, u3} F' G₀ M₀' (MulOneClass.toMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toMul.{u3} M₀' (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F' G₀ M₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} M₀' (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F' G₀ M₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} M₀' _inst_4) _inst_6))) g (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_2) a)))
 Case conversion may be inaccurate. Consider using '#align eq_on_inv₀ eq_on_inv₀ₓ'. -/
 theorem eq_on_inv₀ (f g : F') (h : f a = g a) : f a⁻¹ = g a⁻¹ :=
   by
@@ -503,7 +503,7 @@ include G₀'
 lean 3 declaration is
   forall {G₀ : Type.{u1}} {G₀' : Type.{u2}} {F : Type.{u3}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : GroupWithZero.{u2} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))] (f : F) (a : G₀), Eq.{succ u2} G₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2)) a)) (Inv.inv.{u2} G₀' (DivInvMonoid.toHasInv.{u2} G₀' (GroupWithZero.toDivInvMonoid.{u2} G₀' _inst_3)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f a))
 but is expected to have type
-  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (Inv.inv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') a) (GroupWithZero.toInv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') a) _inst_3) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a))
+  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (Inv.inv.{u2} G₀ (GroupWithZero.toInv.{u2} G₀ _inst_2) a)) (Inv.inv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') a) (GroupWithZero.toInv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') a) _inst_3) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a))
 Case conversion may be inaccurate. Consider using '#align map_inv₀ map_inv₀ₓ'. -/
 /-- A monoid homomorphism between groups with zeros sending `0` to `0` sends `a⁻¹` to `(f a)⁻¹`. -/
 @[simp]
@@ -517,7 +517,7 @@ theorem map_inv₀ : f a⁻¹ = (f a)⁻¹ := by
 lean 3 declaration is
   forall {G₀ : Type.{u1}} {G₀' : Type.{u2}} {F : Type.{u3}} [_inst_2 : GroupWithZero.{u1} G₀] [_inst_3 : GroupWithZero.{u2} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))] (f : F) (a : G₀) (b : G₀), Eq.{succ u2} G₀' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_2))) a b)) (HDiv.hDiv.{u2, u2, u2} G₀' G₀' G₀' (instHDiv.{u2} G₀' (DivInvMonoid.toHasDiv.{u2} G₀' (GroupWithZero.toDivInvMonoid.{u2} G₀' _inst_3))) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f a) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => G₀ -> G₀') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F G₀ (fun (_x : G₀) => G₀') (MulHomClass.toFunLike.{u3, u1, u2} F G₀ G₀' (MulOneClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)))) (MulOneClass.toHasMul.{u2} G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u2} G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u2} G₀' (GroupWithZero.toMonoidWithZero.{u2} G₀' _inst_3)) _inst_4)))) f b))
 but is expected to have type
-  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀) (b : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (HDiv.hDiv.{u3, u3, u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') a) (instHDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') a) (GroupWithZero.toDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') a) _inst_3)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f b))
+  forall {G₀ : Type.{u2}} {G₀' : Type.{u3}} {F : Type.{u1}} [_inst_2 : GroupWithZero.{u2} G₀] [_inst_3 : GroupWithZero.{u3} G₀'] [_inst_4 : MonoidWithZeroHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))] (f : F) (a : G₀) (b : G₀), Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f (HDiv.hDiv.{u2, u2, u2} G₀ G₀ G₀ (instHDiv.{u2} G₀ (GroupWithZero.toDiv.{u2} G₀ _inst_2)) a b)) (HDiv.hDiv.{u3, u3, u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') a) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') b) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') a) (instHDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') a) (GroupWithZero.toDiv.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') a) _inst_3)) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f a) (FunLike.coe.{succ u1, succ u2, succ u3} F G₀ (fun (_x : G₀) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G₀) => G₀') _x) (MulHomClass.toFunLike.{u1, u2, u3} F G₀ G₀' (MulOneClass.toMul.{u2} G₀ (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)))) (MulOneClass.toMul.{u3} G₀' (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F G₀ G₀' (MulZeroOneClass.toMulOneClass.{u2} G₀ (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2))) (MulZeroOneClass.toMulOneClass.{u3} G₀' (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u2, u3} F G₀ G₀' (MonoidWithZero.toMulZeroOneClass.{u2} G₀ (GroupWithZero.toMonoidWithZero.{u2} G₀ _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u3} G₀' (GroupWithZero.toMonoidWithZero.{u3} G₀' _inst_3)) _inst_4))) f b))
 Case conversion may be inaccurate. Consider using '#align map_div₀ map_div₀ₓ'. -/
 @[simp]
 theorem map_div₀ : f (a / b) = f a / f b :=
@@ -542,7 +542,7 @@ noncomputable def MonoidWithZero.inverse {M : Type _} [CommMonoidWithZero M] : M
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M], Eq.{succ u1} ((fun (_x : MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) => M -> M) (MonoidWithZero.inverse.{u1} M _inst_2)) (coeFn.{succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (fun (_x : MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) => M -> M) (MonoidWithZeroHom.hasCoeToFun.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZero.inverse.{u1} M _inst_2)) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M], Eq.{succ u1} (forall (a : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2)) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))
+  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M], Eq.{succ u1} (forall (a : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2)) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))
 Case conversion may be inaccurate. Consider using '#align monoid_with_zero.coe_inverse MonoidWithZero.coe_inverseₓ'. -/
 @[simp]
 theorem MonoidWithZero.coe_inverse {M : Type _} [CommMonoidWithZero M] :
@@ -554,7 +554,7 @@ theorem MonoidWithZero.coe_inverse {M : Type _} [CommMonoidWithZero M] :
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M] (a : M), Eq.{succ u1} M (coeFn.{succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (fun (_x : MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) => M -> M) (MonoidWithZeroHom.hasCoeToFun.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZero.inverse.{u1} M _inst_2) a) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2) a)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M] (a : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2) a) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2) a)
+  forall {M : Type.{u1}} [_inst_2 : CommMonoidWithZero.{u1} M] (a : M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) (MonoidWithZeroHomClass.toMonoidHomClass.{u1, u1, u1} (MonoidWithZeroHom.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2))) M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZeroHom.monoidWithZeroHomClass.{u1, u1} M M (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)) (MonoidWithZero.toMulZeroOneClass.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2)))))) (MonoidWithZero.inverse.{u1} M _inst_2) a) (Ring.inverse.{u1} M (CommMonoidWithZero.toMonoidWithZero.{u1} M _inst_2) a)
 Case conversion may be inaccurate. Consider using '#align monoid_with_zero.inverse_apply MonoidWithZero.inverse_applyₓ'. -/
 @[simp]
 theorem MonoidWithZero.inverse_apply {M : Type _} [CommMonoidWithZero M] (a : M) :

dc6c365e

bump to nightly-2023-02-28-18

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

15328211

Diff

@@ -424,6 +424,12 @@ theorem div_div_cancel' (ha : a ≠ 0) : a / (a / b) = b :=
   ha.IsUnit.div_div_cancel
 #align div_div_cancel' div_div_cancel'
 
+/- warning: div_div_cancel_left' -> div_div_cancel_left' is a dubious translation:
+lean 3 declaration is
+  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))))))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2)))) a b) a) (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ (CommGroupWithZero.toGroupWithZero.{u1} G₀ _inst_2))) b))
+but is expected to have type
+  forall {G₀ : Type.{u1}} [_inst_2 : CommGroupWithZero.{u1} G₀] {a : G₀} {b : G₀}, (Ne.{succ u1} G₀ a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (CommMonoidWithZero.toZero.{u1} G₀ (CommGroupWithZero.toCommMonoidWithZero.{u1} G₀ _inst_2))))) -> (Eq.{succ u1} G₀ (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (CommGroupWithZero.toDiv.{u1} G₀ _inst_2)) a b) a) (Inv.inv.{u1} G₀ (CommGroupWithZero.toInv.{u1} G₀ _inst_2) b))
+Case conversion may be inaccurate. Consider using '#align div_div_cancel_left' div_div_cancel_left'ₓ'. -/
 theorem div_div_cancel_left' (ha : a ≠ 0) : a / b / a = b⁻¹ :=
   ha.IsUnit.div_div_cancel_left
 #align div_div_cancel_left' div_div_cancel_left'

dc6c365e

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

dc6c365e

chore: Move GroupWithZero lemmas earlier (#10919)

Move from Algebra.GroupWithZero.Units.Lemmas to Algebra.GroupWithZero.Units.Basic the lemmas that can be moved.

8ff9aa61

Diff

@@ -3,11 +3,9 @@ Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathlib.Algebra.Group.Commute.Units
 import Mathlib.Algebra.Group.Units.Hom
 import Mathlib.Algebra.GroupWithZero.Commute
 import Mathlib.Algebra.GroupWithZero.Hom
-import Mathlib.Algebra.GroupWithZero.Units.Basic
 import Mathlib.GroupTheory.GroupAction.Units
 
 #align_import algebra.group_with_zero.units.lemmas from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
@@ -21,218 +19,14 @@ import Mathlib.GroupTheory.GroupAction.Units
 variable {α M₀ G₀ M₀' G₀' F F' : Type*}
 variable [MonoidWithZero M₀]
 
-section GroupWithZero
-
-variable [GroupWithZero G₀] {a b c d : G₀}
-
-@[simp]
-theorem div_self (h : a ≠ 0) : a / a = 1 :=
-  IsUnit.div_self h.isUnit
-#align div_self div_self
-
-theorem eq_mul_inv_iff_mul_eq₀ (hc : c ≠ 0) : a = b * c⁻¹ ↔ a * c = b :=
-  IsUnit.eq_mul_inv_iff_mul_eq hc.isUnit
-#align eq_mul_inv_iff_mul_eq₀ eq_mul_inv_iff_mul_eq₀
-
-theorem eq_inv_mul_iff_mul_eq₀ (hb : b ≠ 0) : a = b⁻¹ * c ↔ b * a = c :=
-  IsUnit.eq_inv_mul_iff_mul_eq hb.isUnit
-#align eq_inv_mul_iff_mul_eq₀ eq_inv_mul_iff_mul_eq₀
-
-theorem inv_mul_eq_iff_eq_mul₀ (ha : a ≠ 0) : a⁻¹ * b = c ↔ b = a * c :=
-  IsUnit.inv_mul_eq_iff_eq_mul ha.isUnit
-#align inv_mul_eq_iff_eq_mul₀ inv_mul_eq_iff_eq_mul₀
-
-theorem mul_inv_eq_iff_eq_mul₀ (hb : b ≠ 0) : a * b⁻¹ = c ↔ a = c * b :=
-  IsUnit.mul_inv_eq_iff_eq_mul hb.isUnit
-#align mul_inv_eq_iff_eq_mul₀ mul_inv_eq_iff_eq_mul₀
-
-theorem mul_inv_eq_one₀ (hb : b ≠ 0) : a * b⁻¹ = 1 ↔ a = b :=
-  IsUnit.mul_inv_eq_one hb.isUnit
-#align mul_inv_eq_one₀ mul_inv_eq_one₀
-
-theorem inv_mul_eq_one₀ (ha : a ≠ 0) : a⁻¹ * b = 1 ↔ a = b :=
-  IsUnit.inv_mul_eq_one ha.isUnit
-#align inv_mul_eq_one₀ inv_mul_eq_one₀
-
-theorem mul_eq_one_iff_eq_inv₀ (hb : b ≠ 0) : a * b = 1 ↔ a = b⁻¹ :=
-  IsUnit.mul_eq_one_iff_eq_inv hb.isUnit
-#align mul_eq_one_iff_eq_inv₀ mul_eq_one_iff_eq_inv₀
-
-theorem mul_eq_one_iff_inv_eq₀ (ha : a ≠ 0) : a * b = 1 ↔ a⁻¹ = b :=
-  IsUnit.mul_eq_one_iff_inv_eq ha.isUnit
-#align mul_eq_one_iff_inv_eq₀ mul_eq_one_iff_inv_eq₀
-
-/-- A variant of `eq_mul_inv_iff_mul_eq₀` that moves the nonzero hypothesis to another variable. -/
-lemma mul_eq_of_eq_mul_inv₀ (ha : a ≠ 0) (h : a = c * b⁻¹) : a * b = c := by
-  rwa [← eq_mul_inv_iff_mul_eq₀]; rintro rfl; simp [ha] at h
-
-/-- A variant of `eq_inv_mul_iff_mul_eq₀` that moves the nonzero hypothesis to another variable. -/
-lemma mul_eq_of_eq_inv_mul₀ (hb : b ≠ 0) (h : b = a⁻¹ * c) : a * b = c := by
-  rwa [← eq_inv_mul_iff_mul_eq₀]; rintro rfl; simp [hb] at h
-
-/-- A variant of `inv_mul_eq_iff_eq_mul₀` that moves the nonzero hypothesis to another variable. -/
-lemma eq_mul_of_inv_mul_eq₀ (hc : c ≠ 0) (h : b⁻¹ * a = c) : a = b * c := by
-  rwa [← inv_mul_eq_iff_eq_mul₀]; rintro rfl; simp [hc.symm] at h
-
-/-- A variant of `mul_inv_eq_iff_eq_mul₀` that moves the nonzero hypothesis to another variable. -/
-lemma eq_mul_of_mul_inv_eq₀ (hb : b ≠ 0) (h : a * c⁻¹ = b) : a = b * c := by
-  rwa [← mul_inv_eq_iff_eq_mul₀]; rintro rfl; simp [hb.symm] at h
-
-@[simp]
-theorem div_mul_cancel (a : G₀) (h : b ≠ 0) : a / b * b = a :=
-  IsUnit.div_mul_cancel h.isUnit _
-#align div_mul_cancel div_mul_cancel
-
-@[simp]
-theorem mul_div_cancel (a : G₀) (h : b ≠ 0) : a * b / b = a :=
-  IsUnit.mul_div_cancel h.isUnit _
-#align mul_div_cancel mul_div_cancel
-
-theorem mul_one_div_cancel (h : a ≠ 0) : a * (1 / a) = 1 :=
-  IsUnit.mul_one_div_cancel h.isUnit
-#align mul_one_div_cancel mul_one_div_cancel
-
-theorem one_div_mul_cancel (h : a ≠ 0) : 1 / a * a = 1 :=
-  IsUnit.one_div_mul_cancel h.isUnit
-#align one_div_mul_cancel one_div_mul_cancel
-
-theorem div_left_inj' (hc : c ≠ 0) : a / c = b / c ↔ a = b :=
-  IsUnit.div_left_inj hc.isUnit
-#align div_left_inj' div_left_inj'
-
-@[field_simps]
-theorem div_eq_iff (hb : b ≠ 0) : a / b = c ↔ a = c * b :=
-  IsUnit.div_eq_iff hb.isUnit
-#align div_eq_iff div_eq_iff
-
-@[field_simps]
-theorem eq_div_iff (hb : b ≠ 0) : c = a / b ↔ c * b = a :=
-  IsUnit.eq_div_iff hb.isUnit
-#align eq_div_iff eq_div_iff
-
-theorem div_eq_iff_mul_eq (hb : b ≠ 0) : a / b = c ↔ c * b = a :=
-  (IsUnit.div_eq_iff hb.isUnit).trans eq_comm
-#align div_eq_iff_mul_eq div_eq_iff_mul_eq
-
-theorem eq_div_iff_mul_eq (hc : c ≠ 0) : a = b / c ↔ a * c = b :=
-  IsUnit.eq_div_iff hc.isUnit
-#align eq_div_iff_mul_eq eq_div_iff_mul_eq
-
-theorem div_eq_of_eq_mul (hb : b ≠ 0) : a = c * b → a / b = c :=
-  IsUnit.div_eq_of_eq_mul hb.isUnit
-#align div_eq_of_eq_mul div_eq_of_eq_mul
-
-theorem eq_div_of_mul_eq (hc : c ≠ 0) : a * c = b → a = b / c :=
-  IsUnit.eq_div_of_mul_eq hc.isUnit
-#align eq_div_of_mul_eq eq_div_of_mul_eq
-
-theorem div_eq_one_iff_eq (hb : b ≠ 0) : a / b = 1 ↔ a = b :=
-  IsUnit.div_eq_one_iff_eq hb.isUnit
-#align div_eq_one_iff_eq div_eq_one_iff_eq
-
-theorem div_mul_left (hb : b ≠ 0) : b / (a * b) = 1 / a :=
-  IsUnit.div_mul_left hb.isUnit
-#align div_mul_left div_mul_left
-
-theorem mul_div_mul_right (a b : G₀) (hc : c ≠ 0) : a * c / (b * c) = a / b :=
-  IsUnit.mul_div_mul_right hc.isUnit _ _
-#align mul_div_mul_right mul_div_mul_right
-
-theorem mul_mul_div (a : G₀) (hb : b ≠ 0) : a = a * b * (1 / b) :=
-  (IsUnit.mul_mul_div _ hb.isUnit).symm
-#align mul_mul_div mul_mul_div
-
-theorem div_div_div_cancel_right (a : G₀) (hc : c ≠ 0) : a / c / (b / c) = a / b := by
-  rw [div_div_eq_mul_div, div_mul_cancel _ hc]
-#align div_div_div_cancel_right div_div_div_cancel_right
-
-theorem div_mul_div_cancel (a : G₀) (hc : c ≠ 0) : a / c * (c / b) = a / b := by
-  rw [← mul_div_assoc, div_mul_cancel _ hc]
-#align div_mul_div_cancel div_mul_div_cancel
-
-theorem div_mul_cancel_of_imp {a b : G₀} (h : b = 0 → a = 0) : a / b * b = a :=
-  Classical.by_cases (fun hb : b = 0 => by simp [*]) (div_mul_cancel a)
-#align div_mul_cancel_of_imp div_mul_cancel_of_imp
-
-theorem mul_div_cancel_of_imp {a b : G₀} (h : b = 0 → a = 0) : a * b / b = a :=
-  Classical.by_cases (fun hb : b = 0 => by simp [*]) (mul_div_cancel a)
-#align mul_div_cancel_of_imp mul_div_cancel_of_imp
-
-@[simp]
-theorem divp_mk0 (a : G₀) {b : G₀} (hb : b ≠ 0) : a /ₚ Units.mk0 b hb = a / b :=
-  divp_eq_div _ _
-#align divp_mk0 divp_mk0
-
 namespace Commute
+variable [GroupWithZero G₀] {a b c d : G₀}
 
 /-- The `MonoidWithZero` version of `div_eq_div_iff_mul_eq_mul`. -/
 protected lemma div_eq_div_iff (hbd : Commute b d) (hb : b ≠ 0) (hd : d ≠ 0) :
     a / b = c / d ↔ a * d = c * b := hbd.div_eq_div_iff_of_isUnit hb.isUnit hd.isUnit
 
 end Commute
-end GroupWithZero
-
-section CommGroupWithZero
-
--- comm
-variable [CommGroupWithZero G₀] {a b c d : G₀}
-
-theorem div_mul_right (b : G₀) (ha : a ≠ 0) : a / (a * b) = 1 / b :=
-  IsUnit.div_mul_right ha.isUnit _
-#align div_mul_right div_mul_right
-
-theorem mul_div_cancel_left_of_imp {a b : G₀} (h : a = 0 → b = 0) : a * b / a = b := by
-  rw [mul_comm, mul_div_cancel_of_imp h]
-#align mul_div_cancel_left_of_imp mul_div_cancel_left_of_imp
-
-theorem mul_div_cancel_left (b : G₀) (ha : a ≠ 0) : a * b / a = b :=
-  IsUnit.mul_div_cancel_left ha.isUnit _
-#align mul_div_cancel_left mul_div_cancel_left
-
-theorem mul_div_cancel_of_imp' {a b : G₀} (h : b = 0 → a = 0) : b * (a / b) = a := by
-  rw [mul_comm, div_mul_cancel_of_imp h]
-#align mul_div_cancel_of_imp' mul_div_cancel_of_imp'
-
-theorem mul_div_cancel' (a : G₀) (hb : b ≠ 0) : b * (a / b) = a :=
-  IsUnit.mul_div_cancel' hb.isUnit _
-#align mul_div_cancel' mul_div_cancel'
-
-theorem mul_div_mul_left (a b : G₀) (hc : c ≠ 0) : c * a / (c * b) = a / b :=
-  IsUnit.mul_div_mul_left hc.isUnit _ _
-#align mul_div_mul_left mul_div_mul_left
-
-theorem mul_eq_mul_of_div_eq_div (a : G₀) {b : G₀} (c : G₀) {d : G₀} (hb : b ≠ 0) (hd : d ≠ 0)
-    (h : a / b = c / d) : a * d = c * b := by
-  rw [← mul_one a, ← div_self hb, ← mul_comm_div, h, div_mul_eq_mul_div, div_mul_cancel _ hd]
-#align mul_eq_mul_of_div_eq_div mul_eq_mul_of_div_eq_div
-
-@[field_simps]
-theorem div_eq_div_iff (hb : b ≠ 0) (hd : d ≠ 0) : a / b = c / d ↔ a * d = c * b :=
-  IsUnit.div_eq_div_iff hb.isUnit hd.isUnit
-#align div_eq_div_iff div_eq_div_iff
-
-/-- The `CommGroupWithZero` version of `div_eq_div_iff_div_eq_div`. -/
-theorem div_eq_div_iff_div_eq_div' (hb : b ≠ 0) (hc : c ≠ 0) : a / b = c / d ↔ a / c = b / d := by
-  conv_lhs => rw [← mul_left_inj' hb, div_mul_cancel _ hb]
-  conv_rhs => rw [← mul_left_inj' hc, div_mul_cancel _ hc]
-  rw [mul_comm _ c, div_mul_eq_mul_div, mul_div_assoc]
-
-theorem div_div_cancel' (ha : a ≠ 0) : a / (a / b) = b :=
-  IsUnit.div_div_cancel ha.isUnit
-#align div_div_cancel' div_div_cancel'
-
-theorem div_div_cancel_left' (ha : a ≠ 0) : a / b / a = b⁻¹ :=
-  ha.isUnit.div_div_cancel_left
-#align div_div_cancel_left' div_div_cancel_left'
-
-theorem div_helper (b : G₀) (h : a ≠ 0) : 1 / (a * b) * a = 1 / b := by
-  rw [div_mul_eq_mul_div, one_mul, div_mul_right _ h]
-#align div_helper div_helper
-
-theorem div_div_div_cancel_left' (a b : G₀) (hc : c ≠ 0) : c / a / (c / b) = b / a := by
-  rw [div_div_div_eq, mul_comm, mul_div_mul_right _ _ hc]
-
-end CommGroupWithZero
 
 section MonoidWithZero

dc6c365e

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

75c86f04

Diff

@@ -19,7 +19,6 @@ import Mathlib.GroupTheory.GroupAction.Units
 
 
 variable {α M₀ G₀ M₀' G₀' F F' : Type*}
-
 variable [MonoidWithZero M₀]
 
 section GroupWithZero
@@ -311,7 +310,6 @@ def invMonoidWithZeroHom {G₀ : Type*} [CommGroupWithZero G₀] : G₀ →*₀
 namespace Units
 
 variable [GroupWithZero G₀]
-
 variable {a b : G₀}
 
 @[simp]

dc6c365e

chore(Algebra/Group): Do not import GroupWithZero (#11202)

I am claiming that anything within the Algebra.Group folder should be additivisable, to the exception of MonoidHom.End maybe. This is not the case of NeZero, MonoidWithZero and MonoidWithZeroHom which were all imported to prove a few lemmas. Those lemmas are easily moved to another file.

c8969e40

Diff

@@ -4,9 +4,9 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
 import Mathlib.Algebra.Group.Commute.Units
-import Mathlib.Algebra.Group.Hom.Basic
 import Mathlib.Algebra.Group.Units.Hom
 import Mathlib.Algebra.GroupWithZero.Commute
+import Mathlib.Algebra.GroupWithZero.Hom
 import Mathlib.Algebra.GroupWithZero.Units.Basic
 import Mathlib.GroupTheory.GroupAction.Units

dc6c365e

feat: a⁻¹ * b = 1 → a = b (#10835)

and other basic lemmas.

From PFR

87ac4e6b

Diff

@@ -63,6 +63,22 @@ theorem mul_eq_one_iff_inv_eq₀ (ha : a ≠ 0) : a * b = 1 ↔ a⁻¹ = b :=
   IsUnit.mul_eq_one_iff_inv_eq ha.isUnit
 #align mul_eq_one_iff_inv_eq₀ mul_eq_one_iff_inv_eq₀
 
+/-- A variant of `eq_mul_inv_iff_mul_eq₀` that moves the nonzero hypothesis to another variable. -/
+lemma mul_eq_of_eq_mul_inv₀ (ha : a ≠ 0) (h : a = c * b⁻¹) : a * b = c := by
+  rwa [← eq_mul_inv_iff_mul_eq₀]; rintro rfl; simp [ha] at h
+
+/-- A variant of `eq_inv_mul_iff_mul_eq₀` that moves the nonzero hypothesis to another variable. -/
+lemma mul_eq_of_eq_inv_mul₀ (hb : b ≠ 0) (h : b = a⁻¹ * c) : a * b = c := by
+  rwa [← eq_inv_mul_iff_mul_eq₀]; rintro rfl; simp [hb] at h
+
+/-- A variant of `inv_mul_eq_iff_eq_mul₀` that moves the nonzero hypothesis to another variable. -/
+lemma eq_mul_of_inv_mul_eq₀ (hc : c ≠ 0) (h : b⁻¹ * a = c) : a = b * c := by
+  rwa [← inv_mul_eq_iff_eq_mul₀]; rintro rfl; simp [hc.symm] at h
+
+/-- A variant of `mul_inv_eq_iff_eq_mul₀` that moves the nonzero hypothesis to another variable. -/
+lemma eq_mul_of_mul_inv_eq₀ (hb : b ≠ 0) (h : a * c⁻¹ = b) : a = b * c := by
+  rwa [← mul_inv_eq_iff_eq_mul₀]; rintro rfl; simp [hb.symm] at h
+
 @[simp]
 theorem div_mul_cancel (a : G₀) (h : b ≠ 0) : a / b * b = a :=
   IsUnit.div_mul_cancel h.isUnit _

dc6c365e

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

@@ -221,8 +221,9 @@ end CommGroupWithZero
 
 section MonoidWithZero
 
-variable [GroupWithZero G₀] [Nontrivial M₀] [MonoidWithZero M₀'] [MonoidWithZeroHomClass F G₀ M₀]
-  [MonoidWithZeroHomClass F' G₀ M₀'] (f : F) {a : G₀}
+variable [GroupWithZero G₀] [Nontrivial M₀] [MonoidWithZero M₀'] [FunLike F G₀ M₀]
+  [MonoidWithZeroHomClass F G₀ M₀] [FunLike F' G₀ M₀'] [MonoidWithZeroHomClass F' G₀ M₀']
+  (f : F) {a : G₀}
 
 
 theorem map_ne_zero : f a ≠ 0 ↔ a ≠ 0 :=
@@ -245,7 +246,8 @@ end MonoidWithZero
 
 section GroupWithZero
 
-variable [GroupWithZero G₀] [GroupWithZero G₀'] [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (a b : G₀)
+variable [GroupWithZero G₀] [GroupWithZero G₀'] [FunLike F G₀ G₀']
+  [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (a b : G₀)
 
 /-- A monoid homomorphism between groups with zeros sending `0` to `0` sends `a⁻¹` to `(f a)⁻¹`. -/
 @[simp]
@@ -306,7 +308,7 @@ end Units
 /-- If a monoid homomorphism `f` between two `GroupWithZero`s maps `0` to `0`, then it maps `x^n`,
 `n : ℤ`, to `(f x)^n`. -/
 @[simp]
-theorem map_zpow₀ {F G₀ G₀' : Type*} [GroupWithZero G₀] [GroupWithZero G₀']
+theorem map_zpow₀ {F G₀ G₀' : Type*} [GroupWithZero G₀] [GroupWithZero G₀'] [FunLike F G₀ G₀']
     [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (x : G₀) (n : ℤ) : f (x ^ n) = f x ^ n :=
   map_zpow' f (map_inv₀ f) x n
 #align map_zpow₀ map_zpow₀

dc6c365e

feat: two lemmas about division (#9966)

ad223232

Diff

@@ -150,6 +150,7 @@ theorem divp_mk0 (a : G₀) {b : G₀} (hb : b ≠ 0) : a /ₚ Units.mk0 b hb =
 
 namespace Commute
 
+/-- The `MonoidWithZero` version of `div_eq_div_iff_mul_eq_mul`. -/
 protected lemma div_eq_div_iff (hbd : Commute b d) (hb : b ≠ 0) (hd : d ≠ 0) :
     a / b = c / d ↔ a * d = c * b := hbd.div_eq_div_iff_of_isUnit hb.isUnit hd.isUnit
 
@@ -195,6 +196,12 @@ theorem div_eq_div_iff (hb : b ≠ 0) (hd : d ≠ 0) : a / b = c / d ↔ a * d =
   IsUnit.div_eq_div_iff hb.isUnit hd.isUnit
 #align div_eq_div_iff div_eq_div_iff
 
+/-- The `CommGroupWithZero` version of `div_eq_div_iff_div_eq_div`. -/
+theorem div_eq_div_iff_div_eq_div' (hb : b ≠ 0) (hc : c ≠ 0) : a / b = c / d ↔ a / c = b / d := by
+  conv_lhs => rw [← mul_left_inj' hb, div_mul_cancel _ hb]
+  conv_rhs => rw [← mul_left_inj' hc, div_mul_cancel _ hc]
+  rw [mul_comm _ c, div_mul_eq_mul_div, mul_div_assoc]
+
 theorem div_div_cancel' (ha : a ≠ 0) : a / (a / b) = b :=
   IsUnit.div_div_cancel ha.isUnit
 #align div_div_cancel' div_div_cancel'

dc6c365e

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

@@ -3,6 +3,7 @@ Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
+import Mathlib.Algebra.Group.Commute.Units
 import Mathlib.Algebra.Group.Hom.Basic
 import Mathlib.Algebra.Group.Units.Hom
 import Mathlib.Algebra.GroupWithZero.Commute
@@ -23,7 +24,7 @@ variable [MonoidWithZero M₀]
 
 section GroupWithZero
 
-variable [GroupWithZero G₀] {a b c : G₀}
+variable [GroupWithZero G₀] {a b c d : G₀}
 
 @[simp]
 theorem div_self (h : a ≠ 0) : a / a = 1 :=
@@ -147,6 +148,12 @@ theorem divp_mk0 (a : G₀) {b : G₀} (hb : b ≠ 0) : a /ₚ Units.mk0 b hb =
   divp_eq_div _ _
 #align divp_mk0 divp_mk0
 
+namespace Commute
+
+protected lemma div_eq_div_iff (hbd : Commute b d) (hb : b ≠ 0) (hd : d ≠ 0) :
+    a / b = c / d ↔ a * d = c * b := hbd.div_eq_div_iff_of_isUnit hb.isUnit hd.isUnit
+
+end Commute
 end GroupWithZero
 
 section CommGroupWithZero

dc6c365e

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,11 +3,11 @@ Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
+import Mathlib.Algebra.Group.Hom.Basic
+import Mathlib.Algebra.Group.Units.Hom
 import Mathlib.Algebra.GroupWithZero.Commute
-import Mathlib.Algebra.Hom.Units
-import Mathlib.Algebra.Hom.Group.Basic
-import Mathlib.GroupTheory.GroupAction.Units
 import Mathlib.Algebra.GroupWithZero.Units.Basic
+import Mathlib.GroupTheory.GroupAction.Units
 
 #align_import algebra.group_with_zero.units.lemmas from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"

dc6c365e

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

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

260cb506

Diff

@@ -5,6 +5,7 @@ Authors: Johan Commelin
 -/
 import Mathlib.Algebra.GroupWithZero.Commute
 import Mathlib.Algebra.Hom.Units
+import Mathlib.Algebra.Hom.Group.Basic
 import Mathlib.GroupTheory.GroupAction.Units
 import Mathlib.Algebra.GroupWithZero.Units.Basic

dc6c365e

chore: reduce imports to Data.Rat.Cast.CharZero (#7091)

Removing further unnecessary imports on the path to major tactics.

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

9893bbd2

Diff

@@ -287,3 +287,11 @@ theorem smul_mk0 {α : Type*} [SMul G₀ α] {g : G₀} (hg : g ≠ 0) (a : α)
 #align units.smul_mk0 Units.smul_mk0
 
 end Units
+
+/-- If a monoid homomorphism `f` between two `GroupWithZero`s maps `0` to `0`, then it maps `x^n`,
+`n : ℤ`, to `(f x)^n`. -/
+@[simp]
+theorem map_zpow₀ {F G₀ G₀' : Type*} [GroupWithZero G₀] [GroupWithZero G₀']
+    [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (x : G₀) (n : ℤ) : f (x ^ n) = f x ^ n :=
+  map_zpow' f (map_inv₀ f) x n
+#align map_zpow₀ map_zpow₀

dc6c365e

feat(Algebra/GroupWithZero/Units/Lemmas): div_div_div_cancel_left' (#6606)

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

ee38ee9a

Diff

@@ -199,6 +199,9 @@ theorem div_helper (b : G₀) (h : a ≠ 0) : 1 / (a * b) * a = 1 / b := by
   rw [div_mul_eq_mul_div, one_mul, div_mul_right _ h]
 #align div_helper div_helper
 
+theorem div_div_div_cancel_left' (a b : G₀) (hc : c ≠ 0) : c / a / (c / b) = b / a := by
+  rw [div_div_div_eq, mul_comm, mul_div_mul_right _ _ hc]
+
 end CommGroupWithZero
 
 section MonoidWithZero

dc6c365e

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

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

This has nice performance benefits.

32de3f67

Diff

@@ -16,7 +16,7 @@ import Mathlib.Algebra.GroupWithZero.Units.Basic
 -/
 
 
-variable {α M₀ G₀ M₀' G₀' F F' : Type _}
+variable {α M₀ G₀ M₀' G₀' F F' : Type*}
 
 variable [MonoidWithZero M₀]
 
@@ -247,7 +247,7 @@ end GroupWithZero
 
 /-- We define the inverse as a `MonoidWithZeroHom` by extending the inverse map by zero
 on non-units. -/
-noncomputable def MonoidWithZero.inverse {M : Type _} [CommMonoidWithZero M] :
+noncomputable def MonoidWithZero.inverse {M : Type*} [CommMonoidWithZero M] :
     M →*₀ M where
   toFun := Ring.inverse
   map_zero' := Ring.inverse_zero _
@@ -256,19 +256,19 @@ noncomputable def MonoidWithZero.inverse {M : Type _} [CommMonoidWithZero M] :
 #align monoid_with_zero.inverse MonoidWithZero.inverse
 
 @[simp]
-theorem MonoidWithZero.coe_inverse {M : Type _} [CommMonoidWithZero M] :
+theorem MonoidWithZero.coe_inverse {M : Type*} [CommMonoidWithZero M] :
     (MonoidWithZero.inverse : M → M) = Ring.inverse :=
   rfl
 #align monoid_with_zero.coe_inverse MonoidWithZero.coe_inverse
 
 @[simp]
-theorem MonoidWithZero.inverse_apply {M : Type _} [CommMonoidWithZero M] (a : M) :
+theorem MonoidWithZero.inverse_apply {M : Type*} [CommMonoidWithZero M] (a : M) :
     MonoidWithZero.inverse a = Ring.inverse a :=
   rfl
 #align monoid_with_zero.inverse_apply MonoidWithZero.inverse_apply
 
 /-- Inversion on a commutative group with zero, considered as a monoid with zero homomorphism. -/
-def invMonoidWithZeroHom {G₀ : Type _} [CommGroupWithZero G₀] : G₀ →*₀ G₀ :=
+def invMonoidWithZeroHom {G₀ : Type*} [CommGroupWithZero G₀] : G₀ →*₀ G₀ :=
   { invMonoidHom with map_zero' := inv_zero }
 #align inv_monoid_with_zero_hom invMonoidWithZeroHom
 
@@ -279,7 +279,7 @@ variable [GroupWithZero G₀]
 variable {a b : G₀}
 
 @[simp]
-theorem smul_mk0 {α : Type _} [SMul G₀ α] {g : G₀} (hg : g ≠ 0) (a : α) : mk0 g hg • a = g • a :=
+theorem smul_mk0 {α : Type*} [SMul G₀ α] {g : G₀} (hg : g ≠ 0) (a : α) : mk0 g hg • a = g • a :=
   rfl
 #align units.smul_mk0 Units.smul_mk0

dc6c365e

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module algebra.group_with_zero.units.lemmas
-! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.GroupWithZero.Commute
 import Mathlib.Algebra.Hom.Units
 import Mathlib.GroupTheory.GroupAction.Units
 import Mathlib.Algebra.GroupWithZero.Units.Basic
 
+#align_import algebra.group_with_zero.units.lemmas from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
+
 /-!
 # Further lemmas about units in a `MonoidWithZero` or a `GroupWithZero`.

dc6c365e

chore: cleanup whitespace (#5988)

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

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

12343aa5

Diff

@@ -37,7 +37,7 @@ theorem eq_mul_inv_iff_mul_eq₀ (hc : c ≠ 0) : a = b * c⁻¹ ↔ a * c = b :
 #align eq_mul_inv_iff_mul_eq₀ eq_mul_inv_iff_mul_eq₀
 
 theorem eq_inv_mul_iff_mul_eq₀ (hb : b ≠ 0) : a = b⁻¹ * c ↔ b * a = c :=
-  IsUnit.eq_inv_mul_iff_mul_eq  hb.isUnit
+  IsUnit.eq_inv_mul_iff_mul_eq hb.isUnit
 #align eq_inv_mul_iff_mul_eq₀ eq_inv_mul_iff_mul_eq₀
 
 theorem inv_mul_eq_iff_eq_mul₀ (ha : a ≠ 0) : a⁻¹ * b = c ↔ b = a * c :=

dc6c365e

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

0422d4a6

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 
 ! This file was ported from Lean 3 source module algebra.group_with_zero.units.lemmas
-! leanprover-community/mathlib commit 4dc134b97a3de65ef2ed881f3513d56260971562
+! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -194,6 +194,10 @@ theorem div_div_cancel' (ha : a ≠ 0) : a / (a / b) = b :=
   IsUnit.div_div_cancel ha.isUnit
 #align div_div_cancel' div_div_cancel'
 
+theorem div_div_cancel_left' (ha : a ≠ 0) : a / b / a = b⁻¹ :=
+  ha.isUnit.div_div_cancel_left
+#align div_div_cancel_left' div_div_cancel_left'
+
 theorem div_helper (b : G₀) (h : a ≠ 0) : 1 / (a * b) * a = 1 / b := by
   rw [div_mul_eq_mul_div, one_mul, div_mul_right _ h]
 #align div_helper div_helper

4dc134b9

chore: add source headers to ported theory files (#1094)

The script used to do this is included. The yaml file was obtained from https://raw.githubusercontent.com/wiki/leanprover-community/mathlib/mathlib4-port-status.md

f168625e

Diff

@@ -2,6 +2,11 @@
 Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
+
+! This file was ported from Lean 3 source module algebra.group_with_zero.units.lemmas
+! leanprover-community/mathlib commit 4dc134b97a3de65ef2ed881f3513d56260971562
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.GroupWithZero.Commute
 import Mathlib.Algebra.Hom.Units

`algebra.group_with_zero.units.lemmas` ⟷ `Mathlib.Algebra.GroupWithZero.Units.Lemmas`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Important changes

Remaining issues

Slower (failing) search

`simp` not firing sometimes

Missing instances due to unification failing

Workaround for issues

Dependencies 41

algebra.group_with_zero.units.lemmas ⟷ Mathlib.Algebra.GroupWithZero.Units.Lemmas

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Important changes

Remaining issues

Slower (failing) search

simp not firing sometimes

Missing instances due to unification failing

Workaround for issues

Dependencies 41

`algebra.group_with_zero.units.lemmas` ⟷ `Mathlib.Algebra.GroupWithZero.Units.Lemmas`

`simp` not firing sometimes