ring_theory.non_zero_divisors ⟷ Mathlib.Algebra.GroupWithZero.NonZeroDivisors

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

@@ -217,7 +217,6 @@ theorem nonZeroDivisors_le_comap_nonZeroDivisors_of_injective [NoZeroDivisors M'
 #align non_zero_divisors_le_comap_non_zero_divisors_of_injective nonZeroDivisors_le_comap_nonZeroDivisors_of_injective
 -/
 
-#print prod_zero_iff_exists_zero /-
 theorem prod_zero_iff_exists_zero [NoZeroDivisors M₁] [Nontrivial M₁] {s : Multiset M₁} :
     s.Prod = 0 ↔ ∃ (r : M₁) (hr : r ∈ s), r = 0 :=
   by
@@ -236,7 +235,6 @@ theorem prod_zero_iff_exists_zero [NoZeroDivisors M₁] [Nontrivial M₁] {s : M
       rintro b ⟨hb₁, hb₂⟩
       exact ⟨Multiset.mem_cons_of_mem hb₁, hb₂⟩
 #align prod_zero_iff_exists_zero prod_zero_iff_exists_zero
--/
 
 end nonZeroDivisors
 

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

@@ -32,7 +32,7 @@ section nonZeroDivisors
 def nonZeroDivisors (R : Type _) [MonoidWithZero R] : Submonoid R
     where
   carrier := {x | ∀ z, z * x = 0 → z = 0}
-  one_mem' z hz := by rwa [mul_one] at hz 
+  one_mem' z hz := by rwa [mul_one] at hz
   hMul_mem' x₁ x₂ hx₁ hx₂ z hz :=
     have : z * x₁ * x₂ = 0 := by rwa [mul_assoc]
     hx₁ z <| hx₂ (z * x₁) this

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

@@ -3,8 +3,8 @@ Copyright (c) 2020 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Devon Tuma
 -/
-import Mathbin.GroupTheory.Submonoid.Operations
-import Mathbin.GroupTheory.Submonoid.Membership
+import GroupTheory.Submonoid.Operations
+import GroupTheory.Submonoid.Membership
 
 #align_import ring_theory.non_zero_divisors from "leanprover-community/mathlib"@"327c3c0d9232d80e250dc8f65e7835b82b266ea5"
 

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

@@ -33,7 +33,7 @@ def nonZeroDivisors (R : Type _) [MonoidWithZero R] : Submonoid R
     where
   carrier := {x | ∀ z, z * x = 0 → z = 0}
   one_mem' z hz := by rwa [mul_one] at hz 
-  mul_mem' x₁ x₂ hx₁ hx₂ z hz :=
+  hMul_mem' x₁ x₂ hx₁ hx₂ z hz :=
     have : z * x₁ * x₂ = 0 := by rwa [mul_assoc]
     hx₁ z <| hx₂ (z * x₁) this
 #align non_zero_divisors nonZeroDivisors
@@ -142,14 +142,14 @@ theorem isUnit_of_mem_nonZeroDivisors {G₀ : Type _} [GroupWithZero G₀] {x :
 #print eq_zero_of_ne_zero_of_mul_right_eq_zero /-
 theorem eq_zero_of_ne_zero_of_mul_right_eq_zero [NoZeroDivisors M] {x y : M} (hnx : x ≠ 0)
     (hxy : y * x = 0) : y = 0 :=
-  Or.resolve_right (eq_zero_or_eq_zero_of_mul_eq_zero hxy) hnx
+  Or.resolve_right (eq_zero_or_eq_zero_of_hMul_eq_zero hxy) hnx
 #align eq_zero_of_ne_zero_of_mul_right_eq_zero eq_zero_of_ne_zero_of_mul_right_eq_zero
 -/
 
 #print eq_zero_of_ne_zero_of_mul_left_eq_zero /-
 theorem eq_zero_of_ne_zero_of_mul_left_eq_zero [NoZeroDivisors M] {x y : M} (hnx : x ≠ 0)
     (hxy : x * y = 0) : y = 0 :=
-  Or.resolve_left (eq_zero_or_eq_zero_of_mul_eq_zero hxy) hnx
+  Or.resolve_left (eq_zero_or_eq_zero_of_hMul_eq_zero hxy) hnx
 #align eq_zero_of_ne_zero_of_mul_left_eq_zero eq_zero_of_ne_zero_of_mul_left_eq_zero
 -/
 
@@ -183,7 +183,7 @@ theorem map_mem_nonZeroDivisors [Nontrivial M] [NoZeroDivisors M'] [ZeroHomClass
 #print le_nonZeroDivisors_of_noZeroDivisors /-
 theorem le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {S : Submonoid M}
     (hS : (0 : M) ∉ S) : S ≤ M⁰ := fun x hx y hy =>
-  Or.rec_on (eq_zero_or_eq_zero_of_mul_eq_zero hy) (fun h => h) fun h =>
+  Or.rec_on (eq_zero_or_eq_zero_of_hMul_eq_zero hy) (fun h => h) fun h =>
     absurd (h ▸ hx : (0 : M) ∈ S) hS
 #align le_non_zero_divisors_of_no_zero_divisors le_nonZeroDivisors_of_noZeroDivisors
 -/

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

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Devon Tuma
-
-! This file was ported from Lean 3 source module ring_theory.non_zero_divisors
-! leanprover-community/mathlib commit 327c3c0d9232d80e250dc8f65e7835b82b266ea5
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.GroupTheory.Submonoid.Operations
 import Mathbin.GroupTheory.Submonoid.Membership
 
+#align_import ring_theory.non_zero_divisors from "leanprover-community/mathlib"@"327c3c0d9232d80e250dc8f65e7835b82b266ea5"
+
 /-!
 # Non-zero divisors
 

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

@@ -42,61 +42,83 @@ def nonZeroDivisors (R : Type _) [MonoidWithZero R] : Submonoid R
 #align non_zero_divisors nonZeroDivisors
 -/
 
--- mathport name: non_zero_divisors
 scoped[nonZeroDivisors] notation:9000 R "⁰" => nonZeroDivisors R
 
 variable {M M' M₁ R R' F : Type _} [MonoidWithZero M] [MonoidWithZero M'] [CommMonoidWithZero M₁]
   [Ring R] [CommRing R']
 
+#print mem_nonZeroDivisors_iff /-
 theorem mem_nonZeroDivisors_iff {r : M} : r ∈ M⁰ ↔ ∀ x, x * r = 0 → x = 0 :=
   Iff.rfl
 #align mem_non_zero_divisors_iff mem_nonZeroDivisors_iff
+-/
 
+#print mul_right_mem_nonZeroDivisors_eq_zero_iff /-
 theorem mul_right_mem_nonZeroDivisors_eq_zero_iff {x r : M} (hr : r ∈ M⁰) : x * r = 0 ↔ x = 0 :=
   ⟨hr _, by simp (config := { contextual := true })⟩
 #align mul_right_mem_non_zero_divisors_eq_zero_iff mul_right_mem_nonZeroDivisors_eq_zero_iff
+-/
 
+#print mul_right_coe_nonZeroDivisors_eq_zero_iff /-
 @[simp]
 theorem mul_right_coe_nonZeroDivisors_eq_zero_iff {x : M} {c : M⁰} : x * c = 0 ↔ x = 0 :=
   mul_right_mem_nonZeroDivisors_eq_zero_iff c.Prop
 #align mul_right_coe_non_zero_divisors_eq_zero_iff mul_right_coe_nonZeroDivisors_eq_zero_iff
+-/
 
+#print mul_left_mem_nonZeroDivisors_eq_zero_iff /-
 theorem mul_left_mem_nonZeroDivisors_eq_zero_iff {r x : M₁} (hr : r ∈ M₁⁰) : r * x = 0 ↔ x = 0 := by
   rw [mul_comm, mul_right_mem_nonZeroDivisors_eq_zero_iff hr]
 #align mul_left_mem_non_zero_divisors_eq_zero_iff mul_left_mem_nonZeroDivisors_eq_zero_iff
+-/
 
+#print mul_left_coe_nonZeroDivisors_eq_zero_iff /-
 @[simp]
 theorem mul_left_coe_nonZeroDivisors_eq_zero_iff {c : M₁⁰} {x : M₁} : (c : M₁) * x = 0 ↔ x = 0 :=
   mul_left_mem_nonZeroDivisors_eq_zero_iff c.Prop
 #align mul_left_coe_non_zero_divisors_eq_zero_iff mul_left_coe_nonZeroDivisors_eq_zero_iff
+-/
 
+#print mul_cancel_right_mem_nonZeroDivisors /-
 theorem mul_cancel_right_mem_nonZeroDivisors {x y r : R} (hr : r ∈ R⁰) : x * r = y * r ↔ x = y :=
   by
   refine' ⟨fun h => _, congr_arg _⟩
   rw [← sub_eq_zero, ← mul_right_mem_nonZeroDivisors_eq_zero_iff hr, sub_mul, h, sub_self]
 #align mul_cancel_right_mem_non_zero_divisor mul_cancel_right_mem_nonZeroDivisors
+-/
 
+#print mul_cancel_right_coe_nonZeroDivisors /-
 theorem mul_cancel_right_coe_nonZeroDivisors {x y : R} {c : R⁰} : x * c = y * c ↔ x = y :=
   mul_cancel_right_mem_nonZeroDivisors c.Prop
 #align mul_cancel_right_coe_non_zero_divisor mul_cancel_right_coe_nonZeroDivisors
+-/
 
+#print mul_cancel_left_mem_nonZeroDivisors /-
 @[simp]
 theorem mul_cancel_left_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : r * x = r * y ↔ x = y :=
   by simp_rw [mul_comm r, mul_cancel_right_mem_nonZeroDivisors hr]
 #align mul_cancel_left_mem_non_zero_divisor mul_cancel_left_mem_nonZeroDivisors
+-/
 
+#print mul_cancel_left_coe_nonZeroDivisors /-
 theorem mul_cancel_left_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : (c : R') * x = c * y ↔ x = y :=
   mul_cancel_left_mem_nonZeroDivisors c.Prop
 #align mul_cancel_left_coe_non_zero_divisor mul_cancel_left_coe_nonZeroDivisors
+-/
 
+#print nonZeroDivisors.ne_zero /-
 theorem nonZeroDivisors.ne_zero [Nontrivial M] {x} (hx : x ∈ M⁰) : x ≠ 0 := fun h =>
   one_ne_zero (hx _ <| (one_mul _).trans h)
 #align non_zero_divisors.ne_zero nonZeroDivisors.ne_zero
+-/
 
+#print nonZeroDivisors.coe_ne_zero /-
 theorem nonZeroDivisors.coe_ne_zero [Nontrivial M] (x : M⁰) : (x : M) ≠ 0 :=
   nonZeroDivisors.ne_zero x.2
 #align non_zero_divisors.coe_ne_zero nonZeroDivisors.coe_ne_zero
+-/
 
+#print mul_mem_nonZeroDivisors /-
 theorem mul_mem_nonZeroDivisors {a b : M₁} : a * b ∈ M₁⁰ ↔ a ∈ M₁⁰ ∧ b ∈ M₁⁰ :=
   by
   constructor
@@ -109,54 +131,74 @@ theorem mul_mem_nonZeroDivisors {a b : M₁} : a * b ∈ M₁⁰ ↔ a ∈ M₁
     apply hb
     rw [mul_assoc, hx]
 #align mul_mem_non_zero_divisors mul_mem_nonZeroDivisors
+-/
 
+#print isUnit_of_mem_nonZeroDivisors /-
 theorem isUnit_of_mem_nonZeroDivisors {G₀ : Type _} [GroupWithZero G₀] {x : G₀}
     (hx : x ∈ nonZeroDivisors G₀) : IsUnit x :=
   ⟨⟨x, x⁻¹, mul_inv_cancel (nonZeroDivisors.ne_zero hx),
       inv_mul_cancel (nonZeroDivisors.ne_zero hx)⟩,
     rfl⟩
 #align is_unit_of_mem_non_zero_divisors isUnit_of_mem_nonZeroDivisors
+-/
 
+#print eq_zero_of_ne_zero_of_mul_right_eq_zero /-
 theorem eq_zero_of_ne_zero_of_mul_right_eq_zero [NoZeroDivisors M] {x y : M} (hnx : x ≠ 0)
     (hxy : y * x = 0) : y = 0 :=
   Or.resolve_right (eq_zero_or_eq_zero_of_mul_eq_zero hxy) hnx
 #align eq_zero_of_ne_zero_of_mul_right_eq_zero eq_zero_of_ne_zero_of_mul_right_eq_zero
+-/
 
+#print eq_zero_of_ne_zero_of_mul_left_eq_zero /-
 theorem eq_zero_of_ne_zero_of_mul_left_eq_zero [NoZeroDivisors M] {x y : M} (hnx : x ≠ 0)
     (hxy : x * y = 0) : y = 0 :=
   Or.resolve_left (eq_zero_or_eq_zero_of_mul_eq_zero hxy) hnx
 #align eq_zero_of_ne_zero_of_mul_left_eq_zero eq_zero_of_ne_zero_of_mul_left_eq_zero
+-/
 
+#print mem_nonZeroDivisors_of_ne_zero /-
 theorem mem_nonZeroDivisors_of_ne_zero [NoZeroDivisors M] {x : M} (hx : x ≠ 0) : x ∈ M⁰ := fun _ =>
   eq_zero_of_ne_zero_of_mul_right_eq_zero hx
 #align mem_non_zero_divisors_of_ne_zero mem_nonZeroDivisors_of_ne_zero
+-/
 
+#print mem_nonZeroDivisors_iff_ne_zero /-
 theorem mem_nonZeroDivisors_iff_ne_zero [NoZeroDivisors M] [Nontrivial M] {x : M} :
     x ∈ M⁰ ↔ x ≠ 0 :=
   ⟨nonZeroDivisors.ne_zero, mem_nonZeroDivisors_of_ne_zero⟩
 #align mem_non_zero_divisors_iff_ne_zero mem_nonZeroDivisors_iff_ne_zero
+-/
 
+#print map_ne_zero_of_mem_nonZeroDivisors /-
 theorem map_ne_zero_of_mem_nonZeroDivisors [Nontrivial M] [ZeroHomClass F M M'] (g : F)
     (hg : Function.Injective (g : M → M')) {x : M} (h : x ∈ M⁰) : g x ≠ 0 := fun h0 =>
   one_ne_zero (h 1 ((one_mul x).symm ▸ hg (trans h0 (map_zero g).symm)))
 #align map_ne_zero_of_mem_non_zero_divisors map_ne_zero_of_mem_nonZeroDivisors
+-/
 
+#print map_mem_nonZeroDivisors /-
 theorem map_mem_nonZeroDivisors [Nontrivial M] [NoZeroDivisors M'] [ZeroHomClass F M M'] (g : F)
     (hg : Function.Injective g) {x : M} (h : x ∈ M⁰) : g x ∈ M'⁰ := fun z hz =>
   eq_zero_of_ne_zero_of_mul_right_eq_zero (map_ne_zero_of_mem_nonZeroDivisors g hg h) hz
 #align map_mem_non_zero_divisors map_mem_nonZeroDivisors
+-/
 
+#print le_nonZeroDivisors_of_noZeroDivisors /-
 theorem le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {S : Submonoid M}
     (hS : (0 : M) ∉ S) : S ≤ M⁰ := fun x hx y hy =>
   Or.rec_on (eq_zero_or_eq_zero_of_mul_eq_zero hy) (fun h => h) fun h =>
     absurd (h ▸ hx : (0 : M) ∈ S) hS
 #align le_non_zero_divisors_of_no_zero_divisors le_nonZeroDivisors_of_noZeroDivisors
+-/
 
+#print powers_le_nonZeroDivisors_of_noZeroDivisors /-
 theorem powers_le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {a : M} (ha : a ≠ 0) :
     Submonoid.powers a ≤ M⁰ :=
   le_nonZeroDivisors_of_noZeroDivisors fun h => absurd (h.recOn fun _ hn => pow_eq_zero hn) ha
 #align powers_le_non_zero_divisors_of_no_zero_divisors powers_le_nonZeroDivisors_of_noZeroDivisors
+-/
 
+#print map_le_nonZeroDivisors_of_injective /-
 theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroHomClass F M M']
     (f : F) (hf : Function.Injective f) {S : Submonoid M} (hS : S ≤ M⁰) : S.map f ≤ M'⁰ :=
   by
@@ -169,12 +211,16 @@ theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroH
         zero_ne_one
           (hS (hf (trans hx0 (map_zero f).symm) ▸ hx : 0 ∈ S) 1 (MulZeroClass.mul_zero 1)).symm
 #align map_le_non_zero_divisors_of_injective map_le_nonZeroDivisors_of_injective
+-/
 
+#print nonZeroDivisors_le_comap_nonZeroDivisors_of_injective /-
 theorem nonZeroDivisors_le_comap_nonZeroDivisors_of_injective [NoZeroDivisors M']
     [MonoidWithZeroHomClass F M M'] (f : F) (hf : Function.Injective f) : M⁰ ≤ M'⁰.comap f :=
   Submonoid.le_comap_of_map_le _ (map_le_nonZeroDivisors_of_injective _ hf le_rfl)
 #align non_zero_divisors_le_comap_non_zero_divisors_of_injective nonZeroDivisors_le_comap_nonZeroDivisors_of_injective
+-/
 
+#print prod_zero_iff_exists_zero /-
 theorem prod_zero_iff_exists_zero [NoZeroDivisors M₁] [Nontrivial M₁] {s : Multiset M₁} :
     s.Prod = 0 ↔ ∃ (r : M₁) (hr : r ∈ s), r = 0 :=
   by
@@ -193,6 +239,7 @@ theorem prod_zero_iff_exists_zero [NoZeroDivisors M₁] [Nontrivial M₁] {s : M
       rintro b ⟨hb₁, hb₂⟩
       exact ⟨Multiset.mem_cons_of_mem hb₁, hb₂⟩
 #align prod_zero_iff_exists_zero prod_zero_iff_exists_zero
+-/
 
 end nonZeroDivisors
 

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

@@ -34,7 +34,7 @@ section nonZeroDivisors
 /-- The submonoid of non-zero-divisors of a `monoid_with_zero` `R`. -/
 def nonZeroDivisors (R : Type _) [MonoidWithZero R] : Submonoid R
     where
-  carrier := { x | ∀ z, z * x = 0 → z = 0 }
+  carrier := {x | ∀ z, z * x = 0 → z = 0}
   one_mem' z hz := by rwa [mul_one] at hz 
   mul_mem' x₁ x₂ hx₁ hx₂ z hz :=
     have : z * x₁ * x₂ = 0 := by rwa [mul_assoc]

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

@@ -35,7 +35,7 @@ section nonZeroDivisors
 def nonZeroDivisors (R : Type _) [MonoidWithZero R] : Submonoid R
     where
   carrier := { x | ∀ z, z * x = 0 → z = 0 }
-  one_mem' z hz := by rwa [mul_one] at hz
+  one_mem' z hz := by rwa [mul_one] at hz 
   mul_mem' x₁ x₂ hx₁ hx₂ z hz :=
     have : z * x₁ * x₂ = 0 := by rwa [mul_assoc]
     hx₁ z <| hx₂ (z * x₁) this
@@ -176,7 +176,7 @@ theorem nonZeroDivisors_le_comap_nonZeroDivisors_of_injective [NoZeroDivisors M'
 #align non_zero_divisors_le_comap_non_zero_divisors_of_injective nonZeroDivisors_le_comap_nonZeroDivisors_of_injective
 
 theorem prod_zero_iff_exists_zero [NoZeroDivisors M₁] [Nontrivial M₁] {s : Multiset M₁} :
-    s.Prod = 0 ↔ ∃ (r : M₁)(hr : r ∈ s), r = 0 :=
+    s.Prod = 0 ↔ ∃ (r : M₁) (hr : r ∈ s), r = 0 :=
   by
   constructor; swap
   · rintro ⟨r, hrs, rfl⟩

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

@@ -48,121 +48,55 @@ scoped[nonZeroDivisors] notation:9000 R "⁰" => nonZeroDivisors R
 variable {M M' M₁ R R' F : Type _} [MonoidWithZero M] [MonoidWithZero M'] [CommMonoidWithZero M₁]
   [Ring R] [CommRing R']
 
-/- warning: mem_non_zero_divisors_iff -> mem_nonZeroDivisors_iff is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] {r : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) r (nonZeroDivisors.{u1} M _inst_1)) (forall (x : M), (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x r) (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 u1} M x (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))))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] {r : M}, Iff (Membership.mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) r (nonZeroDivisors.{u1} M _inst_1)) (forall (x : M), (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x r) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))) -> (Eq.{succ u1} M x (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align mem_non_zero_divisors_iff mem_nonZeroDivisors_iffₓ'. -/
 theorem mem_nonZeroDivisors_iff {r : M} : r ∈ M⁰ ↔ ∀ x, x * r = 0 → x = 0 :=
   Iff.rfl
 #align mem_non_zero_divisors_iff mem_nonZeroDivisors_iff
 
-/- warning: mul_right_mem_non_zero_divisors_eq_zero_iff -> mul_right_mem_nonZeroDivisors_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] {x : M} {r : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) r (nonZeroDivisors.{u1} M _inst_1)) -> (Iff (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x r) (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 u1} M x (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))))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] {x : M} {r : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) r (nonZeroDivisors.{u1} M _inst_1)) -> (Iff (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x r) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))) (Eq.{succ u1} M x (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align mul_right_mem_non_zero_divisors_eq_zero_iff mul_right_mem_nonZeroDivisors_eq_zero_iffₓ'. -/
 theorem mul_right_mem_nonZeroDivisors_eq_zero_iff {x r : M} (hr : r ∈ M⁰) : x * r = 0 ↔ x = 0 :=
   ⟨hr _, by simp (config := { contextual := true })⟩
 #align mul_right_mem_non_zero_divisors_eq_zero_iff mul_right_mem_nonZeroDivisors_eq_zero_iff
 
-/- warning: mul_right_coe_non_zero_divisors_eq_zero_iff -> mul_right_coe_nonZeroDivisors_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] {x : M} {c : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (nonZeroDivisors.{u1} M _inst_1)}, Iff (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (nonZeroDivisors.{u1} M _inst_1)) M (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (nonZeroDivisors.{u1} M _inst_1)) M (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (nonZeroDivisors.{u1} M _inst_1)) M (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (nonZeroDivisors.{u1} M _inst_1)) M (coeSubtype.{succ u1} M (fun (x : M) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (nonZeroDivisors.{u1} M _inst_1)))))) c)) (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 u1} M x (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)))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] {x : M} {c : Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (nonZeroDivisors.{u1} M _inst_1))}, Iff (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (Subtype.val.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x (SetLike.coe.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (nonZeroDivisors.{u1} M _inst_1))) c)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))) (Eq.{succ u1} M x (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1))))
-Case conversion may be inaccurate. Consider using '#align mul_right_coe_non_zero_divisors_eq_zero_iff mul_right_coe_nonZeroDivisors_eq_zero_iffₓ'. -/
 @[simp]
 theorem mul_right_coe_nonZeroDivisors_eq_zero_iff {x : M} {c : M⁰} : x * c = 0 ↔ x = 0 :=
   mul_right_mem_nonZeroDivisors_eq_zero_iff c.Prop
 #align mul_right_coe_non_zero_divisors_eq_zero_iff mul_right_coe_nonZeroDivisors_eq_zero_iff
 
-/- warning: mul_left_mem_non_zero_divisors_eq_zero_iff -> mul_left_mem_nonZeroDivisors_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {M₁ : Type.{u1}} [_inst_3 : CommMonoidWithZero.{u1} M₁] {r : M₁} {x : M₁}, (Membership.Mem.{u1, u1} M₁ (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.setLike.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) r (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))) -> (Iff (Eq.{succ u1} M₁ (HMul.hMul.{u1, u1, u1} M₁ M₁ M₁ (instHMul.{u1} M₁ (MulZeroClass.toHasMul.{u1} M₁ (MulZeroOneClass.toMulZeroClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) r x) (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₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))))))) (Eq.{succ u1} M₁ x (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₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))))))))
-but is expected to have type
-  forall {M₁ : Type.{u1}} [_inst_3 : CommMonoidWithZero.{u1} M₁] {r : M₁} {x : M₁}, (Membership.mem.{u1, u1} M₁ (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.instSetLikeSubmonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) r (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))) -> (Iff (Eq.{succ u1} M₁ (HMul.hMul.{u1, u1, u1} M₁ M₁ M₁ (instHMul.{u1} M₁ (MulZeroClass.toMul.{u1} M₁ (MulZeroOneClass.toMulZeroClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) r x) (OfNat.ofNat.{u1} M₁ 0 (Zero.toOfNat0.{u1} M₁ (CommMonoidWithZero.toZero.{u1} M₁ _inst_3)))) (Eq.{succ u1} M₁ x (OfNat.ofNat.{u1} M₁ 0 (Zero.toOfNat0.{u1} M₁ (CommMonoidWithZero.toZero.{u1} M₁ _inst_3)))))
-Case conversion may be inaccurate. Consider using '#align mul_left_mem_non_zero_divisors_eq_zero_iff mul_left_mem_nonZeroDivisors_eq_zero_iffₓ'. -/
 theorem mul_left_mem_nonZeroDivisors_eq_zero_iff {r x : M₁} (hr : r ∈ M₁⁰) : r * x = 0 ↔ x = 0 := by
   rw [mul_comm, mul_right_mem_nonZeroDivisors_eq_zero_iff hr]
 #align mul_left_mem_non_zero_divisors_eq_zero_iff mul_left_mem_nonZeroDivisors_eq_zero_iff
 
-/- warning: mul_left_coe_non_zero_divisors_eq_zero_iff -> mul_left_coe_nonZeroDivisors_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {M₁ : Type.{u1}} [_inst_3 : CommMonoidWithZero.{u1} M₁] {c : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.setLike.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))} {x : M₁}, Iff (Eq.{succ u1} M₁ (HMul.hMul.{u1, u1, u1} M₁ M₁ M₁ (instHMul.{u1} M₁ (MulZeroClass.toHasMul.{u1} M₁ (MulZeroOneClass.toMulZeroClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.setLike.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))) M₁ (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.setLike.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))) M₁ (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.setLike.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))) M₁ (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.setLike.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))) M₁ (coeSubtype.{succ u1} M₁ (fun (x : M₁) => Membership.Mem.{u1, u1} M₁ (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.setLike.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) x (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))))) c) x) (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₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))))))) (Eq.{succ u1} M₁ x (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₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))))))
-but is expected to have type
-  forall {M₁ : Type.{u1}} [_inst_3 : CommMonoidWithZero.{u1} M₁] {c : Subtype.{succ u1} M₁ (fun (x : M₁) => Membership.mem.{u1, u1} M₁ (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.instSetLikeSubmonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) x (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))} {x : M₁}, Iff (Eq.{succ u1} M₁ (HMul.hMul.{u1, u1, u1} M₁ M₁ M₁ (instHMul.{u1} M₁ (MulZeroClass.toMul.{u1} M₁ (MulZeroOneClass.toMulZeroClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) (Subtype.val.{succ u1} M₁ (fun (x : M₁) => Membership.mem.{u1, u1} M₁ (Set.{u1} M₁) (Set.instMembershipSet.{u1} M₁) x (SetLike.coe.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.instSetLikeSubmonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) c) x) (OfNat.ofNat.{u1} M₁ 0 (Zero.toOfNat0.{u1} M₁ (CommMonoidWithZero.toZero.{u1} M₁ _inst_3)))) (Eq.{succ u1} M₁ x (OfNat.ofNat.{u1} M₁ 0 (Zero.toOfNat0.{u1} M₁ (CommMonoidWithZero.toZero.{u1} M₁ _inst_3))))
-Case conversion may be inaccurate. Consider using '#align mul_left_coe_non_zero_divisors_eq_zero_iff mul_left_coe_nonZeroDivisors_eq_zero_iffₓ'. -/
 @[simp]
 theorem mul_left_coe_nonZeroDivisors_eq_zero_iff {c : M₁⁰} {x : M₁} : (c : M₁) * x = 0 ↔ x = 0 :=
   mul_left_mem_nonZeroDivisors_eq_zero_iff c.Prop
 #align mul_left_coe_non_zero_divisors_eq_zero_iff mul_left_coe_nonZeroDivisors_eq_zero_iff
 
-/- warning: mul_cancel_right_mem_non_zero_divisor -> mul_cancel_right_mem_nonZeroDivisors is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] {x : R} {y : R} {r : R}, (Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) r (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))) -> (Iff (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_4))) x r) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_4))) y r)) (Eq.{succ u1} R x y))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] {x : R} {y : R} {r : R}, (Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) r (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))) -> (Iff (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))) x r) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))) y r)) (Eq.{succ u1} R x y))
-Case conversion may be inaccurate. Consider using '#align mul_cancel_right_mem_non_zero_divisor mul_cancel_right_mem_nonZeroDivisorsₓ'. -/
 theorem mul_cancel_right_mem_nonZeroDivisors {x y r : R} (hr : r ∈ R⁰) : x * r = y * r ↔ x = y :=
   by
   refine' ⟨fun h => _, congr_arg _⟩
   rw [← sub_eq_zero, ← mul_right_mem_nonZeroDivisors_eq_zero_iff hr, sub_mul, h, sub_self]
 #align mul_cancel_right_mem_non_zero_divisor mul_cancel_right_mem_nonZeroDivisors
 
-/- warning: mul_cancel_right_coe_non_zero_divisor -> mul_cancel_right_coe_nonZeroDivisors is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align mul_cancel_right_coe_non_zero_divisor mul_cancel_right_coe_nonZeroDivisorsₓ'. -/
 theorem mul_cancel_right_coe_nonZeroDivisors {x y : R} {c : R⁰} : x * c = y * c ↔ x = y :=
   mul_cancel_right_mem_nonZeroDivisors c.Prop
 #align mul_cancel_right_coe_non_zero_divisor mul_cancel_right_coe_nonZeroDivisors
 
-/- warning: mul_cancel_left_mem_non_zero_divisor -> mul_cancel_left_mem_nonZeroDivisors is a dubious translation:
-lean 3 declaration is
-  forall {R' : Type.{u1}} [_inst_5 : CommRing.{u1} R'] {x : R'} {y : R'} {r : R'}, (Membership.Mem.{u1, u1} R' (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) r (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) -> (Iff (Eq.{succ u1} R' (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (Distrib.toHasMul.{u1} R' (Ring.toDistrib.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))) r x) (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (Distrib.toHasMul.{u1} R' (Ring.toDistrib.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))) r y)) (Eq.{succ u1} R' x y))
-but is expected to have type
-  forall {R' : Type.{u1}} [_inst_5 : CommRing.{u1} R'] {x : R'} {y : R'} {r : R'}, (Membership.mem.{u1, u1} R' (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) R' (Submonoid.instSetLikeSubmonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5))))))) r (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5))))) -> (Iff (Eq.{succ u1} R' (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (NonUnitalNonAssocRing.toMul.{u1} R' (NonAssocRing.toNonUnitalNonAssocRing.{u1} R' (Ring.toNonAssocRing.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) r x) (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (NonUnitalNonAssocRing.toMul.{u1} R' (NonAssocRing.toNonUnitalNonAssocRing.{u1} R' (Ring.toNonAssocRing.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) r y)) (Eq.{succ u1} R' x y))
-Case conversion may be inaccurate. Consider using '#align mul_cancel_left_mem_non_zero_divisor mul_cancel_left_mem_nonZeroDivisorsₓ'. -/
 @[simp]
 theorem mul_cancel_left_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : r * x = r * y ↔ x = y :=
   by simp_rw [mul_comm r, mul_cancel_right_mem_nonZeroDivisors hr]
 #align mul_cancel_left_mem_non_zero_divisor mul_cancel_left_mem_nonZeroDivisors
 
-/- warning: mul_cancel_left_coe_non_zero_divisor -> mul_cancel_left_coe_nonZeroDivisors is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align mul_cancel_left_coe_non_zero_divisor mul_cancel_left_coe_nonZeroDivisorsₓ'. -/
 theorem mul_cancel_left_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : (c : R') * x = c * y ↔ x = y :=
   mul_cancel_left_mem_nonZeroDivisors c.Prop
 #align mul_cancel_left_coe_non_zero_divisor mul_cancel_left_coe_nonZeroDivisors
 
-/- warning: non_zero_divisors.ne_zero -> nonZeroDivisors.ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : Nontrivial.{u1} M] {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (nonZeroDivisors.{u1} M _inst_1)) -> (Ne.{succ u1} M x (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)))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : Nontrivial.{u1} M] {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (nonZeroDivisors.{u1} M _inst_1)) -> (Ne.{succ u1} M x (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1))))
-Case conversion may be inaccurate. Consider using '#align non_zero_divisors.ne_zero nonZeroDivisors.ne_zeroₓ'. -/
 theorem nonZeroDivisors.ne_zero [Nontrivial M] {x} (hx : x ∈ M⁰) : x ≠ 0 := fun h =>
   one_ne_zero (hx _ <| (one_mul _).trans h)
 #align non_zero_divisors.ne_zero nonZeroDivisors.ne_zero
 
-/- warning: non_zero_divisors.coe_ne_zero -> nonZeroDivisors.coe_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : Nontrivial.{u1} M] (x : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (nonZeroDivisors.{u1} M _inst_1)), Ne.{succ u1} M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (nonZeroDivisors.{u1} M _inst_1)) M (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (nonZeroDivisors.{u1} M _inst_1)) M (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (nonZeroDivisors.{u1} M _inst_1)) M (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (nonZeroDivisors.{u1} M _inst_1)) M (coeSubtype.{succ u1} M (fun (x : M) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (nonZeroDivisors.{u1} M _inst_1)))))) x) (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))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : Nontrivial.{u1} M] (x : Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (nonZeroDivisors.{u1} M _inst_1))), Ne.{succ u1} M (Subtype.val.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x (SetLike.coe.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (nonZeroDivisors.{u1} M _inst_1))) x) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))
-Case conversion may be inaccurate. Consider using '#align non_zero_divisors.coe_ne_zero nonZeroDivisors.coe_ne_zeroₓ'. -/
 theorem nonZeroDivisors.coe_ne_zero [Nontrivial M] (x : M⁰) : (x : M) ≠ 0 :=
   nonZeroDivisors.ne_zero x.2
 #align non_zero_divisors.coe_ne_zero nonZeroDivisors.coe_ne_zero
 
-/- warning: mul_mem_non_zero_divisors -> mul_mem_nonZeroDivisors is a dubious translation:
-lean 3 declaration is
-  forall {M₁ : Type.{u1}} [_inst_3 : CommMonoidWithZero.{u1} M₁] {a : M₁} {b : M₁}, Iff (Membership.Mem.{u1, u1} M₁ (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.setLike.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) (HMul.hMul.{u1, u1, u1} M₁ M₁ M₁ (instHMul.{u1} M₁ (MulZeroClass.toHasMul.{u1} M₁ (MulZeroOneClass.toMulZeroClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) a b) (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))) (And (Membership.Mem.{u1, u1} M₁ (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.setLike.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) a (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))) (Membership.Mem.{u1, u1} M₁ (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.setLike.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) b (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))
-but is expected to have type
-  forall {M₁ : Type.{u1}} [_inst_3 : CommMonoidWithZero.{u1} M₁] {a : M₁} {b : M₁}, Iff (Membership.mem.{u1, u1} M₁ (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.instSetLikeSubmonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) (HMul.hMul.{u1, u1, u1} M₁ M₁ M₁ (instHMul.{u1} M₁ (MulZeroClass.toMul.{u1} M₁ (MulZeroOneClass.toMulZeroClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) a b) (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))) (And (Membership.mem.{u1, u1} M₁ (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.instSetLikeSubmonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) a (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))) (Membership.mem.{u1, u1} M₁ (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) M₁ (Submonoid.instSetLikeSubmonoid.{u1} M₁ (MulZeroOneClass.toMulOneClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))) b (nonZeroDivisors.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))
-Case conversion may be inaccurate. Consider using '#align mul_mem_non_zero_divisors mul_mem_nonZeroDivisorsₓ'. -/
 theorem mul_mem_nonZeroDivisors {a b : M₁} : a * b ∈ M₁⁰ ↔ a ∈ M₁⁰ ∧ b ∈ M₁⁰ :=
   by
   constructor
@@ -176,12 +110,6 @@ theorem mul_mem_nonZeroDivisors {a b : M₁} : a * b ∈ M₁⁰ ↔ a ∈ M₁
     rw [mul_assoc, hx]
 #align mul_mem_non_zero_divisors mul_mem_nonZeroDivisors
 
-/- warning: is_unit_of_mem_non_zero_divisors -> isUnit_of_mem_nonZeroDivisors is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_6 : GroupWithZero.{u1} G₀] {x : G₀}, (Membership.Mem.{u1, u1} G₀ (Submonoid.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_6)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_6)))) G₀ (Submonoid.setLike.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_6))))) x (nonZeroDivisors.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_6))) -> (IsUnit.{u1} G₀ (MonoidWithZero.toMonoid.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_6)) x)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_6 : GroupWithZero.{u1} G₀] {x : G₀}, (Membership.mem.{u1, u1} G₀ (Submonoid.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_6)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_6)))) G₀ (Submonoid.instSetLikeSubmonoid.{u1} G₀ (MulZeroOneClass.toMulOneClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_6))))) x (nonZeroDivisors.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_6))) -> (IsUnit.{u1} G₀ (MonoidWithZero.toMonoid.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_6)) x)
-Case conversion may be inaccurate. Consider using '#align is_unit_of_mem_non_zero_divisors isUnit_of_mem_nonZeroDivisorsₓ'. -/
 theorem isUnit_of_mem_nonZeroDivisors {G₀ : Type _} [GroupWithZero G₀] {x : G₀}
     (hx : x ∈ nonZeroDivisors G₀) : IsUnit x :=
   ⟨⟨x, x⁻¹, mul_inv_cancel (nonZeroDivisors.ne_zero hx),
@@ -189,100 +117,46 @@ theorem isUnit_of_mem_nonZeroDivisors {G₀ : Type _} [GroupWithZero G₀] {x :
     rfl⟩
 #align is_unit_of_mem_non_zero_divisors isUnit_of_mem_nonZeroDivisors
 
-/- warning: eq_zero_of_ne_zero_of_mul_right_eq_zero -> eq_zero_of_ne_zero_of_mul_right_eq_zero is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))] {x : M} {y : M}, (Ne.{succ u1} M x (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 u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) y x) (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 u1} M y (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)))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MonoidWithZero.toZero.{u1} M _inst_1)] {x : M} {y : M}, (Ne.{succ u1} M x (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) y x) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))) -> (Eq.{succ u1} M y (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1))))
-Case conversion may be inaccurate. Consider using '#align eq_zero_of_ne_zero_of_mul_right_eq_zero eq_zero_of_ne_zero_of_mul_right_eq_zeroₓ'. -/
 theorem eq_zero_of_ne_zero_of_mul_right_eq_zero [NoZeroDivisors M] {x y : M} (hnx : x ≠ 0)
     (hxy : y * x = 0) : y = 0 :=
   Or.resolve_right (eq_zero_or_eq_zero_of_mul_eq_zero hxy) hnx
 #align eq_zero_of_ne_zero_of_mul_right_eq_zero eq_zero_of_ne_zero_of_mul_right_eq_zero
 
-/- warning: eq_zero_of_ne_zero_of_mul_left_eq_zero -> eq_zero_of_ne_zero_of_mul_left_eq_zero is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))] {x : M} {y : M}, (Ne.{succ u1} M x (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 u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x y) (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 u1} M y (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)))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MonoidWithZero.toZero.{u1} M _inst_1)] {x : M} {y : M}, (Ne.{succ u1} M x (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x y) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))) -> (Eq.{succ u1} M y (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1))))
-Case conversion may be inaccurate. Consider using '#align eq_zero_of_ne_zero_of_mul_left_eq_zero eq_zero_of_ne_zero_of_mul_left_eq_zeroₓ'. -/
 theorem eq_zero_of_ne_zero_of_mul_left_eq_zero [NoZeroDivisors M] {x y : M} (hnx : x ≠ 0)
     (hxy : x * y = 0) : y = 0 :=
   Or.resolve_left (eq_zero_or_eq_zero_of_mul_eq_zero hxy) hnx
 #align eq_zero_of_ne_zero_of_mul_left_eq_zero eq_zero_of_ne_zero_of_mul_left_eq_zero
 
-/- warning: mem_non_zero_divisors_of_ne_zero -> mem_nonZeroDivisors_of_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))] {x : M}, (Ne.{succ u1} M x (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))))))) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (nonZeroDivisors.{u1} M _inst_1))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MonoidWithZero.toZero.{u1} M _inst_1)] {x : M}, (Ne.{succ u1} M x (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (nonZeroDivisors.{u1} M _inst_1))
-Case conversion may be inaccurate. Consider using '#align mem_non_zero_divisors_of_ne_zero mem_nonZeroDivisors_of_ne_zeroₓ'. -/
 theorem mem_nonZeroDivisors_of_ne_zero [NoZeroDivisors M] {x : M} (hx : x ≠ 0) : x ∈ M⁰ := fun _ =>
   eq_zero_of_ne_zero_of_mul_right_eq_zero hx
 #align mem_non_zero_divisors_of_ne_zero mem_nonZeroDivisors_of_ne_zero
 
-/- warning: mem_non_zero_divisors_iff_ne_zero -> mem_nonZeroDivisors_iff_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))] [_inst_7 : Nontrivial.{u1} M] {x : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (nonZeroDivisors.{u1} M _inst_1)) (Ne.{succ u1} M x (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)))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MonoidWithZero.toZero.{u1} M _inst_1)] [_inst_7 : Nontrivial.{u1} M] {x : M}, Iff (Membership.mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (nonZeroDivisors.{u1} M _inst_1)) (Ne.{succ u1} M x (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1))))
-Case conversion may be inaccurate. Consider using '#align mem_non_zero_divisors_iff_ne_zero mem_nonZeroDivisors_iff_ne_zeroₓ'. -/
 theorem mem_nonZeroDivisors_iff_ne_zero [NoZeroDivisors M] [Nontrivial M] {x : M} :
     x ∈ M⁰ ↔ x ≠ 0 :=
   ⟨nonZeroDivisors.ne_zero, mem_nonZeroDivisors_of_ne_zero⟩
 #align mem_non_zero_divisors_iff_ne_zero mem_nonZeroDivisors_iff_ne_zero
 
-/- warning: map_ne_zero_of_mem_non_zero_divisors -> map_ne_zero_of_mem_nonZeroDivisors is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : Nontrivial.{u1} M] [_inst_7 : ZeroHomClass.{u3, u1, u2} F M M' (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] (g : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (ZeroHomClass.toFunLike.{u3, u1, u2} F M M' (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) _inst_7)) g)) -> (forall {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (nonZeroDivisors.{u1} M _inst_1)) -> (Ne.{succ u2} M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (ZeroHomClass.toFunLike.{u3, u1, u2} F M M' (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) _inst_7)) g x) (OfNat.ofNat.{u2} M' 0 (OfNat.mk.{u2} M' 0 (Zero.zero.{u2} M' (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))))))))
-but is expected to have type
-  forall {M : Type.{u3}} {M' : Type.{u1}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u3} M] [_inst_2 : MonoidWithZero.{u1} M'] [_inst_6 : Nontrivial.{u3} M] [_inst_7 : ZeroHomClass.{u2, u3, u1} F M M' (MonoidWithZero.toZero.{u3} M _inst_1) (MonoidWithZero.toZero.{u1} M' _inst_2)] (g : F), (Function.Injective.{succ u3, succ u1} M M' (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.124 : M) => M') _x) (ZeroHomClass.toFunLike.{u2, u3, u1} F M M' (MonoidWithZero.toZero.{u3} M _inst_1) (MonoidWithZero.toZero.{u1} M' _inst_2) _inst_7) g)) -> (forall {x : M}, (Membership.mem.{u3, u3} M (Submonoid.{u3} M (MulZeroOneClass.toMulOneClass.{u3} M (MonoidWithZero.toMulZeroOneClass.{u3} M _inst_1))) (SetLike.instMembership.{u3, u3} (Submonoid.{u3} M (MulZeroOneClass.toMulOneClass.{u3} M (MonoidWithZero.toMulZeroOneClass.{u3} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u3} M (MulZeroOneClass.toMulOneClass.{u3} M (MonoidWithZero.toMulZeroOneClass.{u3} M _inst_1)))) x (nonZeroDivisors.{u3} M _inst_1)) -> (Ne.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.124 : M) => M') x) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.124 : M) => M') _x) (ZeroHomClass.toFunLike.{u2, u3, u1} F M M' (MonoidWithZero.toZero.{u3} M _inst_1) (MonoidWithZero.toZero.{u1} M' _inst_2) _inst_7) g x) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.124 : M) => M') x) 0 (Zero.toOfNat0.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.124 : M) => M') x) (MonoidWithZero.toZero.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.124 : M) => M') x) _inst_2)))))
-Case conversion may be inaccurate. Consider using '#align map_ne_zero_of_mem_non_zero_divisors map_ne_zero_of_mem_nonZeroDivisorsₓ'. -/
 theorem map_ne_zero_of_mem_nonZeroDivisors [Nontrivial M] [ZeroHomClass F M M'] (g : F)
     (hg : Function.Injective (g : M → M')) {x : M} (h : x ∈ M⁰) : g x ≠ 0 := fun h0 =>
   one_ne_zero (h 1 ((one_mul x).symm ▸ hg (trans h0 (map_zero g).symm)))
 #align map_ne_zero_of_mem_non_zero_divisors map_ne_zero_of_mem_nonZeroDivisors
 
-/- warning: map_mem_non_zero_divisors -> map_mem_nonZeroDivisors is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : Nontrivial.{u1} M] [_inst_7 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_8 : ZeroHomClass.{u3, u1, u2} F M M' (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] (g : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (ZeroHomClass.toFunLike.{u3, u1, u2} F M M' (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) _inst_8)) g)) -> (forall {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) x (nonZeroDivisors.{u1} M _inst_1)) -> (Membership.Mem.{u2, u2} M' (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) M' (Submonoid.setLike.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (ZeroHomClass.toFunLike.{u3, u1, u2} F M M' (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) _inst_8)) g x) (nonZeroDivisors.{u2} M' _inst_2)))
-but is expected to have type
-  forall {M : Type.{u3}} {M' : Type.{u2}} {F : Type.{u1}} [_inst_1 : MonoidWithZero.{u3} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : Nontrivial.{u3} M] [_inst_7 : NoZeroDivisors.{u2} M' (MulZeroClass.toMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidWithZero.toZero.{u2} M' _inst_2)] [_inst_8 : ZeroHomClass.{u1, u3, u2} F M M' (MonoidWithZero.toZero.{u3} M _inst_1) (MonoidWithZero.toZero.{u2} M' _inst_2)] (g : F), (Function.Injective.{succ u3, succ u2} M M' (FunLike.coe.{succ u1, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.124 : M) => M') _x) (ZeroHomClass.toFunLike.{u1, u3, u2} F M M' (MonoidWithZero.toZero.{u3} M _inst_1) (MonoidWithZero.toZero.{u2} M' _inst_2) _inst_8) g)) -> (forall {x : M}, (Membership.mem.{u3, u3} M (Submonoid.{u3} M (MulZeroOneClass.toMulOneClass.{u3} M (MonoidWithZero.toMulZeroOneClass.{u3} M _inst_1))) (SetLike.instMembership.{u3, u3} (Submonoid.{u3} M (MulZeroOneClass.toMulOneClass.{u3} M (MonoidWithZero.toMulZeroOneClass.{u3} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u3} M (MulZeroOneClass.toMulOneClass.{u3} M (MonoidWithZero.toMulZeroOneClass.{u3} M _inst_1)))) x (nonZeroDivisors.{u3} M _inst_1)) -> (Membership.mem.{u2, u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.124 : M) => M') x) (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) M' (Submonoid.instSetLikeSubmonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))) (FunLike.coe.{succ u1, succ u3, succ u2} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.124 : M) => M') _x) (ZeroHomClass.toFunLike.{u1, u3, u2} F M M' (MonoidWithZero.toZero.{u3} M _inst_1) (MonoidWithZero.toZero.{u2} M' _inst_2) _inst_8) g x) (nonZeroDivisors.{u2} M' _inst_2)))
-Case conversion may be inaccurate. Consider using '#align map_mem_non_zero_divisors map_mem_nonZeroDivisorsₓ'. -/
 theorem map_mem_nonZeroDivisors [Nontrivial M] [NoZeroDivisors M'] [ZeroHomClass F M M'] (g : F)
     (hg : Function.Injective g) {x : M} (h : x ∈ M⁰) : g x ∈ M'⁰ := fun z hz =>
   eq_zero_of_ne_zero_of_mul_right_eq_zero (map_ne_zero_of_mem_nonZeroDivisors g hg h) hz
 #align map_mem_non_zero_divisors map_mem_nonZeroDivisors
 
-/- warning: le_non_zero_divisors_of_no_zero_divisors -> le_nonZeroDivisors_of_noZeroDivisors is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))] {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (Not (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (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)))))) S)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) S (nonZeroDivisors.{u1} M _inst_1))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MonoidWithZero.toZero.{u1} M _inst_1)] {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (Not (Membership.mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1))) S)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) S (nonZeroDivisors.{u1} M _inst_1))
-Case conversion may be inaccurate. Consider using '#align le_non_zero_divisors_of_no_zero_divisors le_nonZeroDivisors_of_noZeroDivisorsₓ'. -/
 theorem le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {S : Submonoid M}
     (hS : (0 : M) ∉ S) : S ≤ M⁰ := fun x hx y hy =>
   Or.rec_on (eq_zero_or_eq_zero_of_mul_eq_zero hy) (fun h => h) fun h =>
     absurd (h ▸ hx : (0 : M) ∈ S) hS
 #align le_non_zero_divisors_of_no_zero_divisors le_nonZeroDivisors_of_noZeroDivisors
 
-/- warning: powers_le_non_zero_divisors_of_no_zero_divisors -> powers_le_nonZeroDivisors_of_noZeroDivisors is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))] {a : M}, (Ne.{succ u1} M 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))))))) -> (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1)))))) (Submonoid.powers.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1) a) (nonZeroDivisors.{u1} M _inst_1))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MonoidWithZero.toZero.{u1} M _inst_1)] {a : M}, (Ne.{succ u1} M a (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))) -> (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))))))) (Submonoid.powers.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1) a) (nonZeroDivisors.{u1} M _inst_1))
-Case conversion may be inaccurate. Consider using '#align powers_le_non_zero_divisors_of_no_zero_divisors powers_le_nonZeroDivisors_of_noZeroDivisorsₓ'. -/
 theorem powers_le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {a : M} (ha : a ≠ 0) :
     Submonoid.powers a ≤ M⁰ :=
   le_nonZeroDivisors_of_noZeroDivisors fun h => absurd (h.recOn fun _ hn => pow_eq_zero hn) ha
 #align powers_le_non_zero_divisors_of_no_zero_divisors powers_le_nonZeroDivisors_of_noZeroDivisors
 
-/- warning: map_le_non_zero_divisors_of_injective -> map_le_nonZeroDivisors_of_injective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_7 : MonoidWithZeroHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (MulHomClass.toFunLike.{u3, u1, u2} F M M' (MulOneClass.toHasMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toHasMul.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7)))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (Preorder.toHasLe.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) M' (Submonoid.setLike.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))))) (Submonoid.map.{u1, u2, u3} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u2} M' _inst_2)))
-but is expected to have type
-  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Preorder.toLE.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (PartialOrder.toPreorder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))))))) (Submonoid.map.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u3} M' _inst_2)))
-Case conversion may be inaccurate. Consider using '#align map_le_non_zero_divisors_of_injective map_le_nonZeroDivisors_of_injectiveₓ'. -/
 theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroHomClass F M M']
     (f : F) (hf : Function.Injective f) {S : Submonoid M} (hS : S ≤ M⁰) : S.map f ≤ M'⁰ :=
   by
@@ -296,23 +170,11 @@ theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroH
           (hS (hf (trans hx0 (map_zero f).symm) ▸ hx : 0 ∈ S) 1 (MulZeroClass.mul_zero 1)).symm
 #align map_le_non_zero_divisors_of_injective map_le_nonZeroDivisors_of_injective
 
-/- warning: non_zero_divisors_le_comap_non_zero_divisors_of_injective -> nonZeroDivisors_le_comap_nonZeroDivisors_of_injective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_7 : MonoidWithZeroHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (MulHomClass.toFunLike.{u3, u1, u2} F M M' (MulOneClass.toHasMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toHasMul.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7)))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u2, u3} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7) f (nonZeroDivisors.{u2} M' _inst_2)))
-but is expected to have type
-  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f (nonZeroDivisors.{u3} M' _inst_2)))
-Case conversion may be inaccurate. Consider using '#align non_zero_divisors_le_comap_non_zero_divisors_of_injective nonZeroDivisors_le_comap_nonZeroDivisors_of_injectiveₓ'. -/
 theorem nonZeroDivisors_le_comap_nonZeroDivisors_of_injective [NoZeroDivisors M']
     [MonoidWithZeroHomClass F M M'] (f : F) (hf : Function.Injective f) : M⁰ ≤ M'⁰.comap f :=
   Submonoid.le_comap_of_map_le _ (map_le_nonZeroDivisors_of_injective _ hf le_rfl)
 #align non_zero_divisors_le_comap_non_zero_divisors_of_injective nonZeroDivisors_le_comap_nonZeroDivisors_of_injective
 
-/- warning: prod_zero_iff_exists_zero -> prod_zero_iff_exists_zero is a dubious translation:
-lean 3 declaration is
-  forall {M₁ : Type.{u1}} [_inst_3 : CommMonoidWithZero.{u1} M₁] [_inst_6 : NoZeroDivisors.{u1} M₁ (MulZeroClass.toHasMul.{u1} M₁ (MulZeroOneClass.toMulZeroClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (MulZeroClass.toHasZero.{u1} M₁ (MulZeroOneClass.toMulZeroClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))] [_inst_7 : Nontrivial.{u1} M₁] {s : Multiset.{u1} M₁}, Iff (Eq.{succ u1} M₁ (Multiset.prod.{u1} M₁ (CommMonoidWithZero.toCommMonoid.{u1} M₁ _inst_3) s) (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₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))))))) (Exists.{succ u1} M₁ (fun (r : M₁) => Exists.{0} (Membership.Mem.{u1, u1} M₁ (Multiset.{u1} M₁) (Multiset.hasMem.{u1} M₁) r s) (fun (hr : Membership.Mem.{u1, u1} M₁ (Multiset.{u1} M₁) (Multiset.hasMem.{u1} M₁) r s) => Eq.{succ u1} M₁ r (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₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3))))))))))
-but is expected to have type
-  forall {M₁ : Type.{u1}} [_inst_3 : CommMonoidWithZero.{u1} M₁] [_inst_6 : NoZeroDivisors.{u1} M₁ (MulZeroClass.toMul.{u1} M₁ (MulZeroOneClass.toMulZeroClass.{u1} M₁ (MonoidWithZero.toMulZeroOneClass.{u1} M₁ (CommMonoidWithZero.toMonoidWithZero.{u1} M₁ _inst_3)))) (CommMonoidWithZero.toZero.{u1} M₁ _inst_3)] [_inst_7 : Nontrivial.{u1} M₁] {s : Multiset.{u1} M₁}, Iff (Eq.{succ u1} M₁ (Multiset.prod.{u1} M₁ (CommMonoidWithZero.toCommMonoid.{u1} M₁ _inst_3) s) (OfNat.ofNat.{u1} M₁ 0 (Zero.toOfNat0.{u1} M₁ (CommMonoidWithZero.toZero.{u1} M₁ _inst_3)))) (Exists.{succ u1} M₁ (fun (r : M₁) => Exists.{0} (Membership.mem.{u1, u1} M₁ (Multiset.{u1} M₁) (Multiset.instMembershipMultiset.{u1} M₁) r s) (fun (hr : Membership.mem.{u1, u1} M₁ (Multiset.{u1} M₁) (Multiset.instMembershipMultiset.{u1} M₁) r s) => Eq.{succ u1} M₁ r (OfNat.ofNat.{u1} M₁ 0 (Zero.toOfNat0.{u1} M₁ (CommMonoidWithZero.toZero.{u1} M₁ _inst_3))))))
-Case conversion may be inaccurate. Consider using '#align prod_zero_iff_exists_zero prod_zero_iff_exists_zeroₓ'. -/
 theorem prod_zero_iff_exists_zero [NoZeroDivisors M₁] [Nontrivial M₁] {s : Multiset M₁} :
     s.Prod = 0 ↔ ∃ (r : M₁)(hr : r ∈ s), r = 0 :=
   by

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

@@ -113,10 +113,7 @@ theorem mul_cancel_right_mem_nonZeroDivisors {x y r : R} (hr : r ∈ R⁰) : x *
 #align mul_cancel_right_mem_non_zero_divisor mul_cancel_right_mem_nonZeroDivisors
 
 /- warning: mul_cancel_right_coe_non_zero_divisor -> mul_cancel_right_coe_nonZeroDivisors is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] {x : R} {y : R} {c : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))}, Iff (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_4))) x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) x (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))))) c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_4))) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))) R (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))) R (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))) R (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))) R (coeSubtype.{succ u1} R (fun (x : R) => Membership.Mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.setLike.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) x (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))))) c))) (Eq.{succ u1} R x y)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] {x : R} {y : R} {c : Subtype.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))) x (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))}, Iff (Eq.{succ u1} R (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))) x (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) c)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))) y (Subtype.val.{succ u1} R (fun (x : R) => Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) x (SetLike.coe.{u1, u1} (Submonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) R (Submonoid.instSetLikeSubmonoid.{u1} R (MulZeroOneClass.toMulOneClass.{u1} R (MonoidWithZero.toMulZeroOneClass.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) (nonZeroDivisors.{u1} R (Semiring.toMonoidWithZero.{u1} R (Ring.toSemiring.{u1} R _inst_4))))) c))) (Eq.{succ u1} R x y)
+<too large>
 Case conversion may be inaccurate. Consider using '#align mul_cancel_right_coe_non_zero_divisor mul_cancel_right_coe_nonZeroDivisorsₓ'. -/
 theorem mul_cancel_right_coe_nonZeroDivisors {x y : R} {c : R⁰} : x * c = y * c ↔ x = y :=
   mul_cancel_right_mem_nonZeroDivisors c.Prop
@@ -134,10 +131,7 @@ theorem mul_cancel_left_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : r
 #align mul_cancel_left_mem_non_zero_divisor mul_cancel_left_mem_nonZeroDivisors
 
 /- warning: mul_cancel_left_coe_non_zero_divisor -> mul_cancel_left_coe_nonZeroDivisors is a dubious translation:
-lean 3 declaration is
-  forall {R' : Type.{u1}} [_inst_5 : CommRing.{u1} R'] {x : R'} {y : R'} {c : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))}, Iff (Eq.{succ u1} R' (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (Distrib.toHasMul.{u1} R' (Ring.toDistrib.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (coeSubtype.{succ u1} R' (fun (x : R') => Membership.Mem.{u1, u1} R' (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) x (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))))) c) x) (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (Distrib.toHasMul.{u1} R' (Ring.toDistrib.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (coeSubtype.{succ u1} R' (fun (x : R') => Membership.Mem.{u1, u1} R' (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) x (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))))) c) y)) (Eq.{succ u1} R' x y)
-but is expected to have type
-  forall {R' : Type.{u1}} [_inst_5 : CommRing.{u1} R'] {x : R'} {y : R'} {c : Subtype.{succ u1} R' (fun (x : R') => Membership.mem.{u1, u1} R' (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) R' (Submonoid.instSetLikeSubmonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5))))))) x (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))}, Iff (Eq.{succ u1} R' (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (NonUnitalNonAssocRing.toMul.{u1} R' (NonAssocRing.toNonUnitalNonAssocRing.{u1} R' (Ring.toNonAssocRing.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) (Subtype.val.{succ u1} R' (fun (x : R') => Membership.mem.{u1, u1} R' (Set.{u1} R') (Set.instMembershipSet.{u1} R') x (SetLike.coe.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) R' (Submonoid.instSetLikeSubmonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) c) x) (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (NonUnitalNonAssocRing.toMul.{u1} R' (NonAssocRing.toNonUnitalNonAssocRing.{u1} R' (Ring.toNonAssocRing.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) (Subtype.val.{succ u1} R' (fun (x : R') => Membership.mem.{u1, u1} R' (Set.{u1} R') (Set.instMembershipSet.{u1} R') x (SetLike.coe.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) R' (Submonoid.instSetLikeSubmonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) c) y)) (Eq.{succ u1} R' x y)
+<too large>
 Case conversion may be inaccurate. Consider using '#align mul_cancel_left_coe_non_zero_divisor mul_cancel_left_coe_nonZeroDivisorsₓ'. -/
 theorem mul_cancel_left_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : (c : R') * x = c * y ↔ x = y :=
   mul_cancel_left_mem_nonZeroDivisors c.Prop

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

@@ -287,7 +287,7 @@ theorem powers_le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {a : M} (
 lean 3 declaration is
   forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_7 : MonoidWithZeroHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (MulHomClass.toFunLike.{u3, u1, u2} F M M' (MulOneClass.toHasMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toHasMul.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7)))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (Preorder.toHasLe.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) M' (Submonoid.setLike.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))))) (Submonoid.map.{u1, u2, u3} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u2} M' _inst_2)))
 but is expected to have type
-  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Preorder.toLE.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (PartialOrder.toPreorder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))))))) (Submonoid.map.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u3} M' _inst_2)))
+  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Preorder.toLE.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (PartialOrder.toPreorder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))))))) (Submonoid.map.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u3} M' _inst_2)))
 Case conversion may be inaccurate. Consider using '#align map_le_non_zero_divisors_of_injective map_le_nonZeroDivisors_of_injectiveₓ'. -/
 theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroHomClass F M M']
     (f : F) (hf : Function.Injective f) {S : Submonoid M} (hS : S ≤ M⁰) : S.map f ≤ M'⁰ :=
@@ -306,7 +306,7 @@ theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroH
 lean 3 declaration is
   forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_7 : MonoidWithZeroHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (MulHomClass.toFunLike.{u3, u1, u2} F M M' (MulOneClass.toHasMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toHasMul.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7)))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u2, u3} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7) f (nonZeroDivisors.{u2} M' _inst_2)))
 but is expected to have type
-  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f (nonZeroDivisors.{u3} M' _inst_2)))
+  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f (nonZeroDivisors.{u3} M' _inst_2)))
 Case conversion may be inaccurate. Consider using '#align non_zero_divisors_le_comap_non_zero_divisors_of_injective nonZeroDivisors_le_comap_nonZeroDivisors_of_injectiveₓ'. -/
 theorem nonZeroDivisors_le_comap_nonZeroDivisors_of_injective [NoZeroDivisors M']
     [MonoidWithZeroHomClass F M M'] (f : F) (hf : Function.Injective f) : M⁰ ≤ M'⁰.comap f :=

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

@@ -262,7 +262,7 @@ theorem map_mem_nonZeroDivisors [Nontrivial M] [NoZeroDivisors M'] [ZeroHomClass
 
 /- warning: le_non_zero_divisors_of_no_zero_divisors -> le_nonZeroDivisors_of_noZeroDivisors is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))] {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (Not (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (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)))))) S)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) S (nonZeroDivisors.{u1} M _inst_1))
+  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))] {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (Not (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (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)))))) S)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) S (nonZeroDivisors.{u1} M _inst_1))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MonoidWithZero.toZero.{u1} M _inst_1)] {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (Not (Membership.mem.{u1, u1} M (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.instSetLikeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1))) S)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) S (nonZeroDivisors.{u1} M _inst_1))
 Case conversion may be inaccurate. Consider using '#align le_non_zero_divisors_of_no_zero_divisors le_nonZeroDivisors_of_noZeroDivisorsₓ'. -/
@@ -274,7 +274,7 @@ theorem le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {S : Submonoid M
 
 /- warning: powers_le_non_zero_divisors_of_no_zero_divisors -> powers_le_nonZeroDivisors_of_noZeroDivisors is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))] {a : M}, (Ne.{succ u1} M 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))))))) -> (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1)))))) (Submonoid.powers.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1) a) (nonZeroDivisors.{u1} M _inst_1))
+  forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulZeroClass.toHasZero.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))] {a : M}, (Ne.{succ u1} M 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))))))) -> (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1)))))) (Submonoid.powers.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1) a) (nonZeroDivisors.{u1} M _inst_1))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_6 : NoZeroDivisors.{u1} M (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MonoidWithZero.toZero.{u1} M _inst_1)] {a : M}, (Ne.{succ u1} M a (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MonoidWithZero.toZero.{u1} M _inst_1)))) -> (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1))))))) (Submonoid.powers.{u1} M (MonoidWithZero.toMonoid.{u1} M _inst_1) a) (nonZeroDivisors.{u1} M _inst_1))
 Case conversion may be inaccurate. Consider using '#align powers_le_non_zero_divisors_of_no_zero_divisors powers_le_nonZeroDivisors_of_noZeroDivisorsₓ'. -/
@@ -285,7 +285,7 @@ theorem powers_le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {a : M} (
 
 /- warning: map_le_non_zero_divisors_of_injective -> map_le_nonZeroDivisors_of_injective is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_7 : MonoidWithZeroHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (MulHomClass.toFunLike.{u3, u1, u2} F M M' (MulOneClass.toHasMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toHasMul.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7)))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (Preorder.toLE.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) M' (Submonoid.setLike.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))))) (Submonoid.map.{u1, u2, u3} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u2} M' _inst_2)))
+  forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_7 : MonoidWithZeroHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (MulHomClass.toFunLike.{u3, u1, u2} F M M' (MulOneClass.toHasMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toHasMul.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7)))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (Preorder.toHasLe.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) M' (Submonoid.setLike.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))))) (Submonoid.map.{u1, u2, u3} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u2} M' _inst_2)))
 but is expected to have type
   forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Preorder.toLE.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (PartialOrder.toPreorder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))))))) (Submonoid.map.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u3} M' _inst_2)))
 Case conversion may be inaccurate. Consider using '#align map_le_non_zero_divisors_of_injective map_le_nonZeroDivisors_of_injectiveₓ'. -/
@@ -304,7 +304,7 @@ theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroH
 
 /- warning: non_zero_divisors_le_comap_non_zero_divisors_of_injective -> nonZeroDivisors_le_comap_nonZeroDivisors_of_injective is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_7 : MonoidWithZeroHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (MulHomClass.toFunLike.{u3, u1, u2} F M M' (MulOneClass.toHasMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toHasMul.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7)))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u2, u3} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7) f (nonZeroDivisors.{u2} M' _inst_2)))
+  forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_7 : MonoidWithZeroHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (MulHomClass.toFunLike.{u3, u1, u2} F M M' (MulOneClass.toHasMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toHasMul.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7)))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u2, u3} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7) f (nonZeroDivisors.{u2} M' _inst_2)))
 but is expected to have type
   forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f (nonZeroDivisors.{u3} M' _inst_2)))
 Case conversion may be inaccurate. Consider using '#align non_zero_divisors_le_comap_non_zero_divisors_of_injective nonZeroDivisors_le_comap_nonZeroDivisors_of_injectiveₓ'. -/

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

@@ -126,7 +126,7 @@ theorem mul_cancel_right_coe_nonZeroDivisors {x y : R} {c : R⁰} : x * c = y *
 lean 3 declaration is
   forall {R' : Type.{u1}} [_inst_5 : CommRing.{u1} R'] {x : R'} {y : R'} {r : R'}, (Membership.Mem.{u1, u1} R' (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) r (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) -> (Iff (Eq.{succ u1} R' (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (Distrib.toHasMul.{u1} R' (Ring.toDistrib.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))) r x) (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (Distrib.toHasMul.{u1} R' (Ring.toDistrib.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))) r y)) (Eq.{succ u1} R' x y))
 but is expected to have type
-  forall {R' : Type.{u1}} [_inst_5 : CommRing.{u1} R'] {x : R'} {y : R'} {r : R'}, (Membership.mem.{u1, u1} R' (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.instSetLikeSubmonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) r (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) -> (Iff (Eq.{succ u1} R' (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (NonUnitalNonAssocRing.toMul.{u1} R' (NonAssocRing.toNonUnitalNonAssocRing.{u1} R' (Ring.toNonAssocRing.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) r x) (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (NonUnitalNonAssocRing.toMul.{u1} R' (NonAssocRing.toNonUnitalNonAssocRing.{u1} R' (Ring.toNonAssocRing.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) r y)) (Eq.{succ u1} R' x y))
+  forall {R' : Type.{u1}} [_inst_5 : CommRing.{u1} R'] {x : R'} {y : R'} {r : R'}, (Membership.mem.{u1, u1} R' (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) R' (Submonoid.instSetLikeSubmonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5))))))) r (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5))))) -> (Iff (Eq.{succ u1} R' (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (NonUnitalNonAssocRing.toMul.{u1} R' (NonAssocRing.toNonUnitalNonAssocRing.{u1} R' (Ring.toNonAssocRing.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) r x) (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (NonUnitalNonAssocRing.toMul.{u1} R' (NonAssocRing.toNonUnitalNonAssocRing.{u1} R' (Ring.toNonAssocRing.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) r y)) (Eq.{succ u1} R' x y))
 Case conversion may be inaccurate. Consider using '#align mul_cancel_left_mem_non_zero_divisor mul_cancel_left_mem_nonZeroDivisorsₓ'. -/
 @[simp]
 theorem mul_cancel_left_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : r * x = r * y ↔ x = y :=
@@ -137,7 +137,7 @@ theorem mul_cancel_left_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : r
 lean 3 declaration is
   forall {R' : Type.{u1}} [_inst_5 : CommRing.{u1} R'] {x : R'} {y : R'} {c : coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))}, Iff (Eq.{succ u1} R' (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (Distrib.toHasMul.{u1} R' (Ring.toDistrib.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (coeSubtype.{succ u1} R' (fun (x : R') => Membership.Mem.{u1, u1} R' (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) x (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))))) c) x) (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (Distrib.toHasMul.{u1} R' (Ring.toDistrib.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) R' (coeSubtype.{succ u1} R' (fun (x : R') => Membership.Mem.{u1, u1} R' (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.setLike.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) x (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))))) c) y)) (Eq.{succ u1} R' x y)
 but is expected to have type
-  forall {R' : Type.{u1}} [_inst_5 : CommRing.{u1} R'] {x : R'} {y : R'} {c : Subtype.{succ u1} R' (fun (x : R') => Membership.mem.{u1, u1} R' (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.instSetLikeSubmonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))))) x (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))}, Iff (Eq.{succ u1} R' (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (NonUnitalNonAssocRing.toMul.{u1} R' (NonAssocRing.toNonUnitalNonAssocRing.{u1} R' (Ring.toNonAssocRing.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) (Subtype.val.{succ u1} R' (fun (x : R') => Membership.mem.{u1, u1} R' (Set.{u1} R') (Set.instMembershipSet.{u1} R') x (SetLike.coe.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.instSetLikeSubmonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) c) x) (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (NonUnitalNonAssocRing.toMul.{u1} R' (NonAssocRing.toNonUnitalNonAssocRing.{u1} R' (Ring.toNonAssocRing.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) (Subtype.val.{succ u1} R' (fun (x : R') => Membership.mem.{u1, u1} R' (Set.{u1} R') (Set.instMembershipSet.{u1} R') x (SetLike.coe.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) R' (Submonoid.instSetLikeSubmonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (Ring.toSemiring.{u1} R' (CommRing.toRing.{u1} R' _inst_5)))))) c) y)) (Eq.{succ u1} R' x y)
+  forall {R' : Type.{u1}} [_inst_5 : CommRing.{u1} R'] {x : R'} {y : R'} {c : Subtype.{succ u1} R' (fun (x : R') => Membership.mem.{u1, u1} R' (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) R' (Submonoid.instSetLikeSubmonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5))))))) x (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))}, Iff (Eq.{succ u1} R' (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (NonUnitalNonAssocRing.toMul.{u1} R' (NonAssocRing.toNonUnitalNonAssocRing.{u1} R' (Ring.toNonAssocRing.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) (Subtype.val.{succ u1} R' (fun (x : R') => Membership.mem.{u1, u1} R' (Set.{u1} R') (Set.instMembershipSet.{u1} R') x (SetLike.coe.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) R' (Submonoid.instSetLikeSubmonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) c) x) (HMul.hMul.{u1, u1, u1} R' R' R' (instHMul.{u1} R' (NonUnitalNonAssocRing.toMul.{u1} R' (NonAssocRing.toNonUnitalNonAssocRing.{u1} R' (Ring.toNonAssocRing.{u1} R' (CommRing.toRing.{u1} R' _inst_5))))) (Subtype.val.{succ u1} R' (fun (x : R') => Membership.mem.{u1, u1} R' (Set.{u1} R') (Set.instMembershipSet.{u1} R') x (SetLike.coe.{u1, u1} (Submonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) R' (Submonoid.instSetLikeSubmonoid.{u1} R' (MulZeroOneClass.toMulOneClass.{u1} R' (MonoidWithZero.toMulZeroOneClass.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) (nonZeroDivisors.{u1} R' (Semiring.toMonoidWithZero.{u1} R' (CommSemiring.toSemiring.{u1} R' (CommRing.toCommSemiring.{u1} R' _inst_5)))))) c) y)) (Eq.{succ u1} R' x y)
 Case conversion may be inaccurate. Consider using '#align mul_cancel_left_coe_non_zero_divisor mul_cancel_left_coe_nonZeroDivisorsₓ'. -/
 theorem mul_cancel_left_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : (c : R') * x = c * y ↔ x = y :=
   mul_cancel_left_mem_nonZeroDivisors c.Prop

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

@@ -287,7 +287,7 @@ theorem powers_le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {a : M} (
 lean 3 declaration is
   forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_7 : MonoidWithZeroHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (MulHomClass.toFunLike.{u3, u1, u2} F M M' (MulOneClass.toHasMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toHasMul.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7)))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (Preorder.toLE.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) M' (Submonoid.setLike.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))))) (Submonoid.map.{u1, u2, u3} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u2} M' _inst_2)))
 but is expected to have type
-  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Preorder.toLE.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (PartialOrder.toPreorder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))))))) (Submonoid.map.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u3} M' _inst_2)))
+  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Preorder.toLE.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (PartialOrder.toPreorder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))))))) (Submonoid.map.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u3} M' _inst_2)))
 Case conversion may be inaccurate. Consider using '#align map_le_non_zero_divisors_of_injective map_le_nonZeroDivisors_of_injectiveₓ'. -/
 theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroHomClass F M M']
     (f : F) (hf : Function.Injective f) {S : Submonoid M} (hS : S ≤ M⁰) : S.map f ≤ M'⁰ :=
@@ -306,7 +306,7 @@ theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroH
 lean 3 declaration is
   forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_7 : MonoidWithZeroHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (MulHomClass.toFunLike.{u3, u1, u2} F M M' (MulOneClass.toHasMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toHasMul.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7)))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u2, u3} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7) f (nonZeroDivisors.{u2} M' _inst_2)))
 but is expected to have type
-  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f (nonZeroDivisors.{u3} M' _inst_2)))
+  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f (nonZeroDivisors.{u3} M' _inst_2)))
 Case conversion may be inaccurate. Consider using '#align non_zero_divisors_le_comap_non_zero_divisors_of_injective nonZeroDivisors_le_comap_nonZeroDivisors_of_injectiveₓ'. -/
 theorem nonZeroDivisors_le_comap_nonZeroDivisors_of_injective [NoZeroDivisors M']
     [MonoidWithZeroHomClass F M M'] (f : F) (hf : Function.Injective f) : M⁰ ≤ M'⁰.comap f :=

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

@@ -174,8 +174,8 @@ theorem mul_mem_nonZeroDivisors {a b : M₁} : a * b ∈ M₁⁰ ↔ a ∈ M₁
   constructor
   · intro h
     constructor <;> intro x h' <;> apply h
-    · rw [← mul_assoc, h', zero_mul]
-    · rw [mul_comm a b, ← mul_assoc, h', zero_mul]
+    · rw [← mul_assoc, h', MulZeroClass.zero_mul]
+    · rw [mul_comm a b, ← mul_assoc, h', MulZeroClass.zero_mul]
   · rintro ⟨ha, hb⟩ x hx
     apply ha
     apply hb
@@ -298,7 +298,8 @@ theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroH
     exact
       le_nonZeroDivisors_of_noZeroDivisors fun h =>
         let ⟨x, hx, hx0⟩ := h
-        zero_ne_one (hS (hf (trans hx0 (map_zero f).symm) ▸ hx : 0 ∈ S) 1 (mul_zero 1)).symm
+        zero_ne_one
+          (hS (hf (trans hx0 (map_zero f).symm) ▸ hx : 0 ∈ S) 1 (MulZeroClass.mul_zero 1)).symm
 #align map_le_non_zero_divisors_of_injective map_le_nonZeroDivisors_of_injective
 
 /- warning: non_zero_divisors_le_comap_non_zero_divisors_of_injective -> nonZeroDivisors_le_comap_nonZeroDivisors_of_injective is a dubious translation:

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

@@ -287,7 +287,7 @@ theorem powers_le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {a : M} (
 lean 3 declaration is
   forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_7 : MonoidWithZeroHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (MulHomClass.toFunLike.{u3, u1, u2} F M M' (MulOneClass.toHasMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toHasMul.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7)))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (Preorder.toLE.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) M' (Submonoid.setLike.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))))) (Submonoid.map.{u1, u2, u3} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u2} M' _inst_2)))
 but is expected to have type
-  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Preorder.toLE.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (PartialOrder.toPreorder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))))))) (Submonoid.map.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u3} M' _inst_2)))
+  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (forall {S : Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))}, (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) S (nonZeroDivisors.{u1} M _inst_1)) -> (LE.le.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Preorder.toLE.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (PartialOrder.toPreorder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Submonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))))))) (Submonoid.map.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f S) (nonZeroDivisors.{u3} M' _inst_2)))
 Case conversion may be inaccurate. Consider using '#align map_le_non_zero_divisors_of_injective map_le_nonZeroDivisors_of_injectiveₓ'. -/
 theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroHomClass F M M']
     (f : F) (hf : Function.Injective f) {S : Submonoid M} (hS : S ≤ M⁰) : S.map f ≤ M'⁰ :=
@@ -305,7 +305,7 @@ theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroH
 lean 3 declaration is
   forall {M : Type.{u1}} {M' : Type.{u2}} {F : Type.{u3}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u2} M'] [_inst_6 : NoZeroDivisors.{u2} M' (MulZeroClass.toHasMul.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MulZeroClass.toHasZero.{u2} M' (MulZeroOneClass.toMulZeroClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)))] [_inst_7 : MonoidWithZeroHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> M') (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => M') (MulHomClass.toFunLike.{u3, u1, u2} F M M' (MulOneClass.toHasMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toHasMul.{u2} M' (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7)))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) M (Submonoid.setLike.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u2, u3} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u2} M' (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u3, u1, u2} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u2} M' _inst_2) _inst_7) f (nonZeroDivisors.{u2} M' _inst_2)))
 but is expected to have type
-  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f (nonZeroDivisors.{u3} M' _inst_2)))
+  forall {M : Type.{u1}} {M' : Type.{u3}} {F : Type.{u2}} [_inst_1 : MonoidWithZero.{u1} M] [_inst_2 : MonoidWithZero.{u3} M'] [_inst_6 : NoZeroDivisors.{u3} M' (MulZeroClass.toMul.{u3} M' (MulZeroOneClass.toMulZeroClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidWithZero.toZero.{u3} M' _inst_2)] [_inst_7 : MonoidWithZeroHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)] (f : F), (Function.Injective.{succ u1, succ u3} M M' (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M') _x) (MulHomClass.toFunLike.{u2, u1, u3} F M M' (MulOneClass.toMul.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (MulOneClass.toMul.{u3} M' (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2))) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7))) f)) -> (LE.le.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1))))))) (nonZeroDivisors.{u1} M _inst_1) (Submonoid.comap.{u1, u3, u2} M M' (MulZeroOneClass.toMulOneClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1)) (MulZeroOneClass.toMulOneClass.{u3} M' (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2)) F (MonoidWithZeroHomClass.toMonoidHomClass.{u2, u1, u3} F M M' (MonoidWithZero.toMulZeroOneClass.{u1} M _inst_1) (MonoidWithZero.toMulZeroOneClass.{u3} M' _inst_2) _inst_7) f (nonZeroDivisors.{u3} M' _inst_2)))
 Case conversion may be inaccurate. Consider using '#align non_zero_divisors_le_comap_non_zero_divisors_of_injective nonZeroDivisors_le_comap_nonZeroDivisors_of_injectiveₓ'. -/
 theorem nonZeroDivisors_le_comap_nonZeroDivisors_of_injective [NoZeroDivisors M']
     [MonoidWithZeroHomClass F M M'] (f : F) (hf : Function.Injective f) : M⁰ ≤ M'⁰.comap f :=

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

@@ -8,6 +8,7 @@ import Mathlib.GroupTheory.Submonoid.Operations
 import Mathlib.GroupTheory.Submonoid.Membership
 import Mathlib.GroupTheory.Submonoid.MulOpposite
 import Mathlib.GroupTheory.GroupAction.Opposite
+import Mathlib.Algebra.Ring.Opposite
 
 #align_import ring_theory.non_zero_divisors from "leanprover-community/mathlib"@"1126441d6bccf98c81214a0780c73d499f6721fe"
 

Purely automatic replacement. If this is in any way controversial; I'm happy to just close this PR.

@@ -88,7 +88,7 @@ def nonZeroDivisors (R : Type*) [MonoidWithZero R] : Submonoid R where
 scoped[nonZeroDivisors] notation:9000 R "⁰" => nonZeroDivisors R
 
 /-- Let `R` be a monoid with zero and `M` an additive monoid with an `R`-action, then the collection
-of non-zero smul-divisors forms a submonoid. These elements are also called `M`-regular.-/
+of non-zero smul-divisors forms a submonoid. These elements are also called `M`-regular. -/
 def nonZeroSMulDivisors (R : Type*) [MonoidWithZero R] (M : Type _) [Zero M] [MulAction R M] :
     Submonoid R where
   carrier := { r | ∀ m : M, r • m = 0 → m = 0}

Take the content of

• some of Algebra.BigOperators.List.Basic
• some of Algebra.BigOperators.List.Lemmas
• some of Algebra.BigOperators.Multiset.Basic
• some of Algebra.BigOperators.Multiset.Lemmas
• Algebra.BigOperators.Multiset.Order
• Algebra.BigOperators.Order

and sort it into six files:

• Algebra.Order.BigOperators.Group.List. I credit Yakov for https://github.com/leanprover-community/mathlib/pull/8543.
• Algebra.Order.BigOperators.Group.Multiset. Copyright inherited from Algebra.BigOperators.Multiset.Order.
• Algebra.Order.BigOperators.Group.Finset. Copyright inherited from Algebra.BigOperators.Order.
• Algebra.Order.BigOperators.Ring.List. I credit Stuart for https://github.com/leanprover-community/mathlib/pull/10184.
• Algebra.Order.BigOperators.Ring.Multiset. I credit Ruben for https://github.com/leanprover-community/mathlib/pull/8787.
• Algebra.Order.BigOperators.Ring.Finset. I credit Floris for https://github.com/leanprover-community/mathlib/pull/1294.

Here are the design decisions at play:

• Pure algebra and big operators algebra shouldn't import (algebraic) order theory. This PR makes that better, but not perfect because we still import Data.Nat.Order.Basic in a few List files.
• It's Algebra.Order.BigOperators instead of Algebra.BigOperators.Order because algebraic order theory is more of a theory than big operators algebra. Another reason is that algebraic order theory is the only way to mix pure order and pure algebra, while there are more ways to mix pure finiteness and pure algebra than just big operators.
• There are separate files for group/monoid lemmas vs ring lemmas. Groups/monoids are the natural setup for big operators, so their lemmas shouldn't be mixed with ring lemmas that involves both addition and multiplication. As a result, everything under Algebra.Order.BigOperators.Group should be additivisable (except a few Nat- or Int-specific lemmas). In contrast, things under Algebra.Order.BigOperators.Ring are more prone to having heavy imports.
• Lemmas are separated according to List vs Multiset vs Finset. This is not strictly necessary, and can be relaxed in cases where there aren't that many lemmas to be had. As an example, I could split out the AbsoluteValue lemmas from Algebra.Order.BigOperators.Ring.Finset to a file Algebra.Order.BigOperators.Ring.AbsoluteValue and it could stay this way until too many lemmas are in this file (or a split is needed for import reasons), in which case we would need files Algebra.Order.BigOperators.Ring.AbsoluteValue.Finset, Algebra.Order.BigOperators.Ring.AbsoluteValue.Multiset, etc...
• Finsupp big operator and finprod/finsum order lemmas also belong in Algebra.Order.BigOperators. I haven't done so in this PR because the diff is big enough like that.

@@ -3,6 +3,7 @@ Copyright (c) 2020 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Devon Tuma, Oliver Nash
 -/
+import Mathlib.Algebra.Ring.Opposite
 import Mathlib.GroupTheory.Submonoid.Operations
 import Mathlib.GroupTheory.Submonoid.Membership
 import Mathlib.GroupTheory.Submonoid.MulOpposite
@@ -240,12 +241,6 @@ theorem nonZeroDivisors_le_comap_nonZeroDivisors_of_injective [NoZeroDivisors M'
   Submonoid.le_comap_of_map_le _ (map_le_nonZeroDivisors_of_injective _ hf le_rfl)
 #align non_zero_divisors_le_comap_non_zero_divisors_of_injective nonZeroDivisors_le_comap_nonZeroDivisors_of_injective
 
-@[deprecated Multiset.prod_eq_zero_iff] -- since 26 Dec 2023
-theorem prod_zero_iff_exists_zero [NoZeroDivisors M₁] [Nontrivial M₁] {s : Multiset M₁} :
-    s.prod = 0 ↔ ∃ (r : M₁) (_ : r ∈ s), r = 0 := by
-  simp [Multiset.prod_eq_zero_iff]
-#align prod_zero_iff_exists_zero prod_zero_iff_exists_zero
-
 end nonZeroDivisors
 
 section nonZeroSMulDivisors

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>

@@ -203,6 +203,8 @@ theorem mem_nonZeroDivisors_iff_ne_zero [NoZeroDivisors M] [Nontrivial M] {x : M
     x ∈ M⁰ ↔ x ≠ 0 := ⟨nonZeroDivisors.ne_zero, mem_nonZeroDivisors_of_ne_zero⟩
 #align mem_non_zero_divisors_iff_ne_zero mem_nonZeroDivisors_iff_ne_zero
 
+variable [FunLike F M M']
+
 theorem map_ne_zero_of_mem_nonZeroDivisors [Nontrivial M] [ZeroHomClass F M M'] (g : F)
     (hg : Function.Injective (g : M → M')) {x : M} (h : x ∈ M⁰) : g x ≠ 0 := fun h0 ↦
   one_ne_zero (h 1 ((one_mul x).symm ▸ hg (h0.trans (map_zero g).symm)))

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

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

@@ -5,7 +5,8 @@ Authors: Kenny Lau, Devon Tuma, Oliver Nash
 -/
 import Mathlib.GroupTheory.Submonoid.Operations
 import Mathlib.GroupTheory.Submonoid.Membership
-import Mathlib.GroupTheory.Subgroup.MulOpposite
+import Mathlib.GroupTheory.Submonoid.MulOpposite
+import Mathlib.GroupTheory.GroupAction.Opposite
 
 #align_import ring_theory.non_zero_divisors from "leanprover-community/mathlib"@"1126441d6bccf98c81214a0780c73d499f6721fe"
 

This PR defines the absolute ideal norm of a fractional ideal I : FractionalIdeal R⁰ K where K is a fraction field of R as a zero-preserving group homomorphism with values in ℚ and proves that it generalises the norm on (integral) ideals (and some other classical result).

Also in this PR:

• Add the directory Mathlib/RingTheory/FractionalIdeal and move the file Mathlib/RingTheory/FractionalIdeal.lean to Mathlib/RingTheory/FractionalIdeal/Basic.lean. The new results are in Mathlib/RingTheory/FractionalIdeal/Norm.lean
• Define the numerator and denominator of a fractional ideal. These are used to define the norm. Also define a linear equiv between a fractional ideal and its numerator.
• Several technical lemmas.

@@ -155,8 +155,11 @@ theorem dvd_cancel_left_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : r
 theorem dvd_cancel_left_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : c * x ∣ c * y ↔ x ∣ y :=
   dvd_cancel_left_mem_nonZeroDivisors c.prop
 
-theorem nonZeroDivisors.ne_zero [Nontrivial M] {x} (hx : x ∈ M⁰) : x ≠ 0 := fun h ↦
-  one_ne_zero (hx _ <| (one_mul _).trans h)
+theorem zero_not_mem_nonZeroDivisors [Nontrivial M] : 0 ∉ M⁰ :=
+  fun h ↦ one_ne_zero <| h 1 <| mul_zero _
+
+theorem nonZeroDivisors.ne_zero [Nontrivial M] {x} (hx : x ∈ M⁰) : x ≠ 0 :=
+  ne_of_mem_of_not_mem hx zero_not_mem_nonZeroDivisors
 #align non_zero_divisors.ne_zero nonZeroDivisors.ne_zero
 
 theorem nonZeroDivisors.coe_ne_zero [Nontrivial M] (x : M⁰) : (x : M) ≠ 0 :=

• Make Multiset.prod_eq_zero_iff a simp lemma.
• Golf and deprecate prod_zero_iff_exists_zero; it was a bad API version of Multiset.prod_eq_zero_iff.
• Make Ideal.mul_eq_bot a simp lemma`.
• Add Ideal.multiset_prod_eq_bot (a simp lemma), deprecate Ideal.prod_eq_bot.

The deprecated lemmas prod_zero_iff_exists_zero and Ideal.prod_eq_bot use ∃ x ∈ s, x = 0 instead of a simpler 0 ∈ s in the RHS.

@@ -234,22 +234,10 @@ theorem nonZeroDivisors_le_comap_nonZeroDivisors_of_injective [NoZeroDivisors M'
   Submonoid.le_comap_of_map_le _ (map_le_nonZeroDivisors_of_injective _ hf le_rfl)
 #align non_zero_divisors_le_comap_non_zero_divisors_of_injective nonZeroDivisors_le_comap_nonZeroDivisors_of_injective
 
+@[deprecated Multiset.prod_eq_zero_iff] -- since 26 Dec 2023
 theorem prod_zero_iff_exists_zero [NoZeroDivisors M₁] [Nontrivial M₁] {s : Multiset M₁} :
     s.prod = 0 ↔ ∃ (r : M₁) (_ : r ∈ s), r = 0 := by
-  constructor; swap
-  · rintro ⟨r, hrs, rfl⟩
-    exact Multiset.prod_eq_zero hrs
-  induction' s using Multiset.induction_on with a s ih
-  · intro habs
-    simp at habs
-  · rw [Multiset.prod_cons]
-    intro hprod
-    replace hprod := eq_zero_or_eq_zero_of_mul_eq_zero hprod
-    cases' hprod with ha hb
-    · exact ⟨a, Multiset.mem_cons_self a s, ha⟩
-    · apply (ih hb).imp _
-      rintro b ⟨hb₁, hb₂⟩
-      exact ⟨Multiset.mem_cons_of_mem hb₁, hb₂⟩
+  simp [Multiset.prod_eq_zero_iff]
 #align prod_zero_iff_exists_zero prod_zero_iff_exists_zero
 
 end nonZeroDivisors

Normalising to naming convention rule number 6.

@@ -265,13 +265,13 @@ lemma mem_nonZeroSMulDivisors_iff {x : R} : x ∈ R⁰[M] ↔ ∀ (m : M), x •
 variable (R)
 
 @[simp]
-lemma unop_nonZeroSmulDivisors_mulOpposite_eq_nonZeroDivisors :
+lemma unop_nonZeroSMulDivisors_mulOpposite_eq_nonZeroDivisors :
     (Rᵐᵒᵖ ⁰[R]).unop = R⁰ := rfl
 
 /-- The non-zero `•`-divisors with `•` as right multiplication correspond with the non-zero
 divisors. Note that the `MulOpposite` is needed because we defined `nonZeroDivisors` with
 multiplication on the right. -/
-lemma nonZeroSmulDivisors_mulOpposite_eq_op_nonZeroDivisors :
+lemma nonZeroSMulDivisors_mulOpposite_eq_op_nonZeroDivisors :
     Rᵐᵒᵖ ⁰[R] = R⁰.op := rfl
 
 end nonZeroSMulDivisors

Main changes:

• add Monic.mem_nonZeroDivisors and mem_nonZeroDivisors_of_leadingCoeff which states that a monic polynomial (resp. a polynomial whose leading coefficient is not zero divisor) is not a zero divisor.
• add rootMultiplicity_mul_X_sub_C_pow which states that * (X - a) ^ n adds the root multiplicity at a by n.
• change the conditions in rootMultiplicity_X_sub_C_self, rootMultiplicity_X_sub_C and rootMultiplicity_X_sub_C_pow from IsDomain to Nontrivial.
• add rootMultiplicity_eq_natTrailingDegree which relates rootMultiplicity and natTrailingDegree, and eval_divByMonic_eq_trailingCoeff_comp.
• add le_rootMultiplicity_mul which is similar to le_trailingDegree_mul.
• add rootMultiplicity_mul' which slightly generalizes rootMultiplicity_mul

In Data/Polynomial/FieldDivision:

• add rootMultiplicity_sub_one_le_derivative_rootMultiplicity_of_ne_zero which slightly generalizes rootMultiplicity_sub_one_le_derivative_rootMultiplicity.
• add derivative_rootMultiplicity_of_root_of_mem_nonZeroDivisors which slightly generalizes derivative_rootMultiplicity_of_root.
• add several theorems relating roots of iterate derivative to rootMultiplicity

In addition:

• move eq_of_monic_of_associated from RingDivision to Monic and generalize.
• add dvd_cancel lemmas to NonZeroDivisors.
• add algEquivOfCompEqX: two polynomials that compose to X both ways induces an isomorphism of the polynomial algebra.
• add divisibility lemmas to Polynomial/Derivative.

Co-authored-by: Junyan Xu <junyanxu.math@gmail.com>

@@ -141,6 +141,20 @@ theorem mul_cancel_left_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : (c : R') *
   mul_cancel_left_mem_nonZeroDivisors c.prop
 #align mul_cancel_left_coe_non_zero_divisor mul_cancel_left_coe_nonZeroDivisors
 
+theorem dvd_cancel_right_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : x * r ∣ y * r ↔ x ∣ y :=
+  ⟨fun ⟨z, _⟩ ↦ ⟨z, by rwa [← mul_cancel_right_mem_nonZeroDivisors hr, mul_assoc, mul_comm z r,
+    ← mul_assoc]⟩, fun ⟨z, h⟩ ↦ ⟨z, by rw [h, mul_assoc, mul_comm z r, ← mul_assoc]⟩⟩
+
+theorem dvd_cancel_right_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : x * c ∣ y * c ↔ x ∣ y :=
+  dvd_cancel_right_mem_nonZeroDivisors c.prop
+
+theorem dvd_cancel_left_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : r * x ∣ r * y ↔ x ∣ y :=
+  ⟨fun ⟨z, _⟩ ↦ ⟨z, by rwa [← mul_cancel_left_mem_nonZeroDivisors hr, ← mul_assoc]⟩,
+    fun ⟨z, h⟩ ↦ ⟨z, by rw [h, ← mul_assoc]⟩⟩
+
+theorem dvd_cancel_left_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : c * x ∣ c * y ↔ x ∣ y :=
+  dvd_cancel_left_mem_nonZeroDivisors c.prop
+
 theorem nonZeroDivisors.ne_zero [Nontrivial M] {x} (hx : x ∈ M⁰) : x ≠ 0 := fun h ↦
   one_ne_zero (hx _ <| (one_mul _).trans h)
 #align non_zero_divisors.ne_zero nonZeroDivisors.ne_zero

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

@@ -1,7 +1,7 @@
 /-
 Copyright (c) 2020 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kenny Lau, Devon Tuma
+Authors: Kenny Lau, Devon Tuma, Oliver Nash
 -/
 import Mathlib.GroupTheory.Submonoid.Operations
 import Mathlib.GroupTheory.Submonoid.Membership
@@ -13,7 +13,8 @@ import Mathlib.GroupTheory.Subgroup.MulOpposite
 # Non-zero divisors and smul-divisors
 
 In this file we define the submonoid `nonZeroDivisors` and `nonZeroSMulDivisors` of a
-`MonoidWithZero`.
+`MonoidWithZero`. We also define `nonZeroDivisorsLeft` and `nonZeroDivisorsRight` for
+non-commutative monoids.
 
 ## Notations
 
@@ -27,6 +28,50 @@ your own code.
 
 -/
 
+variable (M₀ : Type*) [MonoidWithZero M₀]
+
+/-- The collection of elements of a `MonoidWithZero` that are not left zero divisors form a
+`Submonoid`. -/
+def nonZeroDivisorsLeft : Submonoid M₀ where
+  carrier := {x | ∀ y, y * x = 0 → y = 0}
+  one_mem' := by simp
+  mul_mem' {x} {y} hx hy := fun z hz ↦ hx _ <| hy _ (mul_assoc z x y ▸ hz)
+
+@[simp] lemma mem_nonZeroDivisorsLeft_iff {x : M₀} :
+    x ∈ nonZeroDivisorsLeft M₀ ↔ ∀ y, y * x = 0 → y = 0 :=
+  Iff.rfl
+
+/-- The collection of elements of a `MonoidWithZero` that are not right zero divisors form a
+`Submonoid`. -/
+def nonZeroDivisorsRight : Submonoid M₀ where
+  carrier := {x | ∀ y, x * y = 0 → y = 0}
+  one_mem' := by simp
+  mul_mem' := fun {x} {y} hx hy z hz ↦ hy _ (hx _ ((mul_assoc x y z).symm ▸ hz))
+
+@[simp] lemma mem_nonZeroDivisorsRight_iff {x : M₀} :
+    x ∈ nonZeroDivisorsRight M₀ ↔ ∀ y, x * y = 0 → y = 0 :=
+  Iff.rfl
+
+lemma nonZeroDivisorsLeft_eq_right (M₀ : Type*) [CommMonoidWithZero M₀] :
+    nonZeroDivisorsLeft M₀ = nonZeroDivisorsRight M₀ := by
+  ext x; simp [mul_comm x]
+
+@[simp] lemma coe_nonZeroDivisorsLeft_eq [NoZeroDivisors M₀] [Nontrivial M₀] :
+    nonZeroDivisorsLeft M₀ = {x : M₀ | x ≠ 0} := by
+  ext x
+  simp only [SetLike.mem_coe, mem_nonZeroDivisorsLeft_iff, mul_eq_zero, forall_eq_or_imp, true_and,
+    Set.mem_setOf_eq]
+  refine' ⟨fun h ↦ _, fun hx y hx' ↦ by contradiction⟩
+  contrapose! h
+  exact ⟨1, h, one_ne_zero⟩
+
+@[simp] lemma coe_nonZeroDivisorsRight_eq [NoZeroDivisors M₀] [Nontrivial M₀] :
+    nonZeroDivisorsRight M₀ = {x : M₀ | x ≠ 0} := by
+  ext x
+  simp only [SetLike.mem_coe, mem_nonZeroDivisorsRight_iff, mul_eq_zero, Set.mem_setOf_eq]
+  refine' ⟨fun h ↦ _, fun hx y hx' ↦ by aesop⟩
+  contrapose! h
+  exact ⟨1, Or.inl h, one_ne_zero⟩
 
 /-- The submonoid of non-zero-divisors of a `MonoidWithZero` `R`. -/
 def nonZeroDivisors (R : Type*) [MonoidWithZero R] : Submonoid R where

If $R$ is a monoid with $0$ and $M$ an additive monoid with an $R$-action, then the set of non-zero smul-divisors of $R$ is a submonoid. for any $r \in R$, $r$ is a non-zero smul-divisors if and only if for any $m\in M$, $r \cdot m = 0$ implies $m = 0$. These elements are also called $M$-regular. They are useful in regular sequences.

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -5,26 +5,29 @@ Authors: Kenny Lau, Devon Tuma
 -/
 import Mathlib.GroupTheory.Submonoid.Operations
 import Mathlib.GroupTheory.Submonoid.Membership
+import Mathlib.GroupTheory.Subgroup.MulOpposite
 
 #align_import ring_theory.non_zero_divisors from "leanprover-community/mathlib"@"1126441d6bccf98c81214a0780c73d499f6721fe"
 
 /-!
-# Non-zero divisors
+# Non-zero divisors and smul-divisors
 
-In this file we define the submonoid `nonZeroDivisors` of a `MonoidWithZero`.
+In this file we define the submonoid `nonZeroDivisors` and `nonZeroSMulDivisors` of a
+`MonoidWithZero`.
 
 ## Notations
 
-This file declares the notation `R⁰` for the submonoid of non-zero-divisors of `R`,
-in the locale `nonZeroDivisors`.
+This file declares the notations:
+- `R⁰` for the submonoid of non-zero-divisors of `R`, in the locale `nonZeroDivisors`.
+- `R⁰[M]` for the submonoid of non-zero smul-divisors of `R` with respect to `M`, in the locale
+  `nonZeroSMulDivisors`
 
-Use the statement `open nonZeroDivisors` to access this notation in your own code.
+Use the statement `open scoped nonZeroDivisors nonZeroSMulDivisors` to access this notation in
+your own code.
 
 -/
 
 
-section nonZeroDivisors
-
 /-- The submonoid of non-zero-divisors of a `MonoidWithZero` `R`. -/
 def nonZeroDivisors (R : Type*) [MonoidWithZero R] : Submonoid R where
   carrier := { x | ∀ z, z * x = 0 → z = 0 }
@@ -37,6 +40,19 @@ def nonZeroDivisors (R : Type*) [MonoidWithZero R] : Submonoid R where
 /-- The notation for the submonoid of non-zerodivisors. -/
 scoped[nonZeroDivisors] notation:9000 R "⁰" => nonZeroDivisors R
 
+/-- Let `R` be a monoid with zero and `M` an additive monoid with an `R`-action, then the collection
+of non-zero smul-divisors forms a submonoid. These elements are also called `M`-regular.-/
+def nonZeroSMulDivisors (R : Type*) [MonoidWithZero R] (M : Type _) [Zero M] [MulAction R M] :
+    Submonoid R where
+  carrier := { r | ∀ m : M, r • m = 0 → m = 0}
+  one_mem' m h := (one_smul R m) ▸ h
+  mul_mem' {r₁ r₂} h₁ h₂ m H := h₂ _ <| h₁ _ <| mul_smul r₁ r₂ m ▸ H
+
+/-- The notation for the submonoid of non-zero smul-divisors. -/
+scoped[nonZeroSMulDivisors] notation:9000 R "⁰[" M "]" => nonZeroSMulDivisors R M
+
+section nonZeroDivisors
+
 open nonZeroDivisors
 
 variable {M M' M₁ R R' F : Type*} [MonoidWithZero M] [MonoidWithZero M'] [CommMonoidWithZero M₁]
@@ -178,3 +194,25 @@ theorem prod_zero_iff_exists_zero [NoZeroDivisors M₁] [Nontrivial M₁] {s : M
 #align prod_zero_iff_exists_zero prod_zero_iff_exists_zero
 
 end nonZeroDivisors
+
+section nonZeroSMulDivisors
+
+open nonZeroSMulDivisors nonZeroDivisors
+
+variable {R M : Type*} [MonoidWithZero R] [Zero M] [MulAction R M]
+
+lemma mem_nonZeroSMulDivisors_iff {x : R} : x ∈ R⁰[M] ↔ ∀ (m : M), x • m = 0 → m = 0 := Iff.rfl
+
+variable (R)
+
+@[simp]
+lemma unop_nonZeroSmulDivisors_mulOpposite_eq_nonZeroDivisors :
+    (Rᵐᵒᵖ ⁰[R]).unop = R⁰ := rfl
+
+/-- The non-zero `•`-divisors with `•` as right multiplication correspond with the non-zero
+divisors. Note that the `MulOpposite` is needed because we defined `nonZeroDivisors` with
+multiplication on the right. -/
+lemma nonZeroSmulDivisors_mulOpposite_eq_op_nonZeroDivisors :
+    Rᵐᵒᵖ ⁰[R] = R⁰.op := rfl
+
+end nonZeroSMulDivisors

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

This has nice performance benefits.

@@ -26,7 +26,7 @@ Use the statement `open nonZeroDivisors` to access this notation in your own cod
 section nonZeroDivisors
 
 /-- The submonoid of non-zero-divisors of a `MonoidWithZero` `R`. -/
-def nonZeroDivisors (R : Type _) [MonoidWithZero R] : Submonoid R where
+def nonZeroDivisors (R : Type*) [MonoidWithZero R] : Submonoid R where
   carrier := { x | ∀ z, z * x = 0 → z = 0 }
   one_mem' _ hz := by rwa [mul_one] at hz
   mul_mem' hx₁ hx₂ _ hz := by
@@ -39,7 +39,7 @@ scoped[nonZeroDivisors] notation:9000 R "⁰" => nonZeroDivisors R
 
 open nonZeroDivisors
 
-variable {M M' M₁ R R' F : Type _} [MonoidWithZero M] [MonoidWithZero M'] [CommMonoidWithZero M₁]
+variable {M M' M₁ R R' F : Type*} [MonoidWithZero M] [MonoidWithZero M'] [CommMonoidWithZero M₁]
   [Ring R] [CommRing R']
 
 theorem mem_nonZeroDivisors_iff {r : M} : r ∈ M⁰ ↔ ∀ x, x * r = 0 → x = 0 := Iff.rfl
@@ -100,7 +100,7 @@ theorem mul_mem_nonZeroDivisors {a b : M₁} : a * b ∈ M₁⁰ ↔ a ∈ M₁
     rw [mul_assoc, hx]
 #align mul_mem_non_zero_divisors mul_mem_nonZeroDivisors
 
-theorem isUnit_of_mem_nonZeroDivisors {G₀ : Type _} [GroupWithZero G₀] {x : G₀}
+theorem isUnit_of_mem_nonZeroDivisors {G₀ : Type*} [GroupWithZero G₀] {x : G₀}
     (hx : x ∈ nonZeroDivisors G₀) : IsUnit x :=
   ⟨⟨x, x⁻¹, mul_inv_cancel (nonZeroDivisors.ne_zero hx),
     inv_mul_cancel (nonZeroDivisors.ne_zero hx)⟩, rfl⟩

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Kenny Lau. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kenny Lau, Devon Tuma
-
-! This file was ported from Lean 3 source module ring_theory.non_zero_divisors
-! leanprover-community/mathlib commit 1126441d6bccf98c81214a0780c73d499f6721fe
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.GroupTheory.Submonoid.Operations
 import Mathlib.GroupTheory.Submonoid.Membership
 
+#align_import ring_theory.non_zero_divisors from "leanprover-community/mathlib"@"1126441d6bccf98c81214a0780c73d499f6721fe"
+
 /-!
 # Non-zero divisors
 

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

@@ -65,8 +65,7 @@ theorem mul_left_coe_nonZeroDivisors_eq_zero_iff {c : M₁⁰} {x : M₁} : (c :
   mul_left_mem_nonZeroDivisors_eq_zero_iff c.prop
 #align mul_left_coe_non_zero_divisors_eq_zero_iff mul_left_coe_nonZeroDivisors_eq_zero_iff
 
-theorem mul_cancel_right_mem_nonZeroDivisors {x y r : R} (hr : r ∈ R⁰) : x * r = y * r ↔ x = y :=
-  by
+theorem mul_cancel_right_mem_nonZeroDivisors {x y r : R} (hr : r ∈ R⁰) : x * r = y * r ↔ x = y := by
   refine ⟨fun h ↦ ?_, congrArg (· * r)⟩
   rw [← sub_eq_zero, ← mul_right_mem_nonZeroDivisors_eq_zero_iff hr, sub_mul, h, sub_self]
 #align mul_cancel_right_mem_non_zero_divisor mul_cancel_right_mem_nonZeroDivisors

This PR fixes two things:

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

@@ -161,8 +161,7 @@ theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroH
 theorem nonZeroDivisors_le_comap_nonZeroDivisors_of_injective [NoZeroDivisors M']
     [MonoidWithZeroHomClass F M M'] (f : F) (hf : Function.Injective f) : M⁰ ≤ M'⁰.comap f :=
   Submonoid.le_comap_of_map_le _ (map_le_nonZeroDivisors_of_injective _ hf le_rfl)
-#align non_zero_divisors_le_comap_non_zero_divisors_of_injective
-  nonZeroDivisors_le_comap_nonZeroDivisors_of_injective
+#align non_zero_divisors_le_comap_non_zero_divisors_of_injective nonZeroDivisors_le_comap_nonZeroDivisors_of_injective
 
 theorem prod_zero_iff_exists_zero [NoZeroDivisors M₁] [Nontrivial M₁] {s : Multiset M₁} :
     s.prod = 0 ↔ ∃ (r : M₁) (_ : r ∈ s), r = 0 := by

@@ -29,8 +29,7 @@ Use the statement `open nonZeroDivisors` to access this notation in your own cod
 section nonZeroDivisors
 
 /-- The submonoid of non-zero-divisors of a `MonoidWithZero` `R`. -/
-def nonZeroDivisors (R : Type _) [MonoidWithZero R] : Submonoid R
-    where
+def nonZeroDivisors (R : Type _) [MonoidWithZero R] : Submonoid R where
   carrier := { x | ∀ z, z * x = 0 → z = 0 }
   one_mem' _ hz := by rwa [mul_one] at hz
   mul_mem' hx₁ hx₂ _ hz := by
@@ -38,7 +37,6 @@ def nonZeroDivisors (R : Type _) [MonoidWithZero R] : Submonoid R
     exact hx₁ _ (hx₂ _ hz)
 #align non_zero_divisors nonZeroDivisors
 
--- mathport name: non_zero_divisors
 /-- The notation for the submonoid of non-zerodivisors. -/
 scoped[nonZeroDivisors] notation:9000 R "⁰" => nonZeroDivisors R
 
@@ -67,24 +65,24 @@ theorem mul_left_coe_nonZeroDivisors_eq_zero_iff {c : M₁⁰} {x : M₁} : (c :
   mul_left_mem_nonZeroDivisors_eq_zero_iff c.prop
 #align mul_left_coe_non_zero_divisors_eq_zero_iff mul_left_coe_nonZeroDivisors_eq_zero_iff
 
-theorem mul_cancel_right_mem_non_zero_divisor {x y r : R} (hr : r ∈ R⁰) : x * r = y * r ↔ x = y :=
+theorem mul_cancel_right_mem_nonZeroDivisors {x y r : R} (hr : r ∈ R⁰) : x * r = y * r ↔ x = y :=
   by
   refine ⟨fun h ↦ ?_, congrArg (· * r)⟩
   rw [← sub_eq_zero, ← mul_right_mem_nonZeroDivisors_eq_zero_iff hr, sub_mul, h, sub_self]
-#align mul_cancel_right_mem_non_zero_divisor mul_cancel_right_mem_non_zero_divisor
+#align mul_cancel_right_mem_non_zero_divisor mul_cancel_right_mem_nonZeroDivisors
 
-theorem mul_cancel_right_coe_non_zero_divisor {x y : R} {c : R⁰} : x * c = y * c ↔ x = y :=
-  mul_cancel_right_mem_non_zero_divisor c.prop
-#align mul_cancel_right_coe_non_zero_divisor mul_cancel_right_coe_non_zero_divisor
+theorem mul_cancel_right_coe_nonZeroDivisors {x y : R} {c : R⁰} : x * c = y * c ↔ x = y :=
+  mul_cancel_right_mem_nonZeroDivisors c.prop
+#align mul_cancel_right_coe_non_zero_divisor mul_cancel_right_coe_nonZeroDivisors
 
 @[simp]
-theorem mul_cancel_left_mem_non_zero_divisor {x y r : R'} (hr : r ∈ R'⁰) : r * x = r * y ↔ x = y :=
-  by simp_rw [mul_comm r, mul_cancel_right_mem_non_zero_divisor hr]
-#align mul_cancel_left_mem_non_zero_divisor mul_cancel_left_mem_non_zero_divisor
+theorem mul_cancel_left_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : r * x = r * y ↔ x = y :=
+  by simp_rw [mul_comm r, mul_cancel_right_mem_nonZeroDivisors hr]
+#align mul_cancel_left_mem_non_zero_divisor mul_cancel_left_mem_nonZeroDivisors
 
-theorem mul_cancel_left_coe_non_zero_divisor {x y : R'} {c : R'⁰} : (c : R') * x = c * y ↔ x = y :=
-  mul_cancel_left_mem_non_zero_divisor c.prop
-#align mul_cancel_left_coe_non_zero_divisor mul_cancel_left_coe_non_zero_divisor
+theorem mul_cancel_left_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : (c : R') * x = c * y ↔ x = y :=
+  mul_cancel_left_mem_nonZeroDivisors c.prop
+#align mul_cancel_left_coe_non_zero_divisor mul_cancel_left_coe_nonZeroDivisors
 
 theorem nonZeroDivisors.ne_zero [Nontrivial M] {x} (hx : x ∈ M⁰) : x ≠ 0 := fun h ↦
   one_ne_zero (hx _ <| (one_mul _).trans h)
@@ -167,7 +165,7 @@ theorem nonZeroDivisors_le_comap_nonZeroDivisors_of_injective [NoZeroDivisors M'
   nonZeroDivisors_le_comap_nonZeroDivisors_of_injective
 
 theorem prod_zero_iff_exists_zero [NoZeroDivisors M₁] [Nontrivial M₁] {s : Multiset M₁} :
-    s.prod = 0 ↔ ∃ (r : M₁)(_ : r ∈ s), r = 0 := by
+    s.prod = 0 ↔ ∃ (r : M₁) (_ : r ∈ s), r = 0 := by
   constructor; swap
   · rintro ⟨r, hrs, rfl⟩
     exact Multiset.prod_eq_zero hrs

Co-authored-by: Eric Rodriguez <37984851+ericrbg@users.noreply.github.com>